Treten Sie der SIG TFX-Addons-Community bei und helfen Sie mit, TFX noch besser zu machen! SIG TFX-Addons beitreten

Besseres ML-Engineering mit ML-Metadaten

Auf TensorFlow.org ansehen In Google Colab ausführen Quelle auf GitHub anzeigen Notizbuch herunterladen

Angenommen, Sie richten eine Produktions-ML-Pipeline ein, um Pinguine zu klassifizieren. Die Pipeline nimmt Ihre Trainingsdaten auf, trainiert und bewertet ein Modell und überträgt es in die Produktion.

Wenn Sie jedoch später versuchen, dieses Modell mit einem größeren Datensatz zu verwenden, der verschiedene Pinguinarten enthält, stellen Sie fest, dass sich Ihr Modell nicht wie erwartet verhält und die Arten falsch klassifiziert.

An dieser Stelle interessiert Sie Folgendes:

  • Was ist die effizienteste Methode zum Debuggen des Modells, wenn das einzige verfügbare Artefakt das Modell in der Produktion ist?
  • Mit welchem ​​Trainingsdatensatz wurde das Modell trainiert?
  • Welcher Trainingslauf führte zu diesem fehlerhaften Modell?
  • Wo sind die Ergebnisse der Modellbewertung?
  • Wo mit dem Debuggen beginnen?

ML Metadaten (MLMD) ist eine Bibliothek, die Metadaten mit ML - Modellen zugeordnet nutzt Ihnen , diese Fragen zu beantworten zu helfen und vieles mehr. Eine hilfreiche Analogie ist, sich diese Metadaten als Äquivalent zum Anmelden bei der Softwareentwicklung vorzustellen. Mit MLMD können Sie die mit den verschiedenen Komponenten Ihrer ML-Pipeline verbundenen Artefakte und Herkunft zuverlässig verfolgen.

In diesem Tutorial richten Sie eine TFX-Pipeline ein, um ein Modell zu erstellen, das Pinguine basierend auf der Körpermasse und der Länge und Tiefe ihrer Halme und der Länge ihrer Flossen in drei Arten einteilt. Anschließend verwenden Sie MLMD, um die Herkunft von Pipelinekomponenten zu verfolgen.

TFX-Pipelines in Colab

Colab ist eine leichtgewichtige Entwicklungsumgebung, die sich deutlich von einer Produktionsumgebung unterscheidet. In der Produktion können Sie verschiedene Pipelinekomponenten wie Datenaufnahme, Transformation, Modelltraining, Ausführungshistorien usw. über mehrere verteilte Systeme hinweg verwenden. Für dieses Tutorial sollten Sie sich bewusst sein, dass es erhebliche Unterschiede bei der Orchestrierung und der Metadatenspeicherung gibt – alles wird lokal in Colab verarbeitet. Erfahren Sie mehr über TFX in Colab hier .

Installieren

Zuerst installieren und importieren wir die erforderlichen Pakete, richten Pfade ein und laden Daten herunter.

Upgrade-Pip

Um zu vermeiden, dass Pip in einem System aktualisiert wird, wenn es lokal ausgeführt wird, stellen Sie sicher, dass wir in Colab ausgeführt werden. Lokale Systeme können natürlich separat nachgerüstet werden.

try:
  import colab
  !pip install --upgrade pip
except:
  pass

TFX installieren und importieren

pip install -q -U tfx

Pakete importieren

Hast du die Laufzeit neu gestartet?

Wenn Sie Google Colab verwenden und die obige Zelle zum ersten Mal ausführen, müssen Sie die Laufzeit neu starten, indem Sie auf die Schaltfläche "LAUFZEIT NEU STARTEN" klicken oder das Menü "Laufzeit > Laufzeit neu starten ..." verwenden. Dies liegt an der Art und Weise, wie Colab Pakete lädt.

import os
import tempfile
import urllib
import pandas as pd

import tensorflow_model_analysis as tfma
from tfx.orchestration.experimental.interactive.interactive_context import InteractiveContext
2021-07-24 09:25:58.004364: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0

Überprüfen Sie die TFX- und MLMD-Versionen.

from tfx import v1 as tfx
print('TFX version: {}'.format(tfx.__version__))
import ml_metadata as mlmd
print('MLMD version: {}'.format(mlmd.__version__))
TFX version: 1.0.0
MLMD version: 1.0.0

Laden Sie den Datensatz herunter

In diesem colab verwenden wir die Palmer Penguins - Datensatz , die gefunden werden können Github . Wir verarbeitet , um die Datenmenge durch alle unvollständigen Datensätze Weglassen und Tropfen island und sex Spalten und konvertiert Etiketten int32 . Der Datensatz enthält 334 Aufzeichnungen über die Körpermasse und die Länge und Tiefe der culmens von Pinguinen und die Länge ihrer Flossen. Sie verwenden diese Daten, um Pinguine in eine von drei Arten zu klassifizieren.

DATA_PATH = 'https://raw.githubusercontent.com/tensorflow/tfx/master/tfx/examples/penguin/data/labelled/penguins_processed.csv'
_data_root = tempfile.mkdtemp(prefix='tfx-data')
_data_filepath = os.path.join(_data_root, "penguins_processed.csv")
urllib.request.urlretrieve(DATA_PATH, _data_filepath)
('/tmp/tfx-dataduqrz_en/penguins_processed.csv',
 <http.client.HTTPMessage at 0x7fba1ebc0e10>)

Erstellen Sie einen InteractiveContext

TFX Komponenten interaktiv in diesem Notebook ausführen zu können, erstellen Sie eine InteractiveContext . Die InteractiveContext verwendet ein temporäres Verzeichnis mit einer ephemeren MLMD Datenbankinstanz. Beachten Sie, dass Anrufe an InteractiveContext nicht-ops außerhalb der Colab Umgebung.

Im Allgemeinen ist es eine gute Praxis - Gruppe ähnliche Pipeline verläuft unter einem Context .

interactive_context = InteractiveContext()
WARNING:absl:InteractiveContext pipeline_root argument not provided: using temporary directory /tmp/tfx-interactive-2021-07-24T09_26_00.721922-9h873pwa as root for pipeline outputs.
WARNING:absl:InteractiveContext metadata_connection_config not provided: using SQLite ML Metadata database at /tmp/tfx-interactive-2021-07-24T09_26_00.721922-9h873pwa/metadata.sqlite.

Konstruieren Sie die TFX-Pipeline

Eine TFX-Pipeline besteht aus mehreren Komponenten, die verschiedene Aspekte des ML-Workflows ausführen. In diesem Notebook, Sie erstellen und die laufen ExampleGen , StatisticsGen , SchemaGen und Trainer Komponenten und verwenden Sie den Evaluator und Pusher Komponente des trainierten Modell zu bewerten und zu schieben.

Beachten Sie die Tutorial - Komponenten Weitere Informationen zu TFX Pipeline - Komponenten.

Instanziieren und Ausführen der ExampleGen-Komponente run

example_gen = tfx.components.CsvExampleGen(input_base=_data_root)
interactive_context.run(example_gen)
WARNING:apache_beam.runners.interactive.interactive_environment:Dependencies required for Interactive Beam PCollection visualization are not available, please use: `pip install apache-beam[interactive]` to install necessary dependencies to enable all data visualization features.
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
WARNING:apache_beam.io.tfrecordio:Couldn't find python-snappy so the implementation of _TFRecordUtil._masked_crc32c is not as fast as it could be.

Instanziieren und Ausführen der StatisticsGen-Komponente

statistics_gen = tfx.components.StatisticsGen(
    examples=example_gen.outputs['examples'])
interactive_context.run(statistics_gen)
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.

Instanziieren und Ausführen der SchemaGen-Komponente

infer_schema = tfx.components.SchemaGen(
    statistics=statistics_gen.outputs['statistics'], infer_feature_shape=True)
interactive_context.run(infer_schema)
2021-07-24 09:26:04.200547: W ml_metadata/metadata_store/rdbms_metadata_access_object.cc:623] No property is defined for the Type

Instanziieren und Ausführen der Trainerkomponente

# Define the module file for the Trainer component
trainer_module_file = 'penguin_trainer.py'
%%writefile {trainer_module_file}

# Define the training algorithm for the Trainer module file
import os
from typing import List, Text

import tensorflow as tf
from tensorflow import keras

from tfx import v1 as tfx
from tfx_bsl.public import tfxio

from tensorflow_metadata.proto.v0 import schema_pb2

# Features used for classification - culmen length and depth, flipper length,
# body mass, and species.

_LABEL_KEY = 'species'

_FEATURE_KEYS = [
    'culmen_length_mm', 'culmen_depth_mm', 'flipper_length_mm', 'body_mass_g'
]


def _input_fn(file_pattern: List[Text],
              data_accessor: tfx.components.DataAccessor,
              schema: schema_pb2.Schema, batch_size: int) -> tf.data.Dataset:
  return data_accessor.tf_dataset_factory(
      file_pattern,
      tfxio.TensorFlowDatasetOptions(
          batch_size=batch_size, label_key=_LABEL_KEY), schema).repeat()


def _build_keras_model():
  inputs = [keras.layers.Input(shape=(1,), name=f) for f in _FEATURE_KEYS]
  d = keras.layers.concatenate(inputs)
  d = keras.layers.Dense(8, activation='relu')(d)
  d = keras.layers.Dense(8, activation='relu')(d)
  outputs = keras.layers.Dense(3)(d)
  model = keras.Model(inputs=inputs, outputs=outputs)
  model.compile(
      optimizer=keras.optimizers.Adam(1e-2),
      loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
      metrics=[keras.metrics.SparseCategoricalAccuracy()])
  return model


def run_fn(fn_args: tfx.components.FnArgs):
  schema = schema_pb2.Schema()
  tfx.utils.parse_pbtxt_file(fn_args.schema_path, schema)
  train_dataset = _input_fn(
      fn_args.train_files, fn_args.data_accessor, schema, batch_size=10)
  eval_dataset = _input_fn(
      fn_args.eval_files, fn_args.data_accessor, schema, batch_size=10)
  model = _build_keras_model()
  model.fit(
      train_dataset,
      epochs=int(fn_args.train_steps / 20),
      steps_per_epoch=20,
      validation_data=eval_dataset,
      validation_steps=fn_args.eval_steps)
  model.save(fn_args.serving_model_dir, save_format='tf')
Writing penguin_trainer.py

Führen Sie die Trainer - Komponente.

trainer = tfx.components.Trainer(
    module_file=os.path.abspath(trainer_module_file),
    examples=example_gen.outputs['examples'],
    schema=infer_schema.outputs['schema'],
    train_args=tfx.proto.TrainArgs(num_steps=100),
    eval_args=tfx.proto.EvalArgs(num_steps=50))
interactive_context.run(trainer)
running bdist_wheel
running build
running build_py
creating build
creating build/lib
copying penguin_trainer.py -> build/lib
installing to /tmp/tmpox9a4duz
running install
running install_lib
copying build/lib/penguin_trainer.py -> /tmp/tmpox9a4duz
running install_egg_info
running egg_info
creating tfx_user_code_Trainer.egg-info
writing tfx_user_code_Trainer.egg-info/PKG-INFO
writing dependency_links to tfx_user_code_Trainer.egg-info/dependency_links.txt
writing top-level names to tfx_user_code_Trainer.egg-info/top_level.txt
writing manifest file 'tfx_user_code_Trainer.egg-info/SOURCES.txt'
reading manifest file 'tfx_user_code_Trainer.egg-info/SOURCES.txt'
writing manifest file 'tfx_user_code_Trainer.egg-info/SOURCES.txt'
Copying tfx_user_code_Trainer.egg-info to /tmp/tmpox9a4duz/tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4-py3.7.egg-info
running install_scripts
creating /tmp/tmpox9a4duz/tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4.dist-info/WHEEL
creating '/tmp/tmpg1jzunkf/tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4-py3-none-any.whl' and adding '/tmp/tmpox9a4duz' to it
adding 'penguin_trainer.py'
adding 'tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4.dist-info/METADATA'
adding 'tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4.dist-info/WHEEL'
adding 'tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4.dist-info/top_level.txt'
adding 'tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4.dist-info/RECORD'
removing /tmp/tmpox9a4duz
2021-07-24 09:26:04.716013: W ml_metadata/metadata_store/rdbms_metadata_access_object.cc:623] No property is defined for the Type
2021-07-24 09:26:04.719884: W ml_metadata/metadata_store/rdbms_metadata_access_object.cc:623] No property is defined for the Type
Processing /tmp/tfx-interactive-2021-07-24T09_26_00.721922-9h873pwa/_wheels/tfx_user_code_Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4-py3-none-any.whl
Installing collected packages: tfx-user-code-Trainer
Successfully installed tfx-user-code-Trainer-0.0+fef7c4ed90dc336ca26daee59d65660cf8da5fa988b2ca0c89df2f558fda10f4
2021-07-24 09:26:06.256595: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcuda.so.1
2021-07-24 09:26:06.260327: E tensorflow/stream_executor/cuda/cuda_driver.cc:328] failed call to cuInit: CUDA_ERROR_SYSTEM_DRIVER_MISMATCH: system has unsupported display driver / cuda driver combination
2021-07-24 09:26:06.260361: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:169] retrieving CUDA diagnostic information for host: kokoro-gcp-ubuntu-prod-559609198
2021-07-24 09:26:06.260368: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:176] hostname: kokoro-gcp-ubuntu-prod-559609198
2021-07-24 09:26:06.260480: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:200] libcuda reported version is: 470.57.2
2021-07-24 09:26:06.260502: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:204] kernel reported version is: 465.27.0
2021-07-24 09:26:06.260508: E tensorflow/stream_executor/cuda/cuda_diagnostics.cc:313] kernel version 465.27.0 does not match DSO version 470.57.2 -- cannot find working devices in this configuration
2021-07-24 09:26:06.260728: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
Epoch 1/5
 1/20 [>.............................] - ETA: 6s - loss: 1.1316 - sparse_categorical_accuracy: 0.0000e+00
2021-07-24 09:26:06.711432: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:176] None of the MLIR Optimization Passes are enabled (registered 2)
2021-07-24 09:26:06.713005: I tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 2000179999 Hz
20/20 [==============================] - 1s 10ms/step - loss: 1.0774 - sparse_categorical_accuracy: 0.4050 - val_loss: 1.0396 - val_sparse_categorical_accuracy: 0.4700
Epoch 2/5
20/20 [==============================] - 0s 5ms/step - loss: 0.9500 - sparse_categorical_accuracy: 0.5350 - val_loss: 0.8672 - val_sparse_categorical_accuracy: 0.7800
Epoch 3/5
20/20 [==============================] - 0s 4ms/step - loss: 0.7380 - sparse_categorical_accuracy: 0.7700 - val_loss: 0.5768 - val_sparse_categorical_accuracy: 0.7800
Epoch 4/5
20/20 [==============================] - 0s 4ms/step - loss: 0.4604 - sparse_categorical_accuracy: 0.8100 - val_loss: 0.4236 - val_sparse_categorical_accuracy: 0.7800
Epoch 5/5
20/20 [==============================] - 0s 4ms/step - loss: 0.3520 - sparse_categorical_accuracy: 0.8150 - val_loss: 0.3400 - val_sparse_categorical_accuracy: 0.7800
2021-07-24 09:26:07.824456: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: /tmp/tfx-interactive-2021-07-24T09_26_00.721922-9h873pwa/Trainer/model/4/Format-Serving/assets
INFO:tensorflow:Assets written to: /tmp/tfx-interactive-2021-07-24T09_26_00.721922-9h873pwa/Trainer/model/4/Format-Serving/assets

Bewerten und pushen Sie das Modell

Verwenden Sie die Evaluator - Komponente zu bewerten und zu ‚segnen‘ das Modell vor der Verwendung Pusher Komponente um das Modell zu einem Servierte Verzeichnis zu schieben.

_serving_model_dir = os.path.join(tempfile.mkdtemp(),
                                  'serving_model/penguins_classification')
eval_config = tfma.EvalConfig(
    model_specs=[
        tfma.ModelSpec(label_key='species', signature_name='serving_default')
    ],
    metrics_specs=[
        tfma.MetricsSpec(metrics=[
            tfma.MetricConfig(
                class_name='SparseCategoricalAccuracy',
                threshold=tfma.MetricThreshold(
                    value_threshold=tfma.GenericValueThreshold(
                        lower_bound={'value': 0.6})))
        ])
    ],
    slicing_specs=[tfma.SlicingSpec()])
evaluator = tfx.components.Evaluator(
    examples=example_gen.outputs['examples'],
    model=trainer.outputs['model'],
    schema=infer_schema.outputs['schema'],
    eval_config=eval_config)
interactive_context.run(evaluator)
2021-07-24 09:26:08.397533: W ml_metadata/metadata_store/rdbms_metadata_access_object.cc:623] No property is defined for the Type
2021-07-24 09:26:08.400911: W ml_metadata/metadata_store/rdbms_metadata_access_object.cc:623] No property is defined for the Type
WARNING:root:Make sure that locally built Python SDK docker image has Python 3.7 interpreter.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:113: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_model_analysis/writers/metrics_plots_and_validations_writer.py:113: tf_record_iterator (from tensorflow.python.lib.io.tf_record) is deprecated and will be removed in a future version.
Instructions for updating:
Use eager execution and: 
`tf.data.TFRecordDataset(path)`
pusher = tfx.components.Pusher(
    model=trainer.outputs['model'],
    model_blessing=evaluator.outputs['blessing'],
    push_destination=tfx.proto.PushDestination(
        filesystem=tfx.proto.PushDestination.Filesystem(
            base_directory=_serving_model_dir)))
interactive_context.run(pusher)
2021-07-24 09:26:12.698547: W ml_metadata/metadata_store/rdbms_metadata_access_object.cc:623] No property is defined for the Type

Das Ausführen der TFX-Pipeline füllt die MLMD-Datenbank. Im nächsten Abschnitt verwenden Sie die MLMD-API, um diese Datenbank nach Metadateninformationen abzufragen.

Abfrage der MLMD-Datenbank

Die MLMD-Datenbank speichert drei Arten von Metadaten:

  • Metadaten zur Pipeline und Herkunftsinformationen, die den Pipelinekomponenten zugeordnet sind
  • Metadaten zu Artefakten, die während der Pipelineausführung generiert wurden
  • Metadaten zu den Ausführungen der Pipeline

Eine typische Produktionsumgebungspipeline bedient mehrere Modelle, wenn neue Daten eintreffen. Wenn Sie in bereitgestellten Modellen auf fehlerhafte Ergebnisse stoßen, können Sie die MLMD-Datenbank abfragen, um die fehlerhaften Modelle zu isolieren. Sie können dann die Herkunft der Pipelinekomponenten verfolgen, die diesen Modellen entsprechen, um Ihre Modelle zu debuggen

Stellen Sie die Metadaten (MD) Speicher nehmen mit dem InteractiveContext zuvor definierten die MLMD Datenbank abzufragen.

connection_config = interactive_context.metadata_connection_config
store = mlmd.MetadataStore(connection_config)

# All TFX artifacts are stored in the base directory
base_dir = connection_config.sqlite.filename_uri.split('metadata.sqlite')[0]

Erstellen Sie einige Hilfsfunktionen, um die Daten aus dem MD-Speicher anzuzeigen.

def display_types(types):
  # Helper function to render dataframes for the artifact and execution types
  table = {'id': [], 'name': []}
  for a_type in types:
    table['id'].append(a_type.id)
    table['name'].append(a_type.name)
  return pd.DataFrame(data=table)
def display_artifacts(store, artifacts):
  # Helper function to render dataframes for the input artifacts
  table = {'artifact id': [], 'type': [], 'uri': []}
  for a in artifacts:
    table['artifact id'].append(a.id)
    artifact_type = store.get_artifact_types_by_id([a.type_id])[0]
    table['type'].append(artifact_type.name)
    table['uri'].append(a.uri.replace(base_dir, './'))
  return pd.DataFrame(data=table)
def display_properties(store, node):
  # Helper function to render dataframes for artifact and execution properties
  table = {'property': [], 'value': []}
  for k, v in node.properties.items():
    table['property'].append(k)
    table['value'].append(
        v.string_value if v.HasField('string_value') else v.int_value)
  for k, v in node.custom_properties.items():
    table['property'].append(k)
    table['value'].append(
        v.string_value if v.HasField('string_value') else v.int_value)
  return pd.DataFrame(data=table)

Zuerst Abfrage der MD Speicher für eine Liste aller seiner gespeicherten ArtifactTypes .

display_types(store.get_artifact_types())

Als nächstes Abfrage alle PushedModel Artefakte.

pushed_models = store.get_artifacts_by_type("PushedModel")
display_artifacts(store, pushed_models)

Fragen Sie den MD-Speicher nach dem neuesten Push-Modell ab. Dieses Tutorial hat nur ein gepushtes Modell.

pushed_model = pushed_models[-1]
display_properties(store, pushed_model)

Einer der ersten Schritte beim Debuggen eines gepushten Modells besteht darin, zu prüfen, welches trainierte Modell gepusht wird und welche Trainingsdaten zum Trainieren dieses Modells verwendet werden.

MLMD bietet Traversal-APIs zum Durchlaufen des Provenienzdiagramms, mit denen Sie die Modellherkunft analysieren können.

def get_one_hop_parent_artifacts(store, artifacts):
  # Get a list of artifacts within a 1-hop of the artifacts of interest
  artifact_ids = [artifact.id for artifact in artifacts]
  executions_ids = set(
      event.execution_id
      for event in store.get_events_by_artifact_ids(artifact_ids)
      if event.type == mlmd.proto.Event.OUTPUT)
  artifacts_ids = set(
      event.artifact_id
      for event in store.get_events_by_execution_ids(executions_ids)
      if event.type == mlmd.proto.Event.INPUT)
  return [artifact for artifact in store.get_artifacts_by_id(artifacts_ids)]

Fragen Sie die übergeordneten Artefakte für das übertragene Modell ab.

parent_artifacts = get_one_hop_parent_artifacts(store, [pushed_model])
display_artifacts(store, parent_artifacts)

Fragen Sie die Eigenschaften für das Modell ab.

exported_model = parent_artifacts[0]
display_properties(store, exported_model)

Fragen Sie die Upstream-Artefakte für das Modell ab.

model_parents = get_one_hop_parent_artifacts(store, [exported_model])
display_artifacts(store, model_parents)

Rufen Sie die Trainingsdaten ab, mit denen das Modell trainiert wurde.

used_data = model_parents[0]
display_properties(store, used_data)

Nachdem Sie nun über die Trainingsdaten verfügen, mit denen das Modell trainiert hat, fragen Sie die Datenbank erneut ab, um den Trainingsschritt (Ausführung) zu finden. Fragen Sie den MD-Speicher nach einer Liste der registrierten Ausführungsarten ab.

display_types(store.get_execution_types())

Der Trainingsschritt ist die ExecutionType namens tfx.components.trainer.component.Trainer . Durchqueren Sie den MD-Laden, um den Trainerlauf zu erhalten, der dem übertragenen Modell entspricht.

def find_producer_execution(store, artifact):
  executions_ids = set(
      event.execution_id
      for event in store.get_events_by_artifact_ids([artifact.id])
      if event.type == mlmd.proto.Event.OUTPUT)
  return store.get_executions_by_id(executions_ids)[0]

trainer = find_producer_execution(store, exported_model)
display_properties(store, trainer)

Zusammenfassung

In diesem Tutorial haben Sie erfahren, wie Sie MLMD nutzen können, um die Herkunft Ihrer TFX-Pipeline-Komponenten zu verfolgen und Probleme zu beheben.

Weitere Informationen zur Verwendung von MLMD finden Sie in diesen zusätzlichen Ressourcen: