Se usó la API de Cloud Translation para traducir esta página.
Switch to English

El componente de canalización ExampleGen TFX

El componente ExampleGen TFX Pipeline ingiere datos en las tuberías TFX. Consume archivos / servicios externos para generar ejemplos que serán leídos por otros componentes TFX. También proporciona una partición coherente y configurable, y baraja el conjunto de datos para las mejores prácticas de AA.

  • Consume: datos de fuentes de datos externas como CSV, TFRecord , Avro, Parquet y BigQuery
  • Emite: tf.Example records, tf.SequenceExample records, o formato proto, depende del formato de carga útil.

ExampleGen y otros componentes

ExampleGen proporciona datos a los componentes que utilizan la biblioteca de validación de datos de TensorFlow , como SchemaGen , StatisticsGen y Example Validator . También proporciona datos a Transform , que hace uso de la biblioteca TensorFlow Transform y, en última instancia, a los objetivos de implementación durante la inferencia.

Cómo utilizar un componente ExampleGen

Para las fuentes de datos compatibles (actualmente, archivos CSV, archivos TFRecord con formato tf.Example , tf.SequenceExample y proto, y resultados de consultas de BigQuery), el componente de canalización de ExampleGen se puede usar directamente en la implementación y requiere poca personalización. Por ejemplo:

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)

o como a continuación para importar TFRecord externo con tf.Example directamente:

from tfx.utils.dsl_utils import tfrecord_input
from tfx.components.example_gen.import_example_gen.component import ImportExampleGen

examples = tfrecord_input(path_to_tfrecord_dir)
example_gen = ImportExampleGen(input=examples)

Span, versión y división

Un Span es una agrupación de ejemplos de formación. Si sus datos se conservan en un sistema de archivos, cada tramo puede almacenarse en un directorio separado. La semántica de un Span no está codificada en TFX; un intervalo puede corresponder a un día de datos, una hora de datos o cualquier otro grupo que sea significativo para su tarea.

Cada tramo puede contener múltiples versiones de datos. Para dar un ejemplo, si elimina algunos ejemplos de un Span para limpiar datos de baja calidad, esto podría resultar en una nueva Versión de ese Span. De forma predeterminada, los componentes TFX funcionan en la última versión dentro de un intervalo.

Cada versión dentro de un intervalo se puede subdividir en múltiples divisiones. El caso de uso más común para dividir un Span es dividirlo en datos de entrenamiento y de evaluación.

Tramos y divisiones

División de entrada / salida personalizada

Para personalizar la relación de división de tren / evaluación que generará ExampleGen, configure output_config para el componente ExampleGen. Por ejemplo:

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)

Observe cómo se configuraron los hash_buckets en este ejemplo.

Para una fuente de entrada que ya se ha dividido, configure input_config para el componente 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)

Para el gen de ejemplo basado en archivos (por ejemplo, CsvExampleGen e ImportExampleGen), el pattern es un patrón de archivo relativo global que se asigna a los archivos de entrada con el directorio raíz proporcionado por la ruta base de entrada. Para la generación de ejemplos basada en consultas (p. Ej., BigQueryExampleGen, PrestoExampleGen), el pattern es una consulta SQL.

De forma predeterminada, todo el directorio base de entrada se trata como una sola división de entrada, y la división de salida de entrenamiento y evaluación se genera con una proporción de 2: 1.

Consulte proto / example_gen.proto para obtener más detalles.

Método de división

Cuando se usa el método de división hash_buckets , en lugar de todo el registro, se puede usar una función para dividir los ejemplos. Si una función está presente, ExampleGen utilizará una huella digital de esa función como clave de partición.

Esta función se puede utilizar para mantener una división estable con ciertas propiedades de los ejemplos: por ejemplo, un usuario siempre se colocará en la misma división si se seleccionó "user_id" como el nombre de la función de partición.

La interpretación de lo que significa una "característica" y cómo hacer coincidir una "característica" con el nombre especificado depende de la implementación de ExampleGen y del tipo de ejemplos.

Para implementaciones de ExampleGen listas para usar:

  • Si genera tf.Example, entonces una "característica" significa una entrada en tf.Example.features.feature.
  • Si genera tf.SequenceExample, entonces una "característica" significa una entrada en tf.SequenceExample.context.feature.
  • Solo se admiten las funciones int64 y bytes.

En los siguientes casos, ExampleGen arroja errores de tiempo de ejecución:

  • El nombre de la característica especificada no existe en el ejemplo.
  • Característica vacía: tf.train.Feature() .
  • Tipos de características no admitidas, por ejemplo, características flotantes.

Para generar la división train / eval según una característica de los ejemplos, establezca output_config para el componente ExampleGen. Por ejemplo:

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)

Observe cómo se configuró el nombre de función de la partition_feature_name en este ejemplo.

Lapso

El intervalo se puede recuperar utilizando la especificación '{SPAN}' en el patrón global de entrada :

  • Esta especificación coincide con los dígitos y asigna los datos a los números SPAN relevantes. Por ejemplo, 'data_ {SPAN} - *. Tfrecord' recopilará archivos como 'data_12-a.tfrecord', 'date_12-b.tfrecord'.
  • Cuando falta la especificación SPAN, se supone que siempre es Span '0'.
  • Si se especifica SPAN, la canalización procesará el último tramo y almacenará el número de tramo en metadatos.

Por ejemplo, supongamos que hay datos de entrada:

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

y la configuración de entrada se muestra a continuación:

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

al activar la canalización, procesará:

  • '/ tmp / span-02 / train / data' como división de tren
  • '/ tmp / span-02 / eval / data' como eval split

con el número de intervalo como '02'. Si más adelante '/ tmp / span-03 / ...' están listos, simplemente active la tubería nuevamente y tomará el span '03' para su procesamiento. A continuación se muestra el ejemplo de código para usar la especificación de intervalo:

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)

Versión

ExampleGen personalizado

Si los componentes de ExampleGen disponibles actualmente no se ajustan a sus necesidades, cree un ExampleGen personalizado, que incluirá un nuevo ejecutor extendido desde BaseExampleGenExecutor.

ExampleGen basado en archivos

Primero, amplíe BaseExampleGenExecutor con un Beam PTransform personalizado, que proporciona la conversión de su división de entrada train / eval a ejemplos TF. Por ejemplo, el ejecutor CsvExampleGen proporciona la conversión de una división CSV de entrada a ejemplos TF.

Luego, cree un componente con el ejecutor anterior, como se hizo en el componente CsvExampleGen . Alternativamente, pase un ejecutor personalizado al componente ExampleGen estándar como se muestra a continuación.

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

Ahora, también admitimos la lectura de archivos Avro y Parquet con este método .

ExampleGen basado en consultas

Primero, amplíe BaseExampleGenExecutor con un Beam PTransform personalizado, que lee desde la fuente de datos externa. Luego, cree un componente simple extendiendo QueryBasedExampleGen.

Esto puede requerir o no configuraciones de conexión adicionales. Por ejemplo, el ejecutor de BigQuery lee con un conector beam.io predeterminado, que abstrae los detalles de configuración de la conexión. El ejecutor de Presto , requiere un Beam PTransform personalizado y un protobuf de configuración de conexión personalizado como entrada.

Si se requiere una configuración de conexión para un componente ExampleGen personalizado, cree un nuevo protobuf y páselo a través de custom_config, que ahora es un parámetro de ejecución opcional. A continuación, se muestra un ejemplo de cómo utilizar un componente configurado.

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

Componentes downstream de ExampleGen

La configuración dividida personalizada es compatible con los componentes posteriores.

EstadísticaGen

El comportamiento predeterminado es realizar la generación de estadísticas para todas las divisiones.

Para excluir divisiones, configure exclude_splits para el componente StatisticsGen. Por ejemplo:

from tfx import components

...

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

SchemaGen

El comportamiento predeterminado es generar un esquema basado en todas las divisiones.

Para excluir cualquier división, establezca exclude_splits para el componente SchemaGen. Por ejemplo:

from tfx import components

...

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

ExampleValidator

El comportamiento predeterminado es validar las estadísticas de todas las divisiones en los ejemplos de entrada con un esquema.

Para excluir cualquier división, establezca exclude_splits para el componente ExampleValidator. Por ejemplo:

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

Transformar

El comportamiento predeterminado es analizar y producir los metadatos de la división 'tren' y transformar todas las divisiones.

Para especificar las divisiones de análisis y las divisiones de transformación, configure splits_config para el componente Transformar. Por ejemplo:

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

Entrenador y sintonizador

El comportamiento predeterminado es entrenar en la división 'train' y evaluar en la división 'eval'.

Para especificar las divisiones del tren y evaluar las divisiones, configure train_args y eval_args para el componente Trainer. Por ejemplo:

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

Evaluador

El comportamiento predeterminado es proporcionar métricas calculadas en la división 'eval'.

Para calcular una estadística de evaluación sobre divisiones personalizadas, configure example_splits para el componente Evaluator. Por ejemplo:

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