Rejoignez la communauté SIG TFX-Addons et contribuez à rendre TFX encore meilleur ! Rejoignez SIG TFX-Addons

Comprendre les pipelines TFX

MLOps consiste à appliquer des pratiques DevOps pour aider à automatiser, gérer et auditer les flux de travail d'apprentissage automatique (ML). Les flux de travail ML incluent des étapes pour:

  • Préparez, analysez et transformez 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.

La gestion de ces étapes de manière ad hoc peut être difficile et prendre du temps.

TFX facilite la mise en œuvre de MLOps en fournissant une boîte à outils qui vous aide à orchestrer votre processus de ML sur divers orchestrateurs, tels que: Apache Airflow, Apache Beam et Kubeflow Pipelines. En implémentant votre flux de travail 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 d'expérimentation en exécutant un pipeline avec différents ensembles d'hyperparamètres.

Ce guide décrit les concepts de base nécessaires pour comprendre les pipelines TFX.

Artefact

Les sorties d'étapes dans un pipeline TFX sont appelées artefacts . Les étapes suivantes 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 workflow.

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 les métadonnées ML .

Les types d'artefacts ont un nom et définissent un schéma de ses propriétés. Les noms de type d'artefact 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 des types de valeur complexes, tels que: chaîne, entier et flottant. Vous pouvez réutiliser ces types d'artefact ou définir des types d'artefact personnalisés qui dérivent d' Artifact .

Paramètre

Les paramètres sont des entrées de pipelines qui sont connues avant que votre pipeline ne soit exécuté. Les paramètres vous permettent de modifier le comportement d'un pipeline, ou d'une partie d'un pipeline, via la configuration au lieu du 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 à utiliser dans un pipeline.

TFX fournit plusieurs composants standard 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 flux de travail ML qui peut être exécuté sur divers 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 composant est déterminée en créant un graphe acyclique dirigé des dépendances d'artefact.

Par exemple, considérons un pipeline qui effectue les opérations suivantes:

  • Ingère des données directement à partir d'un système propriétaire à l'aide d'un composant personnalisé.
  • Calcule les statistiques des 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.
  • Recherche les anomalies dans les données d'entraînement à l'aide du composant standard ExampleValidator.
  • Effectue l'ingénierie d'entités sur le jeu de données à l'aide du composant standard Transform.
  • Entraîne un modèle à l'aide du composant standard Trainer.
  • Évalue le modèle entraîné à l'aide du composant Evaluator.
  • Si le modèle réussit son évaluation, le pipeline met en file d'attente le modèle entraîné vers 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 d'artefact.

  • Le composant d'ingestion de données n'a pas de dépendances d'artefact, il peut donc être le 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.
  • ExampleValidator 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.
  • La transformation dépend des exemples produits par l'ingestion de données et du schéma créé par SchemaGen, elle doit donc être exécutée après l'ingestion de données et SchemaGen.
  • Le formateur 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éploiement personnalisé dépend du modèle enregistré produit par le formateur et des résultats d'analyse créés par l'évaluateur, de sorte que le déployeur doit ê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 de composants SchemaGen de manière séquentielle.
  • Les composants ExampleValidator et Transform peuvent s'exécuter en parallèle car ils partagent des dépendances d'artefact d'entrée et ne dépendent pas de la sortie de l'autre.
  • Une fois le composant Transformer terminé, les instances du composant Trainer, Evaluator et du composant de déploiement 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 la mise en route du développement de pipeline en fournissant un pipeline prédéfini que vous pouvez personnaliser en fonction de votre cas d'utilisation.

En savoir plus sur la personnalisation d'un modèle de pipeline TFX .

Pipeline Run

Une exécution est une exécution unique d'un pipeline.

Orchestrateur

Un orchestrateur est un système dans lequel vous pouvez exécuter des exécutions de pipeline. TFX prend en charge les orchestrateurs tels que: Apache Airflow , Apache Beam et Kubeflow Pipelines . TFX utilise également le terme DagRunner pour désigner une implémentation qui prend en charge un orchestrateur.