Aide à protéger la Grande barrière de corail avec tensorflow sur Kaggle Rejoignez Défi

Comprendre les composants personnalisés TFX

Les pipelines TFX vous permettent d'orchestrer votre flux de travail d'apprentissage automatique (ML) sur des orchestrateurs, tels que: Apache Airflow, Apache Beam et Kubeflow Pipelines. Les pipelines organisent votre flux de travail en une séquence de composants, où chaque composant effectue une étape de votre flux de travail ML. Les composants standard TFX fournissent des fonctionnalités éprouvées pour vous aider à créer facilement un flux de travail ML. Vous pouvez également inclure des composants personnalisés dans votre flux de travail. Les composants personnalisés vous permettent d'étendre votre flux de travail ML en:

  • Construire des composants adaptés à vos besoins, tels que l'ingestion de données à partir d'un système propriétaire.
  • Application de l'augmentation, du suréchantillonnage ou du sous-échantillonnage des données.
  • Effectuez une détection des anomalies en fonction des intervalles de confiance ou d'une erreur de reproduction de l'auto-encodeur.
  • Interfaçage avec des systèmes externes tels que les services d'assistance pour l'alerte et la surveillance.
  • Application d'étiquettes à des exemples non étiquetés.
  • Intégrer des outils créés avec des langages autres que Python dans votre flux de travail ML, comme effectuer une analyse de données à l'aide de R.

En mélangeant des composants standard et des composants personnalisés, vous pouvez créer un flux de travail ML qui répond à vos besoins tout en tirant parti des meilleures pratiques intégrées aux composants standard TFX.

Ce guide décrit les concepts requis pour comprendre les composants personnalisés TFX et les différentes manières de créer des composants personnalisés.

Anatomie d'un composant TFX

Cette section fournit un aperçu de haut niveau de la composition d'un composant TFX. Si vous êtes nouveau dans les pipelines TFX, découvrez les concepts de base en lisant le guide pour comprendre les pipelines TFX .

Les composants TFX sont composés d'une spécification de composant et d'une classe d'exécuteur qui sont regroupés dans une classe d'interface de composant.

Une spécification de composant définit le contrat d'entrée et de sortie du composant. Ce contrat spécifie les artefacts d'entrée et de sortie du composant, ainsi que les paramètres utilisés pour l'exécution du composant.

La classe exécuteur d' un composant fournit l'implémentation du travail effectué par le composant.

Une classe d' interface de composant combine la spécification de composant avec l'exécuteur pour une utilisation en tant que composant dans un pipeline TFX.

Composants TFX à l'exécution

Lorsqu'un pipeline exécute un composant TFX, le composant est exécuté en trois phases:

  1. Tout d'abord, le pilote utilise la spécification du composant pour récupérer les artefacts requis du magasin de métadonnées et les transmettre au composant.
  2. Ensuite, l'exécuteur effectue le travail du composant.
  3. Ensuite, l'éditeur utilise la spécification du composant et les résultats de l'exécuteur pour stocker les sorties du composant dans le magasin de métadonnées.

Anatomie des composants

La plupart des implémentations de composants personnalisés ne nécessitent pas que vous personnalisiez le pilote ou l'éditeur. En règle générale, les modifications apportées au pilote et à l'éditeur ne devraient être nécessaires que si vous souhaitez modifier l'interaction entre les composants de votre pipeline et le magasin de métadonnées. Si vous souhaitez uniquement modifier les entrées, les sorties ou les paramètres de votre composant, il vous suffit de modifier la spécification du composant .

Types de composants personnalisés

Il existe trois types de composants personnalisés: les composants basés sur les fonctions Python, les composants basés sur des conteneurs et les composants entièrement personnalisés. Les sections suivantes décrivent les différents types de composants et les cas dans lesquels vous devez utiliser chaque approche.

Composants basés sur les fonctions Python

Les composants basés sur des fonctions Python sont plus faciles à créer que les composants basés sur des conteneurs ou des composants entièrement personnalisés. La spécification du composant est définie dans les arguments de la fonction Python à l'aide d'annotations de type qui décrivent si un argument est un artefact d'entrée, un artefact de sortie ou un paramètre. Le corps de la fonction définit l'exécuteur du composant. L'interface du composant est définie en ajoutant le décorateur @component à votre fonction.

En décorant votre fonction avec le décorateur @component et en définissant les arguments de la fonction avec des annotations de type, vous pouvez créer un composant sans avoir à créer une spécification de composant, un exécuteur et une interface de composant.

Apprenez à créer des composants basés sur des fonctions Python .

Composants basés sur des conteneurs

Les composants basés sur des conteneurs offrent la flexibilité d'intégrer du code écrit dans n'importe quel langage dans votre pipeline, à condition que vous puissiez exécuter ce code dans un conteneur Docker. Pour créer un composant basé sur un conteneur, vous devez créer une image de conteneur Docker qui contient le code exécutable de votre composant. Ensuite, vous devez appeler la fonction create_container_component pour définir:

  • Les entrées, sorties et paramètres de la spécification de votre composant.
  • Image de conteneur et commande exécutées par l'exécuteur du composant.

Cette fonction renvoie une instance d'un composant que vous pouvez inclure dans votre définition de pipeline.

Cette approche est plus complexe que la création d'un composant basé sur une fonction Python, car elle nécessite l'empaquetage de votre code sous forme d'image de conteneur. Cette approche est la plus appropriée pour inclure du code non Python dans votre pipeline ou pour créer des composants Python avec des environnements d'exécution complexes ou des dépendances.

Apprenez à créer des composants basés sur des conteneurs .

Composants entièrement personnalisés

Les composants entièrement personnalisés vous permettent de créer des composants en définissant la spécification de composant, l'exécuteur et les classes d'interface de composant. Cette approche vous permet de réutiliser et d'étendre un composant standard pour répondre à vos besoins.

Si un composant existant est défini avec les mêmes entrées et sorties que le composant personnalisé que vous développez, vous pouvez simplement remplacer la classe Executor du composant existant. Cela signifie que vous pouvez réutiliser une spécification de composant et implémenter un nouvel exécuteur dérivé d'un composant existant. De cette manière, vous réutilisez les fonctionnalités intégrées aux composants existants et implémentez uniquement les fonctionnalités requises.

Si toutefois les entrées et sorties de votre nouveau composant sont uniques, vous pouvez définir une toute nouvelle spécification de composant .

Cette approche est la meilleure pour réutiliser les spécifications et exécuteurs de composants existants.

Apprenez à créer des composants entièrement personnalisés .