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

Composants de fonction Python personnalisés

La définition de composant basée sur la fonction Python vous permet de créer plus facilement des composants personnalisés TFX, en vous épargnant l'effort de définir une classe de spécification de composant, une classe d'exécuteur et une classe d'interface de composant. Dans ce style de définition de composant, vous écrivez une fonction annotée avec des indications de type. Les conseils de type décrivent les artefacts d'entrée, les artefacts de sortie et les paramètres de votre composant.

L'écriture de votre composant personnalisé dans ce style est très simple, comme dans l'exemple suivant.

@component
def MyValidationComponent(
    model: InputArtifact[Model],
    blessing: OutputArtifact[Model],
    accuracy_threshold: Parameter[int] = 10,
    ) -> OutputDict(accuracy=float):
  '''My simple custom model validation component.'''

  accuracy = evaluate_model(model)
  if accuracy >= accuracy_threshold:
    write_output_blessing(blessing)

  return {
    'accuracy': accuracy
  }

Si vous débutez avec les pipelines TFX, apprenez-en plus sur les concepts de base des pipelines TFX .

Entrées, sorties et paramètres

Dans TFX, les entrées et les sorties sont suivies en tant qu'objets Artefact qui décrivent l'emplacement et les propriétés des métadonnées associées aux données sous-jacentes ; ces informations sont stockées dans ML Metadata. Les artefacts peuvent décrire des types de données complexes ou des types de données simples, tels que : int, float, bytes ou chaînes unicode.

Un paramètre est un argument (entier, flottant, octets ou chaîne Unicode) d'un composant connu au moment de la construction du pipeline. Les paramètres sont utiles pour spécifier des arguments et des hyperparamètres tels que le nombre d'itérations de formation, le taux d'abandon et d'autres configurations de votre composant. Les paramètres sont stockés en tant que propriétés des exécutions de composants lorsqu'ils sont suivis dans les métadonnées ML.

Définition

Pour créer un composant personnalisé, écrivez une fonction qui implémente votre logique personnalisée et décorez-la avec le @component @component du module tfx.dsl.component.experimental.decorators . Pour définir le schéma d'entrée et de sortie de votre composant, annotez les arguments et la valeur de retour de votre fonction à l'aide des annotations du module tfx.dsl.component.experimental.annotations :

  • Pour chaque entrée d'artefact , appliquez l'annotation d'indication de type InputArtifact[ArtifactType] . Remplacez ArtifactType par le type de l'artefact, qui est une sous-classe de tfx.types.Artifact . Ces entrées peuvent être des arguments facultatifs.

  • Pour chaque artefact de sortie , appliquez l'annotation d'indication de type OutputArtifact[ArtifactType] . Remplacez ArtifactType par le type de l'artefact, qui est une sous-classe de tfx.types.Artifact . Les artefacts de sortie de composant doivent être transmis en tant qu'arguments d'entrée de la fonction, afin que votre composant puisse écrire des sorties dans un emplacement géré par le système et définir les propriétés de métadonnées d'artefact appropriées. Cet argument peut être facultatif ou cet argument peut être défini avec une valeur par défaut.

  • Pour chaque paramètre , utilisez l'annotation d'indication de type Parameter[T] . Remplacez T par le type du paramètre. Nous ne prenons actuellement en charge que les types python primitifs : bool , int , float , str ou bytes .

  • Pour chaque entrée de type de données simple ( int , float , str ou bytes ) inconnue au moment de la construction du pipeline, utilisez le type hint T . Notez que dans la version TFX 0.22, les valeurs concrètes ne peuvent pas être transmises au moment de la construction du pipeline pour ce type d'entrée (utilisez plutôt l'annotation Parameter , comme décrit dans la section précédente). Cet argument peut être facultatif ou cet argument peut être défini avec une valeur par défaut. Si votre composant a des sorties de type de données simples ( int , float , str ou bytes ), vous pouvez renvoyer ces sorties à l'aide d'une instance OutputDict . Appliquez l'indicateur de type OutputDict comme valeur de retour de votre composant.

  • Pour chaque output , ajoutez l'argument <output_name>=<T> au constructeur OutputDict , où <output_name> est le nom de la sortie et <T> est le type de sortie, par exemple : int , float , str ou bytes .

Dans le corps de votre fonction, les artefacts d'entrée et de sortie sont transmis en tant tfx.types.Artifact ; vous pouvez inspecter son .uri pour obtenir son emplacement géré par le système et lire/définir toutes les propriétés. Les paramètres d'entrée et les entrées de type de données simples sont transmis en tant qu'objets du type spécifié. Les sorties de type de données simples doivent être renvoyées sous forme de dictionnaire, où les clés sont les noms de sortie appropriés et les valeurs sont les valeurs de retour souhaitées.

Le composant de fonction terminé peut ressembler à ceci :

import tfx.v1 as tfx
from tfx.dsl.component.experimental.decorators import component

@component
def MyTrainerComponent(
    training_data: tfx.dsl.components.InputArtifact[tfx.types.standard_artifacts.Examples],
    model: tfx.dsl.components.OutputArtifact[tfx.types.standard_artifacts.Model],
    dropout_hyperparameter: float,
    num_iterations: tfx.dsl.components.Parameter[int] = 10
    ) -> tfx.v1.dsl.components.OutputDict(loss=float, accuracy=float):
  '''My simple trainer component.'''

  records = read_examples(training_data.uri)
  model_obj = train_model(records, num_iterations, dropout_hyperparameter)
  model_obj.write_to(model.uri)

  return {
    'loss': model_obj.loss,
    'accuracy': model_obj.accuracy
  }

# Example usage in a pipeline graph definition:
# ...
trainer = MyTrainerComponent(
    examples=example_gen.outputs['examples'],
    dropout_hyperparameter=other_component.outputs['dropout'],
    num_iterations=1000)
pusher = Pusher(model=trainer.outputs['model'])
# ...

L'exemple précédent définit MyTrainerComponent comme un composant personnalisé basé sur une fonction Python. Ce composant consomme un artefact d' examples en entrée et produit un artefact de model en sortie. Le composant utilise l' artifact_instance.uri pour lire ou écrire l'artefact à son emplacement géré par le système. Le composant prend un paramètre d'entrée num_iterations et une valeur de type de données simple dropout_hyperparameter , et le composant génère des métriques de loss et de accuracy sous forme de valeurs de sortie de type de données simples. L'artefact du model de sortie est ensuite utilisé par le composant Pusher .