Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Komponent ExampleGen TFX Pipeline

Składnik ExampleGen TFX Pipeline pozyskuje dane do potoków TFX. Zużywa zewnętrzne pliki / usługi do generowania przykładów, które będą odczytywane przez inne składniki TFX. Zapewnia również spójną i konfigurowalną partycję oraz tasuje zestaw danych dla najlepszych praktyk ML.

  • Zużywa: dane z zewnętrznych źródeł danych, takich jak CSV, TFRecord , Avro, Parquet i BigQuery.
  • tf.Example : tf.Example records, tf.SequenceExample rekordy lub format proto, w zależności od formatu ładunku.

ExampleGen i inne składniki

ExampleGen dostarcza dane do komponentów korzystających z biblioteki TensorFlow Data Validation , takich jak SchemaGen , StatisticsGen i Example Validator . Dostarcza również dane do transformacji , która korzysta z biblioteki transformacji TensorFlow , a ostatecznie do celów wdrażania podczas wnioskowania.

Źródła i formaty danych

Obecnie standardowa instalacja TFX zawiera pełne komponenty ExampleGen dla tych źródeł danych i formatów:

Dostępne są również niestandardowe moduły wykonawcze, które umożliwiają tworzenie komponentów ExampleGen dla tych źródeł danych i formatów:

Zobacz przykłady użycia w kodzie źródłowym i tę dyskusję, aby uzyskać więcej informacji na temat używania i tworzenia niestandardowych wykonawców.

Ponadto te źródła danych i formaty są dostępne jako przykłady komponentów niestandardowych :

Pobieranie formatów danych, które są obsługiwane przez Apache Beam

Apache Beam obsługuje pozyskiwanie danych z szerokiego zakresu źródeł danych i formatów ( patrz poniżej ). Te możliwości mogą służyć do tworzenia niestandardowych składników ExampleGen dla TFX, co jest demonstrowane przez niektóre istniejące składniki ExampleGen ( patrz poniżej ).

Jak używać składnika ExampleGen

W przypadku obsługiwanych źródeł danych (obecnie pliki CSV, pliki TFRecord z tf.Example , tf.SequenceExample i proto oraz wyniki zapytań BigQuery) komponent ExampleGen pipeline może być używany bezpośrednio podczas wdrażania i wymaga niewielkiego dostosowania. Na przykład:

from tfx.utils.dsl_utils import csv_input
from tfx.components.example_gen.csv_example_gen.component import CsvExampleGen

examples = csv_input(os.path.join(base_dir, 'data/simple'))
example_gen = CsvExampleGen(input=examples)

lub jak poniżej do importowania zewnętrznego TFRecord z tf.Example bezpośrednio:

from tfx.components.example_gen.import_example_gen.component import ImportExampleGen

example_gen = ImportExampleGen(input_base=path_to_tfrecord_dir)

Rozpiętość, wersja i podział

Span to grupa przykładów szkoleń. Jeśli twoje dane są utrwalone w systemie plików, każdy Span może być przechowywany w oddzielnym katalogu. Semantyka Span nie jest zakodowana na stałe w TFX; Span może oznaczać dzień danych, godzinę danych lub dowolną inną grupę, która ma znaczenie dla Twojego zadania.

Każdy zakres może zawierać wiele wersji danych. Na przykład, jeśli usuniesz kilka przykładów z zakresu w celu oczyszczenia danych o niskiej jakości, może to spowodować powstanie nowej wersji tego zakresu. Domyślnie składniki TFX działają w najnowszej wersji w zakresie.

Każda wersja w ramach zakresu może być dalej podzielona na wiele podziałów. Najczęstszym przypadkiem użycia podziału Span jest podzielenie go na dane uczące i ewaluacyjne.

Rozpiętości i podziały

Niestandardowy podział wejścia / wyjścia

Aby dostosować stosunek podziału pociąg / ocena, który wyprowadzi ExampleGen, ustaw output_config dla składnika ExampleGen. Na przykład:

from  tfx.proto import example_gen_pb2

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

Zwróć uwagę, jak ustawiono hash_buckets w tym przykładzie.

W przypadku źródła wejściowego, które zostało już podzielone, ustaw input_config dla komponentu ExampleGen:

from  tfx.proto import example_gen_pb2

# 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 = example_gen_pb2.Input(splits=[
                example_gen_pb2.Input.Split(name='train', pattern='train/*'),
                example_gen_pb2.Input.Split(name='eval', pattern='eval/*')
            ])
examples = csv_input(input_dir)
example_gen = CsvExampleGen(input=examples, input_config=input)

Dla przykładu gen opartego na plikach (np. CsvExampleGen i ImportExampleGen) pattern jest globalnym pattern pliku, który odwzorowuje pliki wejściowe z katalogiem głównym określonym przez wejściową ścieżkę podstawową. W przypadku przykładowego generatora opartego na zapytaniach (np. BigQueryExampleGen, PrestoExampleGen) pattern to zapytanie SQL.

Domyślnie cały katalog wejściowy jest traktowany jako pojedynczy podział wejścia, a podział pociągu i wyjścia eval jest generowany ze stosunkiem 2: 1.

Zapoznaj się z protokołem proto / example_gen.proto, aby zapoznać się z konfiguracją podziału danych wejściowych i wyjściowych ExampleGen. I zapoznaj się z przewodnikiem po komponentach na dalszych etapach, aby wykorzystać niestandardowe podziały w dalszej części.

Metoda rozłupywania

Korzystając z metody dzielenia hash_buckets zamiast całego rekordu można skorzystać z funkcji partycjonowania przykładów. Jeśli funkcja jest obecna, ExampleGen użyje odcisku palca tej funkcji jako klucza partycji.

Ta funkcja może być użyta do utrzymania stabilnego podziału przy zachowaniu pewnych właściwości przykładów: na przykład użytkownik zawsze będzie umieszczony w tym samym podziale, jeśli jako nazwę funkcji partycji wybrano „user_id”.

Interpretacja tego, co oznacza „funkcja” i jak dopasować „funkcję” do określonej nazwy, zależy od implementacji ExampleGen i typu przykładów.

Dla gotowych wdrożeń ExampleGen:

  • Jeśli generuje tf.Example, wówczas „funkcja” oznacza wpis w tf.Example.features.feature.
  • Jeśli generuje tf.SequenceExample, to „funkcja” oznacza wpis w tf.SequenceExample.context.feature.
  • Obsługiwane są tylko funkcje typu int64 i bajty.

W następujących przypadkach ExampleGen generuje błędy czasu wykonania:

  • Podana nazwa funkcji nie istnieje w przykładzie.
  • Pusta funkcja: tf.train.Feature() .
  • Nieobsługiwane typy funkcji, np. Zmiennoprzecinkowe.

Aby wyprowadzić podział train / eval na podstawie funkcji w przykładach, ustaw output_config dla składnika ExampleGen. Na przykład:

from  tfx.proto import example_gen_pb2

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

Zwróć uwagę, jak partition_feature_name została ustawiona w tym przykładzie.

Zakres

Span można pobrać za pomocą specyfikacji „{SPAN}” we wzorcu wejściowym globu :

  • Ta specyfikacja dopasowuje cyfry i mapuje dane na odpowiednie numery SPAN. Na przykład „data_ {SPAN} - *. Tfrecord” będzie zbierać pliki takie jak „data_12-a.tfrecord”, „date_12-b.tfrecord”.
  • Opcjonalnie tę specyfikację można określić za pomocą szerokości liczb całkowitych podczas mapowania. Na przykład „data_ {SPAN: 2} .file” jest mapowane na pliki takie jak „data_02.file” i „data_27.file” (jako dane wejściowe odpowiednio dla Span-2 i Span-27), ale nie jest mapowane na „data_1”. plik „ani„ data_123.file ”.
  • Gdy brakuje specyfikacji SPAN, zakłada się, że zawsze jest to Span „0”.
  • Jeśli określono SPAN, potok przetworzy najnowszy zakres i zapisze numer zakresu w metadanych.

Na przykład załóżmy, że istnieją dane wejściowe:

  • „/ tmp / span-1 / train / data”
  • „/ tmp / span-1 / eval / data”
  • „/ tmp / span-2 / train / data”
  • „/ tmp / span-2 / eval / data”

a konfiguracja wejściowa jest pokazana poniżej:

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

podczas uruchamiania potoku będzie przetwarzał:

  • „/ tmp / span-2 / train / data” jako podział pociągu
  • „/ tmp / span-2 / eval / data” jako podział eval

z numerem przęsła równym „2”. Jeśli później '/ tmp / span-3 / ...' będzie gotowe, po prostu uruchom ponownie potok, a przejmie zakres '3' do przetwarzania. Poniżej przedstawiono przykład kodu używającego specyfikacji zakresu:

from  tfx.proto import example_gen_pb2

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

Pobieranie określonego zakresu można wykonać za pomocą RangeConfig, co opisano szczegółowo poniżej.

Data

Jeśli twoje źródło danych jest zorganizowane według dat w systemie plików, TFX obsługuje mapowanie dat bezpośrednio na numery zakresowe. Istnieją trzy specyfikacje przedstawiające odwzorowanie dat na zakresy: {RRRR}, {MM} i {DD}:

  • Wszystkie trzy specyfikacje powinny być w całości obecne we wzorcu wejściowym glob, jeśli jakikolwiek jest określony:
  • Można określić albo specyfikację {SPAN}, albo ten zestaw specyfikacji dat.
  • Obliczana jest data kalendarzowa z rokiem od RRRR, miesiącem od MM i dniem miesiąca od DD, a następnie numer zakresu jest obliczany jako liczba dni od epoki unixowej (tj. 1970-01-01). Na przykład „log- {RRRR} {MM} {DD} .data” pasuje do pliku „log-19700101.data” i wykorzystuje go jako dane wejściowe dla Span-0, a „log-20170101.data” jako dane wejściowe dla Span-17167.
  • Jeśli ten zestaw specyfikacji dat jest określony, potok przetworzy najpóźniejszą datę i zapisze odpowiedni numer zakresu w metadanych.

Na przykład załóżmy, że istnieją dane wejściowe uporządkowane według daty kalendarzowej:

  • „/ tmp / 1970-01-02 / train / data”
  • „/ tmp / 1970-01-02 / eval / data”
  • „/ tmp / 1970-01-03 / train / data”
  • „/ tmp / 1970-01-03 / eval / data”

a konfiguracja wejściowa jest pokazana poniżej:

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

podczas uruchamiania potoku będzie przetwarzał:

  • „/ tmp / 1970-01-03 / train / data” jako podział pociągu
  • „/ tmp / 1970-01-03 / eval / data” jako split eval

z numerem przęsła równym „2”. Jeśli później „/ tmp / 1970-01-04 / ...” będą gotowe, po prostu uruchom ponownie potok, a przejdzie on do przetwarzania w zakresie „3”. Poniżej przedstawiono przykładowy kod do korzystania ze specyfikacji daty:

from  tfx.proto import example_gen_pb2

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

Wersja

Wersję można pobrać, używając specyfikacji „{VERSION}” we wzorcu wejściowym globu :

  • Ta specyfikacja dopasowuje cyfry i mapuje dane do odpowiednich numerów WERSJI w ramach SPAN. Należy pamiętać, że specyfikację wersji można stosować w połączeniu ze specyfikacją zakresu lub daty.
  • Ta specyfikacja może być również opcjonalnie określona z szerokością w taki sam sposób, jak specyfikacja SPAN. np. „span- {SPAN} / version- {VERSION: 4} / data- *”.
  • W przypadku braku specyfikacji VERSION wersja jest ustawiona na Brak.
  • Jeśli określono SPAN i VERSION, potok przetworzy najnowszą wersję dla najnowszego zakresu i zapisze numer wersji w metadanych.
  • Jeśli określono VERSION, ale nie określono zakresu (lub daty), zostanie zgłoszony błąd.

Na przykład załóżmy, że istnieją dane wejściowe:

  • „/ 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”

a konfiguracja wejściowa jest pokazana poniżej:

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

podczas uruchamiania potoku będzie przetwarzał:

  • „/ tmp / span-2 / ver-2 / train / data” jako podział pociągu
  • „/ tmp / span-2 / ver-2 / eval / data” jako podział eval

z numerem przęsła równym „2” i numerem wersji „2”. Jeśli później pliki „/ tmp / span-2 / ver-3 / ...” będą gotowe, po prostu ponownie uruchom potok, a pobierze zakres „2” i wersję „3” do przetworzenia. Poniżej przedstawiono przykładowy kod do korzystania ze specyfikacji wersji:

from  tfx.proto import example_gen_pb2

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

Konfiguracja zakresu

TFX obsługuje pobieranie i przetwarzanie określonego zakresu w pliku ExampleGen przy użyciu konfiguracji zakresu, abstrakcyjnej konfiguracji używanej do opisywania zakresów dla różnych jednostek TFX. Aby pobrać określony zakres, ustaw parametr range_config dla opartego na plikach składnika ExampleGen. Na przykład załóżmy, że istnieją dane wejściowe:

  • „/ tmp / span-01 / train / data”
  • „/ tmp / span-01 / eval / data”
  • „/ tmp / span-02 / train / data”
  • „/ tmp / span-02 / eval / data”

Aby konkretnie pobrać i przetworzyć dane z zakresem „1”, oprócz konfiguracji wejściowej określamy konfigurację zakresu. Należy zauważyć, że ExampleGen obsługuje tylko jednopasmowe zakresy statyczne (w celu określenia przetwarzania określonych pojedynczych zakresów). Zatem dla StaticRange, start_span_number musi być równy end_span_number. Korzystając z podanego zakresu i informacji o szerokości rozpiętości (jeśli podano) dla wypełnienia zerami, ExampleGen zastąpi specyfikację SPAN w dostarczonych wzorcach podziału żądanym numerem zakresu. Przykład użycia pokazano poniżej:

from  tfx.proto import example_gen_pb2
from  tfx.proto import range_config_pb2

# 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 = example_gen_pb2.Input(splits=[
                example_gen_pb2.Input.Split(name='train',
                                            pattern='span-{SPAN:2}/train/*'),
                example_gen_pb2.Input.Split(name='eval',
                                            pattern='span-{SPAN:2}/eval/*')
            ])
# Specify the span number to be processed here using StaticRange.
range = range_config_pb2.RangeConfig(
                static_range=range_config_pb2.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.
examples = csv_input(input_dir)
example_gen = CsvExampleGen(input=examples, input_config=input,
                            range_config=range)

Konfiguracji zakresu można również używać do przetwarzania określonych dat, jeśli zamiast specyfikacji SPAN używana jest specyfikacja daty. Na przykład załóżmy, że istnieją dane wejściowe uporządkowane według daty kalendarzowej:

  • „/ tmp / 1970-01-02 / train / data”
  • „/ tmp / 1970-01-02 / eval / data”
  • „/ tmp / 1970-01-03 / train / data”
  • „/ tmp / 1970-01-03 / eval / data”

Aby konkretnie pobrać i przetworzyć dane 2 stycznia 1970 r., Wykonujemy następujące czynności:

from  tfx.components.example_gen import utils
from  tfx.proto import example_gen_pb2
from  tfx.proto import range_config_pb2

input = example_gen_pb2.Input(splits=[
                example_gen_pb2.Input.Split(name='train',
                                            pattern='{YYYY}-{MM}-{DD}/train/*'),
                example_gen_pb2.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 = range_config_pb2.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.
examples = csv_input(input_dir)
example_gen = CsvExampleGen(input=examples, input_config=input,
                            range_config=range)

Niestandardowy ExampleGen

Jeśli aktualnie dostępne komponenty ExampleGen nie odpowiadają twoim potrzebom, możesz utworzyć niestandardowy ExampleGen, który umożliwi ci odczyt z różnych źródeł danych lub w różnych formatach danych.

Przykład oparty na plikachGen

Najpierw rozszerz BaseExampleGenExecutor za pomocą niestandardowego Beam PTransform, który zapewnia konwersję z podziału danych wejściowych train / eval na przykłady TF. Na przykład moduł wykonawczy CsvExampleGen zapewnia konwersję z wejściowego podziału CSV na przykłady TF.

Następnie utwórz komponent z powyższym executorem, tak jak to zrobiono w komponencie CsvExampleGen . Alternatywnie, przekaż niestandardowy moduł wykonawczy do standardowego składnika ExampleGen, jak pokazano poniżej.

from tfx.components.base import executor_spec
from tfx.components.example_gen.component import FileBasedExampleGen
from tfx.components.example_gen.csv_example_gen import executor
from tfx.utils.dsl_utils import external_input

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

Teraz obsługujemy również odczytywanie plików Avro i Parquet przy użyciu tej metody .

Dodatkowe formaty danych

Apache Beam obsługuje odczyt wielu dodatkowych formatów danych . poprzez transformacje we / wy wiązki. Możesz tworzyć niestandardowe komponenty ExampleGen, wykorzystując transformacje We / Wy wiązki przy użyciu wzorca podobnego do przykładu Avro

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

W chwili pisania tego tekstu obsługiwane obecnie formaty i źródła danych dla Beam Python SDK obejmują:

  • Amazon S3
  • Apache Avro
  • Apache Hadoop
  • Apache Kafka
  • Parkiet Apache
  • Google Cloud BigQuery
  • Google Cloud BigTable
  • Google Cloud Datastore
  • Google Cloud Pub / Sub
  • Google Cloud Storage (GCS)
  • MongoDB

Najnowszą listę znajdziesz w dokumentacji Beam .

Oparte na zapytaniach ExampleGen

Najpierw rozszerz BaseExampleGenExecutor za pomocą niestandardowego Beam PTransform, który czyta z zewnętrznego źródła danych. Następnie utwórz prosty składnik, rozszerzając QueryBasedExampleGen.

Może to wymagać dodatkowych konfiguracji połączeń lub nie. Na przykład moduł wykonawczy BigQuery odczytuje przy użyciu domyślnego łącznika beam.io, który wyodrębnia szczegóły konfiguracji połączenia. Executor Presto wymaga niestandardowego Beam PTransform i niestandardowego protokołu konfiguracji połączenia jako danych wejściowych.

Jeśli konfiguracja połączenia jest wymagana dla niestandardowego komponentu ExampleGen, utwórz nowy protobuf i przekaż go przez custom_config, który jest teraz opcjonalnym parametrem wykonywania. Poniżej znajduje się przykład użycia skonfigurowanego komponentu.

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')

ExampleGen Downstream Components

Niestandardowa konfiguracja podziału jest obsługiwana w przypadku komponentów podrzędnych.

StatisticsGen

Domyślnym zachowaniem jest generowanie statystyk dla wszystkich podziałów.

Aby wykluczyć podziały, ustaw exclude_splits dla komponentu StatisticsGen. Na przykład:

from tfx import components

...

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

SchemaGen

Domyślnym zachowaniem jest generowanie schematu na podstawie wszystkich podziałów.

Aby wykluczyć podziały, ustaw exclude_splits dla składnika SchemaGen. Na przykład:

from tfx import components

...

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

ExampleValidator

Zachowanie domyślne polega na sprawdzaniu statystyk wszystkich podziałów na przykładach wejściowych względem schematu.

Aby wykluczyć podziały, ustaw exclude_splits dla składnika ExampleValidator. Na przykład:

from tfx import components

...

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

Przekształcać

Domyślne zachowanie polega na analizie i tworzeniu metadanych z podziału „pociągu” i przekształcaniu wszystkich podziałów.

Aby określić podziały analizy i podziały transformacji, ustaw splits_config dla składnika Transform. Na przykład:

from tfx import components
from  tfx.proto import transform_pb2

...

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

Trener i tuner

Domyślne zachowanie to pociąg na podziale „pociąg” i ocena na podziale „ewaluacja”.

Aby określić podziały pociągu i ocenić podziały, ustaw train_args i eval_args dla Trainer. Na przykład:

from tfx import components
from  tfx.proto import trainer_pb2

...

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

Ewaluator

Zachowanie domyślne polega na podaniu metryk obliczonych na podstawie podziału „eval”.

Aby obliczyć statystyki oceny dla podziałów niestandardowych, ustaw example_splits dla składnika Evaluator. Na przykład:

from tfx import components
from  tfx.proto import evaluator_pb2

...

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