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

Die ExampleGen TFX-Pipeline-Komponente

Die Komponente "ExampleGen TFX Pipeline" nimmt Daten in TFX-Pipelines auf. Es verbraucht externe Dateien/Dienste, um Beispiele zu generieren, die von anderen TFX-Komponenten gelesen werden. Es bietet auch eine konsistente und konfigurierbare Partition und mischt das Dataset für ML-Best Practices.

  • Verbraucht: Daten aus externen Datenquellen wie CSV, TFRecord , Avro, Parquet und BigQuery.
  • Gibt: tf.Example Records, tf.SequenceExample Records oder Proto-Format aus, abhängig vom Payload-Format.

ExampleGen und andere Komponenten

ExampleGen stellt Daten für Komponenten bereit, die die TensorFlow Data Validation- Bibliothek verwenden, z. B. SchemaGen , StatisticsGen und Example Validator . Es stellt auch Daten für Transform bereit, das die TensorFlow Transform- Bibliothek verwendet, und schließlich für Bereitstellungsziele während der Inferenz.

Datenquellen und Formate

Derzeit enthält eine Standardinstallation von TFX vollständige ExampleGen-Komponenten für diese Datenquellen und Formate:

Es sind auch benutzerdefinierte Executoren verfügbar, die die Entwicklung von ExampleGen-Komponenten für diese Datenquellen und Formate ermöglichen:

Weitere Informationen zur Verwendung und Entwicklung von benutzerdefinierten Executoren finden Sie in den Verwendungsbeispielen im Quellcode und in dieser Diskussion .

Darüber hinaus stehen diese Datenquellen und Formate als benutzerdefinierte Komponentenbeispiele zur Verfügung:

Aufnahme von Datenformaten, die von Apache Beam unterstützt werden

Apache Beam unterstützt die Aufnahme von Daten aus einer Vielzahl von Datenquellen und -formaten ( siehe unten ). Diese Fähigkeiten können verwendet werden, um benutzerdefinierte ExampleGen-Komponenten für TFX zu erstellen, was durch einige vorhandene ExampleGen-Komponenten demonstriert wird ( siehe unten ).

So verwenden Sie eine ExampleGen-Komponente

Für unterstützte Datenquellen (derzeit CSV-Dateien, TFRecord-Dateien mit tf.Example , tf.SequenceExample und proto-Format sowie Ergebnisse von BigQuery-Abfragen) kann die ExampleGen-Pipelinekomponente direkt in der Bereitstellung verwendet werden und erfordert nur geringe Anpassungen. Beispielsweise:

example_gen = CsvExampleGen(input_base='data_root')

oder wie unten, um externes TFRecord mit tf.Example direkt zu importieren:

example_gen = ImportExampleGen(input_base=path_to_tfrecord_dir)

Spanne, Version und Split

Ein Span ist eine Gruppierung von Trainingsbeispielen. Wenn Ihre Daten auf einem Dateisystem gespeichert werden, kann jeder Span in einem separaten Verzeichnis gespeichert werden. Die Semantik eines Spans ist in TFX nicht fest codiert; a Span kann einem Datentag, einer Datenstunde oder einer anderen Gruppierung entsprechen, die für Ihre Aufgabe von Bedeutung ist.

Jeder Span kann mehrere Datenversionen enthalten. Wenn Sie beispielsweise einige Beispiele aus einem Span entfernen, um Daten von schlechter Qualität zu bereinigen, kann dies zu einer neuen Version dieses Spans führen. Standardmäßig arbeiten TFX-Komponenten mit der neuesten Version innerhalb eines Spans.

Jede Version innerhalb eines Spans kann weiter in mehrere Splits unterteilt werden. Der häufigste Anwendungsfall für das Aufteilen eines Spans besteht darin, ihn in Trainings- und Evaluierungsdaten aufzuteilen.

Spannen und Splits

Benutzerdefinierte Eingabe/Ausgabe-Aufteilung

Um das Zug/Evaluierungs-Aufteilungsverhältnis anzupassen, das ExampleGen ausgibt, legen Sie die output_config für die ExampleGen-Komponente fest. Beispielsweise:

# Input has a single split 'input_dir/*'.
# Output 2 splits: train:eval=3:1.
output = proto.Output(
             split_config=example_gen_pb2.SplitConfig(splits=[
                 proto.SplitConfig.Split(name='train', hash_buckets=3),
                 proto.SplitConfig.Split(name='eval', hash_buckets=1)
             ]))
example_gen = CsvExampleGen(input_base=input_dir, output_config=output)

Beachten Sie, wie die hash_buckets in diesem Beispiel festgelegt wurden.

input_config für eine bereits geteilte input_config die input_config für die ExampleGen-Komponente fest:


# Input train split is 'input_dir/train/*', eval split is 'input_dir/eval/*'.
# Output splits are generated one-to-one mapping from input splits.
input = proto.Input(splits=[
                example_gen_pb2.Input.Split(name='train', pattern='train/*'),
                example_gen_pb2.Input.Split(name='eval', pattern='eval/*')
            ])
example_gen = CsvExampleGen(input_base=input_dir, input_config=input)

Für dateibasierte Beispielgen (z. B. CsvExampleGen und ImportExampleGen) ist pattern ein glob-relatives Dateimuster, das auf Eingabedateien abgebildet wird, wobei das Stammverzeichnis durch den Eingabebasispfad angegeben wird. Für abfragebasierte Beispielgen (zB BigQueryExampleGen, PrestoExampleGen) ist pattern eine SQL-Abfrage.

Standardmäßig wird das gesamte Eingabe-Basisverzeichnis als einzelne Eingabeaufteilung behandelt, und die Aufteilung der Zug- und Auswertungsausgabe wird mit einem Verhältnis von 2:1 generiert.

Bitte beziehen Sie sich auf proto/example_gen.proto für die Input- und Output-Split-Konfiguration von ExampleGen. Weitere Informationen zur Verwendung der benutzerdefinierten Splits nachgelagert finden Sie im Leitfaden für nachgelagerte Komponenten .

Aufteilungsmethode

Wenn hash_buckets Aufteilungsmethode hash_buckets verwenden, können Sie anstelle des gesamten Datensatzes eine Funktion zum Partitionieren der Beispiele verwenden. Wenn eine Funktion vorhanden ist, verwendet ExampleGen einen Fingerabdruck dieser Funktion als Partitionsschlüssel.

Diese Funktion kann verwendet werden, um eine stabile Aufteilung bezüglich bestimmter Eigenschaften von Beispielen aufrechtzuerhalten: zum Beispiel wird ein Benutzer immer in dieselbe Aufteilung gestellt, wenn "user_id" als Partitionsfunktionsname ausgewählt wurde.

Die Interpretation dessen, was ein "Feature" bedeutet und wie ein "Feature" mit dem angegebenen Namen abgeglichen wird, hängt von der ExampleGen-Implementierung und dem Typ der Beispiele ab.

Für fertige ExampleGen-Implementierungen:

  • Wenn es tf.Example erzeugt, dann bedeutet ein "Feature" einen Eintrag in tf.Example.features.feature.
  • Wenn es tf.SequenceExample generiert, dann bedeutet ein "Feature" einen Eintrag in tf.SequenceExample.context.feature.
  • Es werden nur int64- und bytes-Funktionen unterstützt.

In den folgenden Fällen löst ExampleGen Laufzeitfehler aus:

  • Der angegebene Featurename ist im Beispiel nicht vorhanden.
  • Leere Funktion: tf.train.Feature() .
  • Nicht unterstützte Feature-Typen, zB Float-Features.

Um die Train/Eval-Aufteilung basierend auf einem Feature in den Beispielen output_config , legen Sie die output_config für die ExampleGen-Komponente fest. Beispielsweise:

# Input has a single split 'input_dir/*'.
# Output 2 splits based on 'user_id' features: train:eval=3:1.
output = proto.Output(
             split_config=proto.SplitConfig(splits=[
                 proto.SplitConfig.Split(name='train', hash_buckets=3),
                 proto.SplitConfig.Split(name='eval', hash_buckets=1)
             ],
             partition_feature_name='user_id'))
example_gen = CsvExampleGen(input_base=input_dir, output_config=output)

Beachten Sie, wie partition_feature_name in diesem Beispiel festgelegt wurde.

Spanne

Span kann mit der Spezifikation '{SPAN}' im Eingabe-Glob-Muster abgerufen werden:

  • Diese Spezifikation gleicht Ziffern ab und ordnet die Daten den entsprechenden SPAN-Nummern zu. 'data_{SPAN}-*.tfrecord' sammelt beispielsweise Dateien wie 'data_12-a.tfrecord', 'date_12-b.tfrecord'.
  • Optional kann diese Spezifikation bei der Zuordnung mit der Breite der Ganzzahlen angegeben werden. Beispielsweise wird 'data_{SPAN:2}.file' Dateien wie 'data_02.file' und 'data_27.file' zugeordnet (als Eingaben für Span-2 bzw. Span-27), aber nicht 'data_1. file' noch 'data_123.file'.
  • Wenn die SPAN-Spezifikation fehlt, wird davon ausgegangen, dass sie immer Span '0' ist.
  • Wenn SPAN angegeben ist, verarbeitet die Pipeline den neuesten Span und speichert die Spannummer in den Metadaten.

Nehmen wir beispielsweise an, es gibt Eingabedaten:

  • '/tmp/span-1/train/data'
  • '/tmp/span-1/eval/data'
  • '/tmp/span-2/train/data'
  • '/tmp/span-2/eval/data'

und die Eingabekonfiguration wird wie folgt angezeigt:

splits {
  name: 'train'
  pattern: 'span-{SPAN}/train/*'
}
splits {
  name: 'eval'
  pattern: 'span-{SPAN}/eval/*'
}

Beim Auslösen der Pipeline wird Folgendes verarbeitet:

  • '/tmp/span-2/train/data' als Zugaufteilung
  • '/tmp/span-2/eval/data' als eval split

mit Span-Nummer als '2'. Wenn später '/tmp/span-3/...' bereit sind, triggern Sie einfach die Pipeline erneut und sie nimmt Span '3' zur Verarbeitung auf. Unten sehen Sie das Codebeispiel für die Verwendung der Span-Spezifikation:

input = proto.Input(splits=[
                proto.Input.Split(name='train',
                                            pattern='span-{SPAN}/train/*'),
                proto.Input.Split(name='eval',
                                            pattern='span-{SPAN}/eval/*')
            ])
example_gen = CsvExampleGen(input_base='/tmp', input_config=input)

Das Abrufen einer bestimmten Spanne kann mit RangeConfig erfolgen, das unten beschrieben wird.

Datum

Wenn Ihre Datenquelle im Dateisystem nach Datum organisiert ist, unterstützt TFX die direkte Zuordnung von Datumsangaben zu Spannweiten. Es gibt drei Spezifikationen, um die Zuordnung von Daten zu Spannen darzustellen: {YYYY}, {MM} und {DD}:

  • Die drei Spezifikationen sollten insgesamt im Eingabe-Glob-Muster vorhanden sein, sofern eine Angabe vorliegt:
  • Entweder {SPAN}-Spezifikation oder dieser Satz von Datumsspezifikationen kann exklusiv angegeben werden.
  • Ein Kalenderdatum mit dem Jahr von YYYY, dem Monat von MM und dem Tag des Monats von DD wird berechnet, dann wird die Span-Nummer als Anzahl der Tage seit der Unix-Epoche (dh 1970-01-01) berechnet. 'log-{YYYY}{MM}{DD}.data' stimmt beispielsweise mit einer Datei 'log-19700101.data' überein und verwendet sie als Eingabe für Span-0 und 'log-20170101.data' als Eingabe für Spannweite-17167.
  • Wenn dieser Satz von Datumsspezifikationen angegeben ist, verarbeitet die Pipeline das späteste Datum und speichert die entsprechende Span-Nummer in den Metadaten.

Angenommen, es gibt Eingabedaten, die nach Kalenderdatum organisiert sind:

  • '/tmp/1970-01-02/train/data'
  • '/tmp/1970-01-02/eval/data'
  • '/tmp/1970-01-03/train/data'
  • '/tmp/1970-01-03/eval/data'

und die Eingabekonfiguration wird wie folgt angezeigt:

splits {
  name: 'train'
  pattern: '{YYYY}-{MM}-{DD}/train/*'
}
splits {
  name: 'eval'
  pattern: '{YYYY}-{MM}-{DD}/eval/*'
}

Beim Auslösen der Pipeline wird Folgendes verarbeitet:

  • '/tmp/1970-01-03/train/data' als Zugaufteilung
  • '/tmp/1970-01-03/eval/data' als Auswertungssplit

mit Span-Nummer als '2'. Wenn später '/tmp/1970-01-04/...' bereit sind, triggern Sie die Pipeline einfach erneut und sie nimmt Span '3' zur Verarbeitung auf. Unten sehen Sie das Codebeispiel für die Verwendung der Datumsspezifikation:

input = proto.Input(splits=[
                proto.Input.Split(name='train',
                                            pattern='{YYYY}-{MM}-{DD}/train/*'),
                proto.Input.Split(name='eval',
                                            pattern='{YYYY}-{MM}-{DD}/eval/*')
            ])
example_gen = CsvExampleGen(input_base='/tmp', input_config=input)

Ausführung

Die Version kann mithilfe der '{VERSION}'-Spezifikation im Eingabe-Glob-Muster abgerufen werden:

  • Diese Spezifikation gleicht Ziffern ab und ordnet die Daten den entsprechenden VERSION-Nummern unter dem SPAN zu. Beachten Sie, dass die Versionsspezifikation in Kombination mit Span- oder Datumsspezifikation verwendet werden kann.
  • Diese Spezifikation kann ebenso wie die SPAN-Spezifikation optional mit der Breite angegeben werden. zB 'span-{SPAN}/version-{VERSION:4}/data-*'.
  • Wenn die VERSION-Spezifikation fehlt, wird die Version auf Keine gesetzt.
  • Wenn sowohl SPAN als auch VERSION angegeben sind, verarbeitet die Pipeline die neueste Version für den neuesten Span und speichert die Versionsnummer in den Metadaten.
  • Wenn VERSION angegeben ist, aber nicht SPAN (oder Datumsangabe), wird ein Fehler ausgegeben.

Nehmen wir beispielsweise an, es gibt Eingabedaten:

  • '/tmp/span-1/ver-1/train/data'
  • '/tmp/span-1/ver-1/eval/data'
  • '/tmp/span-2/ver-1/train/data'
  • '/tmp/span-2/ver-1/eval/data'
  • '/tmp/span-2/ver-2/train/data'
  • '/tmp/span-2/ver-2/eval/data'

und die Eingabekonfiguration wird wie folgt angezeigt:

splits {
  name: 'train'
  pattern: 'span-{SPAN}/ver-{VERSION}/train/*'
}
splits {
  name: 'eval'
  pattern: 'span-{SPAN}/ver-{VERSION}/eval/*'
}

Beim Auslösen der Pipeline wird Folgendes verarbeitet:

  • '/tmp/span-2/ver-2/train/data' als Zugaufteilung
  • '/tmp/span-2/ver-2/eval/data' als eval split

mit Span-Nummer als '2' und Versionsnummer als '2'. Wenn später '/tmp/span-2/ver-3/...' bereit sind, triggern Sie einfach die Pipeline erneut und sie nimmt Span '2' und Version '3' zur Verarbeitung auf. Unten sehen Sie das Codebeispiel für die Verwendung der Versionsspezifikation:

input = proto.Input(splits=[
                proto.Input.Split(name='train',
                                            pattern='span-{SPAN}/ver-{VERSION}/train/*'),
                proto.Input.Split(name='eval',
                                            pattern='span-{SPAN}/ver-{VERSION}/eval/*')
            ])
example_gen = CsvExampleGen(input_base='/tmp', input_config=input)

Bereichskonfiguration

TFX unterstützt das Abrufen und Verarbeiten einer bestimmten Spanne in dateibasiertem ExampleGen mithilfe von range config, einer abstrakten Konfiguration, die verwendet wird, um Bereiche für verschiedene TFX-Entitäten zu beschreiben. Um eine bestimmte Spanne abzurufen, legen Sie range_config für eine dateibasierte ExampleGen-Komponente fest. Nehmen wir beispielsweise an, es gibt Eingabedaten:

  • '/tmp/span-01/train/data'
  • '/tmp/span-01/eval/data'
  • '/tmp/span-02/train/data'
  • '/tmp/span-02/eval/data'

Um gezielt Daten mit Span '1' abzurufen und zu verarbeiten, geben wir zusätzlich zur Eingabekonfiguration eine Bereichskonfiguration an. Beachten Sie, dass ExampleGen nur statische Single-Span-Bereiche unterstützt (um die Verarbeitung bestimmter individueller Spans anzugeben). Daher muss für StaticRange start_span_number gleich end_span_number sein. Unter Verwendung des bereitgestellten Spans und der Spanbreiteninformationen (sofern vorhanden) für das Zero-Padding ersetzt ExampleGen die SPAN-Spezifikation in den bereitgestellten Splitmustern durch die gewünschte Spannummer. Ein Anwendungsbeispiel ist unten dargestellt:

# In cases where files have zero-padding, the width modifier in SPAN spec is
# required so TFX can correctly substitute spec with zero-padded span number.
input = proto.Input(splits=[
                proto.Input.Split(name='train',
                                            pattern='span-{SPAN:2}/train/*'),
                proto.Input.Split(name='eval',
                                            pattern='span-{SPAN:2}/eval/*')
            ])
# Specify the span number to be processed here using StaticRange.
range = proto.RangeConfig(
                static_range=proto.StaticRange(
                        start_span_number=1, end_span_number=1)
            )

# After substitution, the train and eval split patterns will be
# 'input_dir/span-01/train/*' and 'input_dir/span-01/eval/*', respectively.
example_gen = CsvExampleGen(input_base=input_dir, input_config=input,
                            range_config=range)

Die Bereichskonfiguration kann auch verwendet werden, um bestimmte Daten zu verarbeiten, wenn die Datumsspezifikation anstelle von SPAN-Spezifikation verwendet wird. Angenommen, es gibt Eingabedaten, die nach Kalenderdatum organisiert sind:

  • '/tmp/1970-01-02/train/data'
  • '/tmp/1970-01-02/eval/data'
  • '/tmp/1970-01-03/train/data'
  • '/tmp/1970-01-03/eval/data'

Um Daten speziell am 2. Januar 1970 abzurufen und zu verarbeiten, gehen wir wie folgt vor:

from  tfx.components.example_gen import utils

input = proto.Input(splits=[
                proto.Input.Split(name='train',
                                            pattern='{YYYY}-{MM}-{DD}/train/*'),
                proto.Input.Split(name='eval',
                                            pattern='{YYYY}-{MM}-{DD}/eval/*')
            ])
# Specify date to be converted to span number to be processed using StaticRange.
span = utils.date_to_span_number(1970, 1, 2)
range = proto.RangeConfig(
                static_range=range_config_pb2.StaticRange(
                        start_span_number=span, end_span_number=span)
            )

# After substitution, the train and eval split patterns will be
# 'input_dir/1970-01-02/train/*' and 'input_dir/1970-01-02/eval/*',
# respectively.
example_gen = CsvExampleGen(input_base=input_dir, input_config=input,
                            range_config=range)

Benutzerdefiniertes BeispielGen

Wenn die derzeit verfügbaren ExampleGen-Komponenten nicht Ihren Anforderungen entsprechen, können Sie ein benutzerdefiniertes ExampleGen erstellen, mit dem Sie aus verschiedenen Datenquellen oder in verschiedenen Datenformaten lesen können.

Dateibasierte ExampleGen-Anpassung (experimentell)

Erweitern Sie zunächst BaseExampleGenExecutor mit einer benutzerdefinierten Beam PTransform, die die Konvertierung von Ihrem Train/Eval-Input-Split in TF-Beispiele ermöglicht. Der CsvExampleGen-Executor bietet beispielsweise die Konvertierung von einer CSV-Eingabeaufteilung in TF-Beispiele.

Erstellen Sie dann eine Komponente mit dem obigen Executor, wie in CsvExampleGen component . Alternativ können Sie einen benutzerdefinierten Executor an die Standard-ExampleGen-Komponente übergeben, wie unten gezeigt.

from tfx.components.base import executor_spec
from tfx.components.example_gen.csv_example_gen import executor

example_gen = FileBasedExampleGen(
    input_base=os.path.join(base_dir, 'data/simple'),
    custom_executor_spec=executor_spec.ExecutorClassSpec(executor.Executor))

Jetzt unterstützen wir auch das Lesen von Avro- und Parquet-Dateien mit dieser Methode .

Zusätzliche Datenformate

Apache Beam unterstützt das Lesen einer Reihe zusätzlicher Datenformate . durch Strahl-I/O-Transformationen. Sie können benutzerdefinierte ExampleGen-Komponenten erstellen, indem Sie die Beam-I/O-Transformationen mit einem Muster ähnlich dem Avro-Beispiel nutzen

  return (pipeline
          | 'ReadFromAvro' >> beam.io.ReadFromAvro(avro_pattern)
          | 'ToTFExample' >> beam.Map(utils.dict_to_example))

Zu den derzeit unterstützten Formaten und Datenquellen für das Beam Python SDK gehören:

  • Amazon S3
  • Apache Avro
  • Apache Hadoop
  • Apache Kafka
  • Apache-Parkett
  • Google Cloud BigQuery
  • Google Cloud BigTable
  • Google Cloud-Datenspeicher
  • Google Cloud Pub/Sub
  • Google Cloud-Speicher (GCS)
  • MongoDB

Die neueste Liste finden Sie in den Beam-Dokumenten .

Abfragebasierte ExampleGen-Anpassung (experimentell)

Erweitern Sie zunächst BaseExampleGenExecutor mit einer benutzerdefinierten Beam PTransform, die aus der externen Datenquelle liest. Erstellen Sie dann eine einfache Komponente, indem Sie QueryBasedExampleGen erweitern.

Dies kann zusätzliche Verbindungskonfigurationen erfordern oder nicht. Der BigQuery-Executor liest beispielsweise mit einem standardmäßigen beam.io-Connector, der die Verbindungskonfigurationsdetails abstrahiert. Der Presto Executor benötigt als Eingabe eine benutzerdefinierte Beam PTransform und ein benutzerdefiniertes Verbindungskonfigurationsprotokoll .

Wenn für eine benutzerdefinierte ExampleGen-Komponente eine Verbindungskonfiguration erforderlich ist, erstellen Sie ein neues Protokoll und übergeben Sie es über custom_config, das jetzt ein optionaler Ausführungsparameter ist. Nachfolgend finden Sie ein Beispiel für die Verwendung einer konfigurierten Komponente.

from tfx.examples.custom_components.presto_example_gen.proto import presto_config_pb2
from tfx.examples.custom_components.presto_example_gen.presto_component.component import PrestoExampleGen

presto_config = presto_config_pb2.PrestoConnConfig(host='localhost', port=8080)
example_gen = PrestoExampleGen(presto_config, query='SELECT * FROM chicago_taxi_trips')

BeispielGen Downstream-Komponenten

Für Downstream-Komponenten wird eine benutzerdefinierte Split-Konfiguration unterstützt.

StatistikGen

Das Standardverhalten besteht darin, die Statistikgenerierung für alle Splits durchzuführen.

Um exclude_splits auszuschließen, legen Sie die exclude_splits für die StatisticsGen-Komponente fest. Beispielsweise:

# Exclude the 'eval' split.
statistics_gen = StatisticsGen(
             examples=example_gen.outputs['examples'],
             exclude_splits=['eval'])

SchemaGen

Das Standardverhalten besteht darin, ein Schema basierend auf allen Splits zu generieren.

Um exclude_splits auszuschließen, legen Sie die exclude_splits für die SchemaGen-Komponente fest. Beispielsweise:

# Exclude the 'eval' split.
schema_gen = SchemaGen(
             statistics=statistics_gen.outputs['statistics'],
             exclude_splits=['eval'])

BeispielValidator

Das Standardverhalten besteht darin, die Statistiken aller Aufteilungen in Eingabebeispielen anhand eines Schemas zu validieren.

Um Splits auszuschließen, legen Sie die exclude_splits für die ExampleValidator-Komponente fest. Beispielsweise:

# Exclude the 'eval' split.
example_validator = ExampleValidator(
             statistics=statistics_gen.outputs['statistics'],
             schema=schema_gen.outputs['schema'],
             exclude_splits=['eval'])

Verwandeln

Das Standardverhalten ist Analysieren und Produzieren der Metadaten aus dem 'trainieren' Split und Transformieren aller Splits.

Um die splits_config und Transformationsaufteilungen anzugeben, legen Sie splits_config für die Transform-Komponente fest. Beispielsweise:

# Analyze the 'train' split and transform all splits.
transform = Transform(
      examples=example_gen.outputs['examples'],
      schema=schema_gen.outputs['schema'],
      module_file=_taxi_module_file,
      splits_config=proto.SplitsConfig(analyze=['train'],
                                               transform=['train', 'eval']))

Trainer und Tuner

Das Standardverhalten ist Trainieren im Split 'train' und Auswerten im Split 'eval'.

Um die Train-Splits anzugeben und Splits auszuwerten, setzen Sie train_args und eval_args für die Trainer-Komponente. Beispielsweise:

# Train on the 'train' split and evaluate on the 'eval' split.
Trainer = Trainer(
      module_file=_taxi_module_file,
      examples=transform.outputs['transformed_examples'],
      schema=schema_gen.outputs['schema'],
      transform_graph=transform.outputs['transform_graph'],
      train_args=proto.TrainArgs(splits=['train'], num_steps=10000),
      eval_args=proto.EvalArgs(splits=['eval'], num_steps=5000))

Bewerter

Das Standardverhalten ist die Bereitstellung von Metriken, die auf der 'eval'-Aufteilung berechnet werden.

Um eine Auswertungsstatistik für benutzerdefinierte example_splits zu berechnen, legen Sie example_splits für die Evaluator-Komponente fest. Beispielsweise:

# Compute metrics on the 'eval1' split and the 'eval2' split.
Trainer = Evaluator(
      examples=example_gen.outputs['examples'],
      model=trainer.outputs['model'],
      example_splits=['eval1', 'eval2'])

Weitere Details finden Sie in der CsvExampleGen-API-Referenz , der FileBasedExampleGen-API-Referenz und der ImportExampleGen-API-Referenz .