Comment utiliser des carnets exploratoires [Meilleures pratiques]

Utilisation optimale des carnets exploratoires Guide des meilleures pratiques

Les notebooks Jupyter ont été l’un des outils les plus controversés dans la communauté de la science des données. Il y a des critiques fervents, ainsi que des fans passionnés. Néanmoins, de nombreux data scientists conviendront qu’ils peuvent être vraiment précieux – s’ils sont bien utilisés. Et c’est ce sur quoi nous allons nous concentrer dans cet article, qui est le deuxième de ma série sur les Modèles logiciels pour la science des données et l’ingénierie de l’apprentissage automatique. Je vous montrerai les meilleures pratiques pour utiliser les notebooks Jupyter pour l’analyse exploratoire des données.

Mais d’abord, nous devons comprendre pourquoi les notebooks ont été établis dans la communauté scientifique. Lorsque la science des données était sexy, les notebooks n’existaient pas encore. Avant eux, nous avions IPython, intégré dans des IDE comme Spyder, qui essayaient de reproduire le fonctionnement de RStudio ou Matlab. Ces outils ont été largement adoptés par les chercheurs.

En 2014, projet Jupyter a évolué à partir d’IPython. Son utilisation a explosé, principalement grâce aux chercheurs qui sont passés travailler dans l’industrie. Cependant, les approches d’utilisation des notebooks qui fonctionnent bien pour les projets scientifiques ne se traduisent pas nécessairement bien dans les analyses menées pour les unités commerciales et produits des entreprises. Il n’est pas rare que des data scientists fraîchement embauchés en sortie d’université aient du mal à répondre aux nouvelles attentes liées à la structure et à la présentation de leurs analyses.

Dans cet article, nous parlerons spécifiquement des notebooks Jupyter d’un point de vue commercial et produit. Comme je l’ai déjà mentionné, les notebooks Jupyter sont un sujet polarisant, donc allons droit au but avec mon opinion.

Les notebooks Jupyter ne devraient être utilisés que pour des tâches purément exploratoires ou des analyses ad hoc UNIQUEMENT.

Un notebook ne devrait être rien de plus qu’un rapport. Le code qu’il contient ne devrait pas être important du tout. Ce sont seulement les résultats qu’il génère qui comptent. Idéalement, nous devrions pouvoir cacher le code dans le notebook car il n’est qu’un moyen de répondre aux questions.

Par exemple : Quelles sont les caractéristiques statistiques de ces tables ? Quelles sont les propriétés de cet ensemble de données d’entraînement ? Quel est l’impact de mettre ce modèle en production ? Comment pouvons-nous nous assurer que ce modèle surpasse le précédent ? Comment la test AB s’est-elle déroulée ?

Les notebooks Jupyter sont utiles dans différents domaines et pour différentes utilisations
Les notebooks Jupyter sont utiles dans différents domaines et pour différentes utilisations | Source : Auteur

Notebook Jupyter : lignes directrices pour une narration efficace

Rédiger des notebooks Jupyter revient essentiellement à raconter une histoire ou répondre à une question sur un problème que vous avez étudié. Mais cela ne signifie pas que vous devez montrer le travail explicite que vous avez réalisé pour parvenir à votre conclusion.

Les notebooks doivent être affinés.

Ils sont principalement créés pour que l’auteur comprenne un problème, mais aussi pour que leurs pairs acquièrent cette connaissance sans avoir à plonger profondément dans le problème eux-mêmes.

Portée

La nature non linéaire et arborescente de l’exploration des ensembles de données dans les notebooks, qui contiennent généralement des sections d’exploration sans pertinence qui n’ont abouti à aucune réponse, n’est pas la façon dont le notebook devrait apparaître à la fin. Le notebook devrait contenir le contenu minimal qui répond le mieux aux questions posées. Vous devriez toujours commenter et donner des justifications sur chacune des hypothèses et conclusions. Les résumés exécutifs sont toujours recommandés car ils sont parfaits pour les parties prenantes qui ont un intérêt vague pour le sujet ou un temps limité. Ils sont également un excellent moyen de préparer les pairs évaluateurs à une plongée complète dans le notebook.

Public

Le public des notebooks est généralement assez technique ou a une vision commerciale. Par conséquent, il est attendu que vous utilisiez un vocabulaire avancé. Néanmoins, les résumés exécutifs ou les conclusions doivent toujours être rédigés dans un langage simple et faire le lien avec des sections contenant des explications plus approfondies. Si vous avez du mal à créer un notebook pour un public non technique, vous voudrez peut-être envisager de créer une présentation diapositives à la place. Vous pouvez y utiliser des infographies, des visualisations personnalisées et des moyens plus larges pour expliquer vos idées.

Les différentes parties prenantes d'un scientifique des données ont toutes des demandes différentes
Les différentes parties prenantes d’un scientifique des données ont toutes des demandes différentes | Source: Auteur

Contexte

Toujours fournir un contexte pour le problème en question. Les données seules ne suffisent pas pour raconter une histoire cohérente. Nous devons encadrer toute l’analyse dans le domaine dans lequel nous travaillons afin que le public se sente à l’aise en le lisant. Utilisez des liens vers la base de connaissances existante de l’entreprise pour étayer vos déclarations et rassemblez toutes les références dans une section dédiée du notebook.

Comment structurer le contenu d’un notebook Jupyter

Dans cette section, j’expliquerai la disposition du notebook que j’utilise généralement. Cela peut sembler beaucoup de travail, mais je recommande de créer un modèle de notebook avec les sections suivantes, en laissant des espaces réservés pour les spécificités de votre tâche. Un tel modèle personnalisé vous fera gagner beaucoup de temps et assurera une cohérence entre les notebooks.

  1. Titre : Idéalement, le nom de la tâche JIRA associée (ou tout autre logiciel de suivi des problèmes) liée à la tâche. Cela vous permet, ainsi qu’à votre public, de relier de manière non ambiguë la réponse (le notebook) à la question (la tâche JIRA).
  2. Description : Quel est l’objectif de cette tâche ? Cela doit être très bref.
  3. Table des matières : Les entrées doivent être des liens vers les sections du notebook, permettant au lecteur de passer à la partie qui l’intéresse. (Jupyter crée des ancres HTML pour chaque titre en utilisant le titre original en minuscules avec les espaces remplacés par des tirets, ainsi vous pouvez y accéder avec des liens Markdown simples tels que [titre de la section](#titre-de-la-section). Vous pouvez également placer vos propres ancres en ajoutant <a id=’votre-ancre’></a> aux cellules Markdown.)
  4. Références : Liens vers une documentation interne ou externe contenant des informations de fond ou des informations spécifiques utilisées dans l’analyse présentée dans le notebook.
  5. TL;DR ou Résumé exécutif : Expliquez de manière très concise les résultats de toute l’exploration et mettez en évidence les conclusions clés (ou questions) auxquelles vous êtes parvenu.
  6. Introduction & Contexte : Mettez la tâche en contexte, ajoutez des informations sur les précédents commerciaux clés liés au problème et expliquez la tâche plus en détail.
  7. Imports : Importations de bibliothèques et paramètres. Configurez les paramètres des bibliothèques tierces, telles que matplotlib ou seaborn. Ajoutez des variables d’environnement, telles que des dates, pour fixer la fenêtre d’exploration.
  8. Données à explorer : Présentez les tables ou les ensembles de données que vous explorez/analysez et référencez leurs sources ou liez leurs entrées dans le catalogue de données. Idéalement, vous indiquez comment chaque ensemble de données ou table est créé et à quelle fréquence il est mis à jour. Vous pouvez lier cette section à tout autre document.
  9. Cellules d’analyse
  10. Conclusion : Explication détaillée des principaux résultats que vous avez obtenus dans la section Analyse, avec des liens vers les parties spécifiques du notebook où les lecteurs peuvent trouver des explications supplémentaires.

N’oubliez pas d’utiliser toujours la mise en forme Markdown pour les en-têtes et pour mettre en évidence les déclarations et citations importantes. Vous pouvez consulter les différentes options de syntaxe Markdown dans la documentation des cellules Markdown – Jupyter Notebook 6.5.2.

Exemple de modèle pour un notebook d'exploration
Exemple de modèle pour un notebook d’exploration | Source : Auteur

Comment organiser le code dans un notebook Jupyter

Pour les tâches d’exploration, le code pour produire des requêtes SQL, le formatage des données dans pandas, ou créer des graphiques n’est pas important pour les lecteurs.

Cependant, il est important pour les relecteurs, nous devons donc maintenir une qualité et une lisibilité élevées.

Voici mes conseils pour travailler avec du code dans des notebooks :

Déplacez les fonctions auxiliaires vers des modules Python simples

En général, il est préférable d’importer les fonctions définies dans des modules Python plutôt que de les définir dans le notebook. Tout d’abord, les différences dans les fichiers .py sont beaucoup plus faciles à lire que les différences dans les notebooks. Le lecteur n’a pas besoin de connaître le fonctionnement interne d’une fonction pour suivre le notebook.

Par exemple, vous avez généralement des fonctions pour lire vos données, exécuter des requêtes SQL et prétraiter, transformer ou enrichir votre ensemble de données. Toutes ces fonctions doivent être déplacées dans des fichiers .py, puis importées dans le notebook afin que les lecteurs ne voient que l’appel de la fonction. Si un examinateur souhaite obtenir plus de détails, il peut toujours consulter directement le module Python.

Je trouve cela particulièrement utile pour les fonctions de visualisation, par exemple. Il est courant que je puisse réutiliser la même fonction pour créer plusieurs fois un diagramme à barres dans mon notebook. Je devrai apporter de petites modifications, comme utiliser un ensemble de données différent ou un titre différent, mais la mise en page et le style général du graphique seront les mêmes. Au lieu de copier et coller le même extrait de code, je crée simplement un module utils/plots.py et je crée des fonctions qui peuvent être importées et adaptées en fournissant des arguments.

Voici un exemple très simple :

import matplotlib.pyplot as plt
import numpy as np
 
def create_barplot(data, x_labels, title='', xlabel='', ylabel='', bar_color='b', bar_width=0.8, style='seaborn', figsize=(8, 6)):
    """Crée un diagramme à barres personnalisable avec Matplotlib.
 
    Paramètres :
    - data : Liste ou tableau des données à tracer.
    - x_labels : Liste des libellés de l'axe des x.
    - title : Titre du graphique.
    - xlabel : Libellé de l'axe des x.
    - ylabel : Libellé de l'axe des y.
    - bar_color : Couleur des barres (par défaut : bleu).
    - bar_width : Largeur des barres (par défaut : 0,8).
    - style : Style Matplotlib à appliquer (par exemple, 'seaborn', 'ggplot', 'default').
    - figsize : Tuple spécifiant la taille du graphique (largeur, hauteur).
 
    Renvoie :
    - None
    """
    # Définir le style de Matplotlib
    plt.style.use(style)
 
    # Créer une figure et un axe
    fig, ax = plt.subplots(figsize=figsize)
 
    # Générer les positions x des barres
    x = np.arange(len(data))
 
    # Créer le diagramme à barres
    ax.bar(x, data, color=bar_color, width=bar_width)
 
    # Définir les libellés de l'axe des x
    ax.set_xticks(x)
    ax.set_xticklabels(x_labels)
 
    # Définir les labels et le titre
    ax.set_xlabel(xlabel)
    ax.set_ylabel(ylabel)
    ax.set_title(title)
 
    # Afficher le graphique
    plt.show()
 
# Exemple d'utilisation dans une cellule du notebook :
create_barplot(
    data,
    x_labels,
    title="Diagramme à barres personnalisé",
    xlabel="Catégories",
    ylabel="Valeurs",
    bar_color="skyblue",
    bar_width=0.6,
    style="seaborn",
    figsize=(10,6)
)

Lors de la création de ces modules Python, gardez à l’esprit que le code fait toujours partie d’une analyse exploratoire. Donc, à moins que vous ne l’utilisiez dans une autre partie du projet, il n’a pas besoin d’être parfait. Il doit simplement être suffisamment lisible et compréhensible pour vos examinateurs.

Placer les fonctions de visualisation, de chargement des données, de préparation des données et d'implémentation des métriques d'évaluation dans des modules Python simples permet de rendre un notebook Jupyter axé sur l'analyse exploratoire
Placer les fonctions de visualisation, de chargement des données, de préparation des données et d’implémentation des métriques d’évaluation dans des modules Python simples permet de rendre un notebook Jupyter axé sur l’analyse exploratoire | Source : Auteur

Utilisation directe de SQL dans les cellules Jupyter

Il existe des cas où les données ne sont pas en mémoire (par exemple, dans un DataFrame pandas) mais dans l’entrepôt de données de l’entreprise (par exemple, Redshift). Dans ces cas, la plupart de l’exploration et de la manipulation des données se fera via SQL.

Il existe plusieurs façons d’utiliser SQL avec les notebooks Jupyter. JupySQL vous permet d’écrire du code SQL directement dans les cellules du notebook et affiche le résultat de la requête comme s’il s’agissait d’un DataFrame pandas. Vous pouvez également stocker des scripts SQL dans des fichiers accompagnants ou dans les modules Python auxiliaires dont nous avons discuté dans la section précédente.

Que ce soit préférable d’utiliser l’un ou l’autre dépend principalement de votre objectif :

Si vous effectuez une exploration de données sur plusieurs tables d’un entrepôt de données et que vous voulez montrer à vos pairs la qualité et la validité des données, alors afficher les requêtes SQL dans le notebook est généralement la meilleure option. Vos relecteurs apprécieront de pouvoir voir directement comment vous avez interrogé ces tables, quelles sortes de jointures vous avez dû effectuer pour arriver à certaines vues, quels filtres vous avez dû appliquer, etc.

Cependant, si vous ne faites que générer un ensemble de données pour valider un modèle d’apprentissage automatique et que l’objectif principal du notebook est de montrer différentes mesures et sorties explicatives, alors je recommanderais de masquer autant que possible l’extraction des données et de garder les requêtes dans un script SQL séparé ou un module Python.

Nous allons maintenant voir un exemple de comment utiliser les deux options.

Lecture et exécution à partir de scripts .sql

Nous pouvons utiliser des fichiers .sql qui sont ouverts et exécutés à partir du notebook grâce à une bibliothèque de connecteurs de base de données.

Disons que nous avons la requête suivante dans un fichier select_purchases.sql :

SELECT * FROM public.ecommerce_purchases WHERE product_id = 123

Ensuite, nous pourrions définir une fonction pour exécuter des scripts SQL:

import psycopg2
 
def execute_sql_script(filename, connection_params):
    """
    Exécuter un script SQL à partir d'un fichier en utilisant psycopg2.
 
    Paramètres:
    - filename: Le nom du fichier script SQL à exécuter.
    - connection_params: Un dictionnaire contenant les paramètres de connexion PostgreSQL,
                        tels que 'host', 'port', 'database', 'user' et 'password'.
 
    Renvoie:
    - Rien
    """
    # Extraire les paramètres de connexion
    host = connection_params.get('host', 'localhost')
    port = connection_params.get('port', '5432')
    database = connection_params.get('database', '')
    user = connection_params.get('user', '')
    password = connection_params.get('password', '')
 
    # Établir une connexion avec la base de données
    try:
        conn = psycopg2.connect(
            host=host,
            port=port,
            database=database,
            user=user,
            password=password
        )
        cursor = conn.cursor()
 
        # Lire et exécuter le script SQL
        with open(filename, 'r') as sql_file:
            sql_script = sql_file.read()
            cursor.execute(sql_script)
        
        # Récupérer le résultat dans un DataFrame Pandas
        result = cursor.fetchall()
        column_names = [desc[0] for desc in cursor.description]
        df = pd.DataFrame(result, columns=column_names)

        # Valider les modifications et fermer la connexion
        conn.commit()
        conn.close()
        return df

    except Exception as e:
        print(f"Erreur : {e}")
        if 'conn' in locals():
            conn.rollback()
            conn.close()

Notez que nous avons fourni des valeurs par défaut pour les paramètres de connexion à la base de données afin de ne pas avoir à les spécifier à chaque fois. Cependant, veillez à ne jamais stocker de secrets ou d’autres informations sensibles dans vos scripts Python ! (Plus tard dans la série, nous discuterons de différentes solutions à ce problème.)

Maintenant, nous pouvons utiliser la commande suivante d’une seule ligne dans notre notebook pour exécuter le script :

df = execute_sql_script('select_purchases.sql', connection_params)

Utilisation de JupySQL

Traditionnellement, ipython-sql a été l’outil de choix pour interroger SQL à partir de notebooks Jupyter. Mais il a été abandonné par son créateur d’origine en avril 2023, qui recommande de passer à JupySQL, qui est un fork maintenu activement. À l’avenir, toutes les améliorations et nouvelles fonctionnalités ne seront ajoutées qu’à JupySQL.

Pour installer la bibliothèque pour l’utiliser avec Redshift, nous devons faire :

pip install jupysql sqlalchemy-redshift redshift-connector 'sqlalchemy<2'

(Vous pouvez également l’utiliser avec d’autres bases de données telles que snowflake ou duckdb,)

Dans votre notebook Jupyter, vous pouvez maintenant utiliser la commande magique %load_ext sql pour activer SQL et utiliser le snippet suivant pour créer un moteur Redshift avec sqlalchemy:

from os import environ
from sqlalchemy import create_engine
from sqlalchemy.engine import URL

user = environ["REDSHIFT_USERNAME"]
password = environ["REDSHIFT_PASSWORD"]
host = environ["REDSHIFT_HOST"]

url = URL.create(
    drivername="redshift+redshift_connector",
    username=user,
    password=password,
    host=host,
    port=5439,
    database="dev",
)

engine = create_engine(url)

Ensuite, il suffit de passer le moteur à la commande magique:

%sql engine --alias redshift-sqlalchemy

Et vous êtes prêt à partir!

Maintenant, c’est aussi simple que d’utiliser la commande magique et d’écrire la requête que vous souhaitez exécuter, vous obtiendrez les résultats dans la sortie de la cellule:

%sql
SELECT * FROM public.ecommerce_purchases WHERE product_id = 123

Assurez-vous que les cellules sont exécutées dans l’ordre

Je vous recommande de toujours exécuter toutes les cellules de code avant de pousser le notebook dans votre dépôt. Les notebooks Jupyter enregistrent l’état de sortie de chaque cellule lorsqu’elle est exécutée. Cela signifie que le code que vous avez écrit ou modifié peut ne pas correspondre à la sortie affichée de la cellule.

Exécuter un notebook du début à la fin est également un bon test pour vérifier si votre notebook dépend de toute entrée utilisateur pour s’exécuter correctement. Idéalement, tout devrait s’exécuter sans votre intervention. Sinon, votre analyse n’est probablement pas reproductible par d’autres personnes – ou même par votre propre future personne.

Une façon de vérifier qu’un notebook a été exécuté dans l’ordre est d’utiliser le hook pre-commit nbcheckorder. Il vérifie si les numéros de sortie des cellules sont séquentiels. S’ils ne le sont pas, cela indique que les cellules du notebook n’ont pas été exécutées les unes après les autres et empêche la validation Git de se poursuivre.

Exemple de fichier .pre-commit-config.yaml :

- repo: local
   rev: v0.2.0
   hooks:
     - id: nbcheckorder

Si vous n’utilisez pas encore pre-commit, je vous recommande vivement d’adopter cet outil. Je vous recommande de commencer à en apprendre davantage à ce sujet grâce à cette introduction à pre-commit d’Elliot Jordan. Ensuite, vous pouvez consulter sa documentation étendue pour comprendre toutes ses fonctionnalités.

Effacez la sortie des cellules

Mieux encore que le conseil précédent, effacez toute la sortie des cellules dans le notebook. Un avantage que vous obtenez est que vous pouvez ignorer les états et les sorties des cellules, mais d’un autre côté, cela force les examinateurs à exécuter le code en local s’ils veulent voir les résultats. Il existe plusieurs façons de le faire automatiquement.

Vous pouvez utiliser le hook pre-commit nbstripout conjointement avec pre-commit, comme expliqué par Florian Rathgeber, l’auteur de l’outil, sur GitHub:

- repo: local
  rev: 0.6.1
  hooks:
    - id: nbstripout

Vous pouvez également utiliser nbconvert –ClearOutputpPreprocessor dans un hook pre-commit personnalisé, comme expliqué par Yury Zhauniarovich:

- repo: local
    hooks:
      - id: jupyter-nb-clear-output
        name: jupyter-nb-clear-output
        files: \.ipynb$
        stages: [ commit ]
        language: python
        entry: jupyter nbconvert --ClearOutputPreprocessor.enabled=True --inplace
        additional_dependencies: [ 'nbconvert' ]

Produire et partager des rapports avec Jupyter notebook

Maintenant, voici une question assez mal résolue dans l’industrie. Quelle est la meilleure façon de partager vos notebooks avec votre équipe et les parties prenantes externes?

En ce qui concerne le partage des analyses à partir des cahiers Jupyter, le domaine est divisé en trois types d’équipes différentes qui favorisent différentes façons de travailler.

Les équipes de traduction

Ces équipes pensent que les personnes des unités commerciales ou des produits ne seront pas à l’aise pour lire les cahiers Jupyter. Par conséquent, ils adaptent leurs analyses et rapports à leur public cible.

Les équipes de traduction prennent leurs conclusions à partir des cahiers Jupyter et les ajoutent au système de connaissances de leur entreprise (par exemple, Confluence, Google Slides, etc.). Comme effet secondaire négatif, elles perdent une partie de la traçabilité des cahiers, car il devient maintenant plus difficile de consulter l’historique des versions du rapport. Mais, elles soutiendront, elles sont capables de transmettre leurs résultats et analyses de manière plus efficace aux parties prenantes concernées.

Si vous souhaitez faire cela, je vous recommande de garder un lien entre le document exporté et le cahier Jupyter afin qu’ils soient toujours synchronisés. Dans cette configuration, vous pouvez garder des cahiers avec moins de texte et de conclusions, axés davantage sur les faits bruts ou les preuves de données. Vous utiliserez le système de documentation pour développer le résumé exécutif et les commentaires sur chacune des conclusions. De cette manière, vous pouvez dissocier les deux livrables – le code exploratoire et les résultats obtenus.

Les équipes internes

Ces équipes utilisent des cahiers Jupyter locaux et les partagent avec d’autres unités commerciales en créant des solutions adaptées au système de connaissances et à l’infrastructure de leur entreprise. Elles sont convaincues que les parties prenantes commerciales et produits doivent être en mesure de comprendre les cahiers du Data Scientist et elles attachent une grande importance à la nécessité de maintenir une lignée entièrement traçable, des conclusions aux données brutes.

Cependant, il est peu probable que l’équipe financière se rende sur GitHub ou Bitbucket pour lire votre cahier.

J’ai vu plusieurs solutions mises en œuvre dans cet espace. Par exemple, vous pouvez utiliser des outils comme nbconvert pour générer des PDF à partir des cahiers Jupyter ou les exporter sous forme de pages HTML, de manière à pouvoir les partager facilement avec n’importe qui, même en dehors des équipes techniques.

Vous pouvez même déplacer ces cahiers dans S3 et les autoriser à être hébergés en tant que site web statique avec la vue rendue. Vous pouvez utiliser un flux de travail CI/CD pour créer et pousser un rendu HTML de votre cahier vers S3 lorsque le code est fusionné dans une branche spécifique.

Les promoteurs d’outils tiers

Ces équipes utilisent des outils qui permettent non seulement le développement de cahiers, mais aussi le partage avec d’autres personnes au sein de l’organisation. Cela implique généralement de faire face à des complexités telles que garantir un accès sécurisé et simple aux entrepôts de données internes, aux lacs de données et aux bases de données.

Certains des outils les plus largement adoptés dans cet espace sont Deepnote, Amazon SageMaker, Google Vertex AI, et Azure Machine Learning. Ce sont des plateformes complètes pour exécuter des cahiers qui permettent de créer des environnements virtuels sur des machines distantes pour exécuter votre code. Elles offrent des fonctionnalités interactives de représentation graphique, d’exploration de données et d’expérimentation, ce qui simplifie l’ensemble du cycle de vie de la science des données. Par exemple, Sagemaker vous permet de visualiser toutes les informations de vos expériences que vous avez suivies avec Sagemaker Experiments, et Deepnote propose également une visualisation facile avec leurs Chart Blocks.

De plus, Deepnote et SageMaker vous permettent de partager le cahier avec n’importe lequel de vos collègues pour le consulter ou même pour permettre une collaboration en temps réel en utilisant le même environnement d’exécution.

Il existe également des alternatives open-source telles que JupyterHub, mais l’effort d’installation et de maintenance nécessaire pour son fonctionnement ne vaut pas la peine. La mise en place d’un JupyterHub sur site peut être une solution suboptimale, et dans de très rares cas seulement cela peut avoir du sens de le faire (par exemple, des types de charges de travail très spécialisés nécessitant un matériel spécifique). En utilisant des services Cloud, vous pouvez tirer parti des économies d’échelle qui garantissent des architectures beaucoup plus tolérantes aux pannes que ce que d’autres entreprises opérant dans un secteur différent peuvent offrir. Vous devez assumer les coûts initiaux de configuration, déléguer sa maintenance à une équipe d’opérations de plateforme pour le maintenir en fonctionnement pour les Data Scientists, et garantir la sécurité et la confidentialité des données. Par conséquent, avoir confiance en des services gérés évitera les maux de tête sans fin liés à l’infrastructure qu’il vaut mieux ne pas avoir.

Mon conseil général pour explorer ces produits : Si votre entreprise utilise déjà un fournisseur de cloud comme AWS, Google Cloud Platform ou Azure, il peut être judicieux d’adopter leur solution de notebook, car l’accès à l’infrastructure de votre entreprise sera probablement plus facile et moins risqué.

Adopter les bonnes pratiques efficaces des notebooks Jupyter

Dans cet article, nous avons discuté des bonnes pratiques et des conseils pour optimiser l’utilité des notebooks Jupyter.

La conclusion la plus importante :

Abordez toujours la création d’un notebook en gardant à l’esprit le public cible et l’objectif final. De cette manière, vous saurez à quel point accorder d’importance aux différentes dimensions du notebook (code, analyse, résumé exécutif, etc).

Dans l’ensemble, j’encourage les data scientists à utiliser les notebooks Jupyter, mais exclusivement pour répondre aux questions exploratoires et à des fins de reporting.

Les artefacts de production tels que les modèles, les ensembles de données ou les hyperparamètres ne devraient pas être liés aux notebooks. Ils devraient avoir leur origine dans des systèmes de production reproductibles et réexécutables. Par exemple, les pipelines SageMaker ou les DAGs Airflow qui sont bien entretenus et rigoureusement testés.

Ces dernières réflexions sur la traçabilité, la reproductibilité et la filiation seront le point de départ du prochain article de ma série sur Les modèles de logiciel dans la science des données et l’ingénierie ML, qui se concentrera sur la manière d’améliorer vos compétences ETL. Bien souvent ignorée par les data scientists, je suis convaincu que la maîtrise de l’ETL est fondamentale et cruciale pour garantir le succès de tout projet d’apprentissage automatique.

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!

Share:

Was this article helpful?

93 out of 132 found this helpful

Discover more

AI

Découvrez FreeU une nouvelle technique d'IA novatrice pour améliorer la qualité générative sans formation ou affinage supplémentaires.

Les modèles de diffusion probabiliste, une catégorie de pointe de modèles génératifs, sont devenus un point critique ...

AI

Les chercheurs de Stanford présentent CORNN une méthode d'apprentissage automatique pour l'analyse en temps réel d'enregistrements neuronaux à grande échelle.

Les développements technologiques ont apporté une nouvelle ère dans le domaine toujours changeant de la recherche en ...

AI

Découvrez Baichuan-13B le modèle de langage open source chinois destiné à concurrencer OpenAI.

Wang Xiaochuan, le fondateur du moteur de recherche chinois Sogou, a lancé un nouveau modèle de langage impressionnan...

AI

Les chercheurs étudient les réseaux tensoriels pour un apprentissage automatique quantum-inspiré interprétable et efficace

La vision par ordinateur, le TALN et d’autres domaines ont connu un succès remarquable grâce aux approches d...