Un guide complet sur ZenML pour les débutants simplifiant MLOps.

Un guide complet sur ZenML simplifiant MLOps pour les débutants.

Êtes-vous nouveau dans le domaine de la science des données, de l’apprentissage automatique ou des MLOps et vous sentez-vous submergé par le choix des outils ? Considérez ZenML, un outil d’orchestration pour des pipelines de production simplifiés. Dans cet article, nous explorerons les capacités et les fonctionnalités de ZenML pour simplifier votre parcours MLOps.

Objectifs d’apprentissage

  • Concepts et commandes ZenML
  • Création de pipelines avec ZenML
  • Suivi des métadonnées, mise en cache et gestion des versions
  • Paramètres et configurations
  • Fonctionnalités avancées de ZenML

Cet article a été publié dans le cadre du Blogathon de la science des données.

Tout d’abord, essayons de comprendre ce qu’est ZenML, pourquoi il se distingue des autres outils et comment l’utiliser.

Qu’est-ce que ZenML ?

ZenML est un framework open-source de MLOps (opérations d’apprentissage automatique) destiné aux scientifiques des données, aux ingénieurs en apprentissage automatique et aux développeurs MLOps. Il facilite la collaboration dans le développement de pipelines ML prêts pour la production. ZenML est connu pour sa simplicité, sa flexibilité et sa nature agnostique quant aux outils. Il fournit des interfaces et des abstractions spécifiquement conçues pour les flux de travail ML, permettant aux utilisateurs d’intégrer leurs outils préférés de manière transparente et de personnaliser les flux de travail pour répondre à leurs besoins uniques.

Pourquoi devrions-nous utiliser ZenML ?

ZenML offre plusieurs avantages aux scientifiques des données, aux ingénieurs en apprentissage automatique et aux ingénieurs MLOps :

  1. Création simplifiée de pipelines : Construisez facilement des pipelines ML avec ZenML en utilisant les décorateurs @step et @pipeline.
  2. Suivi et gestion des versions des métadonnées sans effort : ZenML fournit un tableau de bord convivial pour suivre les pipelines, les exécutions, les composants et les artefacts.
  3. Déploiement automatisé : ZenML rationalise le déploiement du modèle en le déployant automatiquement lorsqu’il est défini comme un pipeline, éliminant ainsi la nécessité d’images Docker personnalisées.
  4. Flexibilité cloud : Déployez votre modèle sur n’importe quelle plateforme cloud en utilisant des commandes simples avec ZenML.
  5. Infrastructure MLOps normalisée : ZenML permet à tous les membres de l’équipe d’exécuter des pipelines en configurant ZenML comme environnement de préparation et de production, garantissant ainsi une configuration MLOps normalisée.
  6. Intégrations sans faille : Intégrez facilement ZenML à des outils de suivi expérimental tels que Weights and Biases, MLflow, et bien d’autres.

Guide d’installation de ZenML

Pour installer ZenML dans votre terminal, utilisez les commandes suivantes :

Installer ZenML :

pip install zenml

Pour accéder au tableau de bord local, installez avec l’option serveur :

pip install "zenml[server]

Pour vérifier si ZenML est correctement installé et vérifier sa version, exécutez :

zenml version

Terminologie ZenML importante

  1. Pipeline : Une série d’étapes dans le flux de travail de l’apprentissage automatique.
  2. Artefacts : Entrées et sorties de chaque étape du pipeline.
  3. Magasin d’artefacts : Un référentiel versionné pour stocker les artefacts, améliorant la vitesse d’exécution du pipeline. ZenML fournit un magasin local par défaut, stocké sur votre système local.
  4. Composants : Configurations pour les fonctions utilisées dans le pipeline ML.
  5. Paquetages : Une collection de composants et d’infrastructures. Le paquetage par défaut de ZenML comprend :
    • Magasin d’artefacts
    • Orchestrateur

La partie gauche de cette image représente la partie codage que nous avons réalisée en tant que pipeline, et la partie droite représente l’infrastructure. Il y a une séparation claire entre ces deux aspects, ce qui facilite le changement d’environnement dans lequel le pipeline s’exécute.

  • Saveurs : Solutions créées en intégrant d’autres outils MLOps à ZenML, s’étendant à partir de la classe abstraite de composants de base.
  • Matérialisateurs : Définissent la manière dont les entrées et les sorties sont transmises entre les étapes via le magasin d’artefacts. Tous les matérialisateurs relèvent de la classe de matérialisateur de base. Vous pouvez également créer des matérialisateurs personnalisés pour intégrer des outils absents de ZenML.
  • Serveur ZenML : Utilisé pour déployer des modèles ML et effectuer des prédictions.

Commandes ZenML Importantes

Commande pour initialiser un nouveau référentiel :

zenml init

Commande pour exécuter le tableau de bord localement :

zenml up

Sortie :

Commande pour connaître l’état de nos pipelines Zenml :

zenml show

Commande pour voir la configuration de la pile active :

zenml stack describe

CLI :

Commande pour voir la liste de toutes les piles enregistrées :

zenml stack list

Sortie :

Tableau de bord :

Création de votre première pipeline

Tout d’abord, nous devons importer pipeline, étape de ZenML pour créer notre pipeline :

# Importer les modules nécessaires pour créer une étape et une pipeline
from zenml import pipeline, step

# Définir l'étape et renvoyer une chaîne de caractères.
@step
def sample_step_1() -> str:
    return "Bienvenue à"

# Prendre 2 entrées et afficher la sortie.
@step
def sample_step_2(input_1: str, input_2: str) -> None:
    print(input_1 + " " + input_2)

# Définir une pipeline.
@pipeline
def my_first_pipeline():
    input_1 = sample_step_1()
    sample_step_2(input_1, "Analytics Vidhya")

# Exécuter la pipeline.
my_first_pipeline()

Dans cette pipeline d’exemple, nous avons construit deux étapes individuelles, que nous avons ensuite intégrées à la pipeline globale. Nous avons accompli cela en utilisant les décorateurs @step et @pipeline.

Tableau de bord : Profitez de la visualisation de votre pipeline.

Paramètres et Renommage d’une Pipeline

Vous pouvez améliorer cette pipeline en introduisant des paramètres. Par exemple, je vais vous montrer comment modifier le nom d’exécution de la pipeline en “Analytiques Vidya run” en utilisant la méthode with_options(), en spécifiant le paramètre run_name.

# Ici, nous utilisons la méthode with_options() pour modifier le nom d'exécution de la pipeline.
my_first_pipeline = my_first_pipeline.with_options(
    run_name="Analytiques Vidya run")

Vous pouvez voir le nouveau nom ici dans le tableau de bord :

Si une étape a plusieurs sorties, il est préférable d’utiliser des annotations de tuple. Par exemple :

# Ici, il y a 4 sorties, donc nous utilisons Tuple. Ici, nous utilisons des annotations pour indiquer à quoi ces sorties se réfèrent.
def train_data() -> Tuple[
    Annotated[pd.DataFrame, "X_train"],
    Annotated[pd.DataFrame, "X_test"],
    Annotated[pd.Series, "Y_train"],
    Annotated[pd.Series, "Y_test"],
]:

Nous pouvons également y ajouter la date et l’heure.

# Ici, nous utilisons la date et l'heure à l'intérieur des espaces réservés, qui seront automatiquement remplacés par la date et l'heure actuelles.
my_first_pipeline = my_first_pipeline.with_options(
    run_name="new_run_name_{{date}}_{{time}}")
my_first_pipeline()

Tableau de bord :

Mise en cache

La mise en cache accélère le processus d’exécution du pipeline en exploitant les sorties des exécutions précédentes lorsque aucun changement de code ne se produit, ce qui permet de gagner du temps et des ressources. Pour activer la mise en cache, il suffit d’inclure un paramètre avec le décorateur @pipeline.

#ici, la mise en cache est activée en tant que paramètre de la fonction.@pipeline(enable_cache=True)def my_first_pipeline():

Il y a des occasions où nous devons ajuster dynamiquement notre code ou nos entrées. Dans de tels cas, vous pouvez désactiver la mise en cache en définissant enable_cache sur False.

Dans le tableau de bord, les niveaux de hiérarchie seront les suivants:

Vous pouvez utiliser les propriétés du modèle pour récupérer des informations sur le pipeline. Par exemple, dans l’exemple suivant, nous accédons au nom du pipeline en utilisant model.name.

modèle=mon_premier_pipeline.modelprint(model.name)

Vous pouvez voir la dernière exécution du pipeline en:

modèle = mon_premier_pipeline.modelprint(model.name)# Maintenant, nous pouvons accéder à la dernière exécution du pipelineexécution = modèle.dernière_execprint("dernière exécution est:", exécution)

Résultat:

Accéder au pipeline en utilisant CLI

Vous pouvez récupérer le pipeline sans vous appuyer sur les définitions du pipeline en utilisant la méthode Client().get_pipeline().

Commande:

de zenml.client import Clientpipeline_model = Client().get_pipeline("mon_premier_pipeline")

Résultat:

Alors que vous pouvez facilement afficher tous vos pipelines et exécutions dans le tableau de bord ZenML, il est intéressant de noter que vous pouvez également accéder à ces informations via le Client et le CLI ZenML.

En utilisant le Client():

#ici, nous avons créé une instance du Client ZenML pour utiliser la méthode list_pipelines()pipelines=Client().list_pipelines()

Résultat:

En utilisant le CLI:

zenml pipeline list

Résultat:

Tableau de bord:

Composants de la pile ZenML CLI

Pour voir tous les artefacts existants, vous pouvez simplement exécuter la commande suivante:

zenml artifact-store list

Résultat:

Tableau de bord:

Pour voir la liste des orchestrations,

zenml orchestrator list

Résultat:

Tableau de bord:

Pour enregistrer un nouvel espace de stockage d’artefacts, suivez la commande:

zenml artifact-store register my_artifact_store --flavor=local

Vous pouvez également apporter des mises à jour ou des suppressions à l’actuel magasin d’artefacts en remplaçant le mot-clé “register” par “update” ou “delete”. Pour accéder à des détails supplémentaires sur la pile enregistrée, vous pouvez exécuter la commande :

zenml artifact-store describe my_artifact_store

Sortie :

Tableau de bord :

Comme nous l’avons démontré précédemment pour le magasin d’artefacts, vous pouvez également passer à une autre pile active.

zenml stack register my_stack -o default -a my_artifact_store

Comme nous l’avons démontré précédemment pour le magasin d’artefacts, vous pouvez également passer à une autre pile active.

zenml stack set my_stack

Vous pouvez maintenant observer que la pile active a été modifiée avec succès de “default” à “my_stack”.

Tableau de bord : Vous pouvez voir la nouvelle pile ici dans le tableau de bord.

Suggestions et bonnes pratiques

1. Intégrez des pratiques de journalisation robustes dans votre projet en :

#importer les modules nécessaires
from zenml import pipeline, step
from zenml.client import Client
from zenml.logger import get_logger

logger = get_logger(__name__)

# Ici, nous créons un pipeline avec 2 étapes.
@step
def sample_step_1() -> str:
    return "Bienvenue sur"

@step
def sample_step_2(input_1: str, input_2: str) -> None:
    print(input_1 + " " + input_2)

@pipeline
def my_first_pipeline():
    # Ici, 'logger' est utilisé pour enregistrer un message d'information
    logger.info("C'est un projet de démonstration")
    input_1 = sample_step_1()
    sample_step_2(input_1, "Analytics Vidya")

my_first_pipeline()

Sortie :

2. Assurez-vous que votre projet dispose d’un modèle bien structuré. Un template propre améliore la lisibilité du code et facilite la compréhension pour les personnes qui examinent votre projet.

My_Project/                             # Répertoire du projet
├── data/                               # Dossier des ensembles de données
├── notebook/ .ipynb                    # Fichiers de notebooks Jupyter
├── pipelines/                          # Dossier des pipelines ZenML
│   ├── deployment_pipeline.py          # Pipeline de déploiement
│   ├── training_pipeline.py            # Pipeline de formation
│   └── *tout autre fichier
├── assets
├── src/                                # Dossier du code source
├── steps/                              # Dossier des étapes ZenML
├── app.py                              # Application Web
├── Dockerfile(* Optionnel)
├── requirements.txt                    # Liste des packages requis par le projet
├── README.md                           # Documentation du projet
└── .zen/

Pour créer un projet MLOps de bout en bout complet, il est conseillé de suivre ce modèle de projet. Assurez-vous toujours que vos fichiers d’étapes et de pipelines sont organisés dans un dossier séparé. Incluez une documentation détaillée pour améliorer la compréhension du code. Le dossier .zen est automatiquement généré lorsque vous lancez ZenML en utilisant la commande “zenml init”. Vous pouvez également utiliser des notebooks pour stocker vos fichiers de notebook Colab ou Jupyter.

3. Lorsque vous traitez plusieurs sorties dans une étape, il est conseillé d’utiliser des annotations de Tuple.

4. N’oubliez pas de définir enable_cache sur False, notamment lors de la planification d’exécutions de pipelines pour des mises à jour régulières, telles que l’importation dynamique de nouvelles données (nous aborderons la planification temporelle plus tard dans ce blog).

Serveur ZenML et son déploiement

Le serveur ZenML sert de hub centralisé pour stocker, gérer et exécuter les pipelines. Vous pouvez avoir une vue complète de sa fonctionnalité grâce à l’image ci-dessous :

Dans cette configuration, la base de données SQLite stocke tous les ensembles, composants et pipelines. “Déployer” signifie faire en sorte que votre modèle entraîné génère des prédictions sur des données en temps réel dans un environnement de production. ZenML propose deux options de déploiement : le Cloud ZenML et le déploiement auto-hébergé.

Ordre d’exécution des étapes

Par défaut, ZenML exécute les étapes dans l’ordre où elles sont définies. Cependant, il est possible de changer cet ordre. Voyons comment :

from zenml import pipeline@pipelinedef my_first_pipeline():#ici, nous mentionnons que l'étape 1 doit s'exécuter uniquement après l'étape 2.    sample_step_1 = step_1(after="step_2")    sample_step_2 = step_2()#Ensuite, nous exécuterons l'étape 3 après l'exécution des étapes 1 et 2.        step_3(sample_step_1, sample_step_2)

Dans ce scénario, nous avons modifié l’ordre d’exécution par défaut des étapes. Plus précisément, nous avons arrangé pour que l’étape 1 s’exécute uniquement après l’étape 2, et que l’étape 3 s’exécute après l’exécution des étapes 1 et 2.

Activer/Désactiver les journaux

Vous pouvez activer ou désactiver l’enregistrement des journaux dans le magasin d’artefacts en ajustant le paramètre “enable_step_logs”. Voici comment faire :

#Ici, nous désactivons les journaux dans l'étape, mentionnée en tant que paramètre.@step(enable_step_logs=False)def sample_step_2(input_1: str, input_2: str) -> None:    print(input_1 + " " + input_2)

Sortie :

Avant l’enregistrement :

Après l’enregistrement :

Types de paramètres

Il existe deux types de paramètres dans ZenML :

  1. Paramètres généraux : Ces paramètres peuvent être utilisés dans tous les pipelines (par ex. paramètres Docker).
  2. Paramètres spécifiques aux composants de pile : Il s’agit de paramètres de configuration spécifiques à l’exécution, qui diffèrent des paramètres d’enregistrement des composants de pile qui sont statiques par nature, tandis que ceux-ci sont dynamiques par nature. Par exemple, “MLFlowTrackingURL” est un paramètre d’enregistrement, tandis que le nom de l’expérience et ses configurations d’exécution sont des paramètres spécifiques aux composants de pile. Les paramètres spécifiques aux composants de pile peuvent être remplacés lors de l’exécution, mais les paramètres d’enregistrement ne peuvent pas l’être.

Planification horaire des modèles

Nous pouvons automatiser le déploiement du modèle ML en le planifiant pour s’exécuter à des moments spécifiques à l’aide de tâches cron. Cela permet non seulement de gagner du temps, mais aussi de s’assurer que le processus s’exécute aux moments désignés sans aucun retard. Voyons comment configurer cela :

from zenml.config.schedule import Schedulefrom zenml import step,pipeline#Définir l'étape et renvoyer une chaîne.@stepdef sample_step_1()->str:    return "Bienvenue à"#Prendre 2 entrées et afficher la sortie@stepdef sample_step_2(input_1:str,input_2:str)->None:    print(input_1+" "+input_2)    @pipelinedef my_first_pipeline():  logger.info("C'est un projet de démonstration")  input_1=sample_step_1()  sample_step_2(input_1,"Analytics Vidya")#Ici, nous utilisons la tâche cron pour planifier nos pipelines.schedule = Schedule(cron_expression="0 7 * * 1")my_first_pipeline = my_first_pipeline.with_options(schedule=schedule)my_first_pipeline()

Dans ce contexte, l’expression CRON suit le format (minute, heure, jour du mois, mois, jour de la semaine). Ici, j’ai planifié le pipeline pour s’exécuter tous les lundis à 7h du matin.

Alternativement, nous pouvons également utiliser des intervalles de temps :

from zenml.config.schedule import Schedulefrom zenml import pipeline@pipelinedef my_first_pipeline():  input_1 = sample_step_1()  sample_step_2(input_1, "Analytics Vidya")#ici, nous utilisons datetime.now() pour mentionner notre heure actuelle et#interval_second est utilisé pour mentionner les intervalles de temps réguliers auxquels il doit être exécuté.schedule = Schedule(start_time=datetime.now(), interval_second=3000)my_first_pipeline = my_first_pipeline.with_options(schedule=schedule)my_first_pipeline()

J’ai écrit du code pour initier notre pipeline, à partir du moment présent, et se répétant à chaque intervalle de 5 minutes.

Contexte de l’étape

Le contexte de l’étape est utilisé pour accéder aux informations sur l’étape en cours d’exécution, telles que son nom, le nom de l’exécution et le nom du pipeline. Ces informations peuvent être utiles à des fins de journalisation et de débogage.

#importer les modules nécessairesfrom zenml import pipeline, stepfrom zenml.client import Clientfrom zenml.logger import get_loggerfrom zenml.config.schedule import Schedulefrom zenml import get_step_context#Obtenir un journal pour le module en cours de coursfichier journalget_logger(__name__)@stepdef sample_step_1() -> str:# accéder au contexte de l'étape dans la fonction de l'étape    step_context = get_step_context()      pipeline_name = step_context.pipeline.name    run_name = step_context.pipeline_run.name    step_name = step_context.step_run.name    logger.info("Nom du pipeline : %s", pipeline_name)    logger.info("Nom de l'exécution : %s", run_name)    logger.info("Nom de l'étape : %s", step_name)    logger.info("C'est un projet de démonstration")    return "Bienvenue à"@step()def sample_step_2(input_1: str, input_2: str) -> None: # accès au contexte de l'étape dans cette 2ème fonction d'étape       step_context = get_step_context()      pipeline_name = step_context.pipeline.name    run_name = step_context.pipeline_run.name    step_name = step_context.step_run.name    logger.info("Nom du pipeline : %s", pipeline_name)    logger.info("Nom de l'exécution : %s", run_name)    logger.info("Nom de l'étape : %s", step_name)    print(input_1 + " " + input_2)@pipelinedef my_first_pipeline():    input_1 = sample_step_1()    sample_step_2(input_1, "Analytics Vidya")my_first_pipeline()

Sortie :

Conclusion

Dans ce guide complet, nous avons couvert tout ce que vous devez savoir sur ZenML, de son installation à des fonctionnalités avancées telles que la personnalisation de l’ordre d’exécution, la création de plannings horaires et l’utilisation des contextes d’étape. Nous espérons que ces concepts entourant ZenML vous permettront de créer des pipelines ML de manière plus efficace, rendant votre parcours MLOps plus simple, plus facile et plus fluide.

Points clés à retenir

  1. ZenML simplifie la création de pipelines ML grâce à l’utilisation de décorateurs tels que @step et @pipeline, le rendant accessible aux débutants.
  2. Le tableau de bord ZenML offre un suivi facile des pipelines, des composants de la pile, des artefacts et des exécutions, simplifiant la gestion de projet.
  3. ZenML s’intègre parfaitement à d’autres outils MLOps tels que Weights & Biases et MLflow, enrichissant votre boîte à outils.
  4. Les contextes d’étape fournissent des informations précieuses sur l’étape en cours, facilitant la journalisation et le débogage efficaces.

Questions fréquemment posées

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

Meta AI rend AudioCraft open source une bibliothèque PyTorch pour la recherche en apprentissage profond sur la génération audio

Pour permettre aux chercheurs et aux praticiens de former leurs modèles et de faire progresser l’état de l̵...

AI

Une API de métaphore Un moteur de recherche révolutionnaire construit pour LLM

Internet était une utopie où tout le monde pouvait accéder aux informations les plus à jour sur n’importe quel ...

AI

Découvrez SMPLitex un modèle AI génératif et un ensemble de données pour l'estimation de la texture humaine en 3D à partir d'une seule image.

Dans le domaine en constante évolution de la vision par ordinateur et des graphiques, un défi majeur a été la créatio...

AI

Découvrez Med-PaLM Multimodal (Med-PaLM M) un grand modèle génératif multimodal qui encode et interprète de manière flexible les données biomédicales.

Les modèles de langage large (LLMs) ont progressé dans presque tous les domaines, de la santé et de la finance à l...

Apprentissage automatique

Rencontrez Wanda une approche simple et efficace de l'élagage pour les grands modèles de langage.

La popularité et l’utilisation des grands modèles de langage (LLM) sont en constante croissance. Avec l’é...