MLOps consiste à appliquer des pratiques DevOps pour aider à automatiser, gérer et auditer les flux de travail d'apprentissage automatique (ML). Les workflows de ML incluent des étapes pour :
- Préparer, analyser et transformer les données.
- Former et évaluer un modèle.
- Déployez des modèles formés en production.
- Suivez les artefacts ML et comprenez leurs dépendances.
Gérer ces étapes de manière ponctuelle peut s’avérer difficile et prendre beaucoup de temps.
TFX facilite la mise en œuvre de MLOps en fournissant une boîte à outils qui vous aide à orchestrer votre processus de ML sur différents orchestrateurs, tels que : Apache Airflow, Apache Beam et Kubeflow Pipelines. En implémentant votre workflow en tant que pipeline TFX, vous pouvez :
- Automatisez votre processus ML, ce qui vous permet de recycler, d'évaluer et de déployer régulièrement votre modèle.
- Utilisez des ressources de calcul distribuées pour traiter des ensembles de données et des charges de travail volumineux.
- Augmentez la vitesse de l’expérimentation en exécutant un pipeline avec différents ensembles d’hyperparamètres.
Ce guide décrit les concepts de base requis pour comprendre les pipelines TFX.
Artefact
Les résultats des étapes d'un pipeline TFX sont appelés artefacts . Les étapes ultérieures de votre flux de travail peuvent utiliser ces artefacts comme entrées. De cette manière, TFX vous permet de transférer des données entre les étapes du flux de travail.
Par exemple, le composant standard ExampleGen émet des exemples sérialisés, que des composants tels que le composant standard StatisticsGen utilisent comme entrées.
Les artefacts doivent être fortement typés avec un type d'artefact enregistré dans le magasin de métadonnées ML . En savoir plus sur les concepts utilisés dans ML Metadata .
Les types d'artefacts ont un nom et définissent un schéma de leurs propriétés. Les noms de types d’artefacts doivent être uniques dans votre magasin de métadonnées ML. TFX fournit plusieurs types d'artefacts standard qui décrivent des types de données et de valeurs complexes, tels que : chaîne, entier et flottant. Vous pouvez réutiliser ces types d'artefacts ou définir des types d'artefacts personnalisés dérivés de Artifact .
Paramètre
Les paramètres sont des entrées dans les pipelines qui sont connues avant l'exécution de votre pipeline. Les paramètres vous permettent de modifier le comportement d'un pipeline, ou d'une partie d'un pipeline, via la configuration plutôt que par le code.
Par exemple, vous pouvez utiliser des paramètres pour exécuter un pipeline avec différents ensembles d'hyperparamètres sans modifier le code du pipeline.
L'utilisation de paramètres vous permet d'augmenter la vitesse d'expérimentation en facilitant l'exécution de votre pipeline avec différents ensembles de paramètres.
En savoir plus sur la classe RuntimeParameter .
Composant
Un composant est une implémentation d'une tâche ML que vous pouvez utiliser comme étape dans votre pipeline TFX. Les composants sont composés de :
- Une spécification de composant, qui définit les artefacts d'entrée et de sortie du composant, ainsi que les paramètres requis du composant.
- Un exécuteur, qui implémente le code pour effectuer une étape de votre flux de travail ML, telle que l'ingestion et la transformation de données ou la formation et l'évaluation d'un modèle.
- Une interface de composant, qui regroupe la spécification du composant et l'exécuteur pour une utilisation dans un pipeline.
TFX fournit plusieurs composants standards que vous pouvez utiliser dans vos pipelines. Si ces composants ne répondent pas à vos besoins, vous pouvez créer des composants personnalisés. En savoir plus sur les composants personnalisés .
Pipeline
Un pipeline TFX est une implémentation portable d'un workflow ML qui peut être exécuté sur différents orchestrateurs, tels que : Apache Airflow, Apache Beam et Kubeflow Pipelines. Un pipeline est composé d'instances de composants et de paramètres d'entrée.
Les instances de composant produisent des artefacts en tant que sorties et dépendent généralement des artefacts produits par les instances de composant en amont en tant qu'entrées. La séquence d'exécution des instances de composants est déterminée en créant un graphe acyclique dirigé des dépendances des artefacts.
Par exemple, considérons un pipeline qui effectue les opérations suivantes :
- Ingère les données directement à partir d’un système propriétaire à l’aide d’un composant personnalisé.
- Calcule les statistiques pour les données d'entraînement à l'aide du composant standard StatisticsGen.
- Crée un schéma de données à l'aide du composant standard SchemaGen.
- Vérifie les anomalies dans les données d'entraînement à l'aide du composant standard SampleValidator.
- Effectue l’ingénierie des fonctionnalités sur l’ensemble de données à l’aide du composant standard Transform.
- Entraîne un modèle à l’aide du composant standard Trainer.
- Évalue le modèle formé à l’aide du composant Évaluateur.
- Si le modèle réussit son évaluation, le pipeline met le modèle formé en file d'attente dans un système de déploiement propriétaire à l'aide d'un composant personnalisé.
Pour déterminer la séquence d'exécution des instances de composant, TFX analyse les dépendances des artefacts.
- Le composant d'ingestion de données n'a aucune dépendance d'artefact, il peut donc s'agir du premier nœud du graphique.
- StatisticsGen dépend des exemples produits par l'ingestion de données, il doit donc être exécuté après l'ingestion de données.
- SchemaGen dépend des statistiques créées par StatisticsGen, il doit donc être exécuté après StatisticsGen.
- SampleValidator dépend des statistiques créées par StatisticsGen et du schéma créé par SchemaGen, il doit donc être exécuté après StatisticsGen et SchemaGen.
- Transform dépend des exemples produits par l'ingestion de données et du schéma créé par SchemaGen, il doit donc être exécuté après l'ingestion de données et SchemaGen.
- Trainer dépend des exemples produits par l'ingestion de données, du schéma créé par SchemaGen et du modèle enregistré produit par Transform. Le formateur ne peut être exécuté qu'après l'ingestion de données, SchemaGen et Transform.
- L'évaluateur dépend des exemples produits par l'ingestion de données et du modèle enregistré produit par le formateur, il doit donc être exécuté après l'ingestion des données et le formateur.
- Le déployeur personnalisé dépend du modèle enregistré produit par le formateur et des résultats d'analyse créés par l'évaluateur. Le déployeur doit donc être exécuté après le formateur et l'évaluateur.
Sur la base de cette analyse, un orchestrateur exécute :
- L'ingestion de données, StatisticsGen, les instances des composants SchemaGen de manière séquentielle.
- Les composants SampleValidator et Transform peuvent s'exécuter en parallèle car ils partagent des dépendances d'artefacts d'entrée et ne dépendent pas de la sortie de chacun.
- Une fois le composant Transform terminé, les instances des composants Trainer, Evaluator et Déployeur personnalisé s'exécutent de manière séquentielle.
En savoir plus sur la création d'un pipeline TFX .
Modèle de pipeline TFX
Les modèles de pipeline TFX facilitent le démarrage du développement de pipelines en fournissant un pipeline prédéfini que vous pouvez personnaliser pour votre cas d'utilisation.
En savoir plus sur la personnalisation d'un modèle de pipeline TFX .
Exécution du pipeline
Une exécution est une exécution unique d’un pipeline.
Orchestrateur
Un Orchestrator est un système dans lequel vous pouvez exécuter des exécutions de pipeline. TFX prend en charge des orchestrateurs tels que : Apache Airflow , Apache Beam et Kubeflow Pipelines . TFX utilise également le terme DagRunner pour désigner une implémentation prenant en charge un orchestrateur.