Arquitectura de análisis del modelo Tensorflow

Visión general

La tubería de TensorFlow Model Analysis (TFMA) se representa de la siguiente manera:

Tubería TFMA

La canalización se compone de cuatro componentes principales:

  • Leer entradas
  • Extracción
  • Evaluación
  • Escribir resultados

Estos componentes utilizan dos tipos principales: tfma.Extracts y tfma.evaluators.Evaluation . El tipo tfma.Extracts representa los datos que se extraen durante el procesamiento de la canalización y pueden corresponder a uno o más ejemplos del modelo. tfma.evaluators.Evaluation representa el resultado de evaluar los extractos en varios puntos durante el proceso de extracción. Para proporcionar una API flexible, estos tipos son solo dictados donde las claves están definidas (reservadas para su uso) por diferentes implementaciones. Los tipos se definen de la siguiente manera:

# Extracts represent data extracted during pipeline processing.
# For example, the PredictExtractor stores the data for the
# features, labels, and predictions under the keys "features",
# "labels", and "predictions".
Extracts = Dict[Text, Any]

# Evaluation represents the output from evaluating extracts at
# particular point in the pipeline. The evaluation outputs are
# keyed by their associated output type. For example, the metric / plot
# dictionaries from evaluating metrics and plots will be stored under
# "metrics" and "plots" respectively.
Evaluation = Dict[Text, beam.pvalue.PCollection]

Tenga en cuenta que tfma.Extracts nunca se escriben directamente; siempre deben pasar por un evaluador para producir un tfma.evaluators.Evaluation que luego se escribe. También tenga en cuenta que tfma.Extracts son dictados que se almacenan en un beam.pvalue.PCollection (es decir, beam.PTransform s toma como entrada beam.pvalue.PCollection[tfma.Extracts] ) mientras que un tfma.evaluators.Evaluation es un dictado cuyos valores son beam.pvalue.PCollection s (es decir, beam.PTransform s toman el propio dict como argumento para la entrada beam.value.PCollection ). En otras palabras tfma.evaluators.Evaluation se usa en el momento de la construcción de la tubería, pero tfma.Extracts se usa en el tiempo de ejecución de la tubería.

Leer entradas

La etapa ReadInputs se compone de una transformación que toma entradas sin procesar (tf.train.Example, CSV, ...) y las convierte en extractos. Hoy en día, los extractos se representan como bytes de entrada sin procesar almacenados en tfma.INPUT_KEY ; sin embargo, los extractos pueden tener cualquier forma que sea compatible con la canalización de extracción, lo que significa que crea tfma.Extracts como salida, y que esos extractos son compatibles con aguas abajo. extractores Depende de los diferentes extractores documentar claramente lo que necesitan.

Extracción

El proceso de extracción es una lista de beam.PTransform s que se ejecutan en serie. Los extractores toman tfma.Extracts como entrada y devuelven tfma.Extracts como salida. El extractor prototípico es el tfma.extractors.PredictExtractor que usa el extracto de entrada producido por la transformación de entradas de lectura y lo ejecuta a través de un modelo para producir extractos de predicciones. Los extractores personalizados se pueden insertar en cualquier punto siempre que sus transformaciones se ajusten a la tfma.Extracts in y tfma.Extracts out. Un extractor se define de la siguiente manera:

# An Extractor is a PTransform that takes Extracts as input and returns
# Extracts as output. A typical example is a PredictExtractor that receives
# an 'input' placeholder for input and adds additional 'predictions' extracts.
Extractor = NamedTuple('Extractor', [
    ('stage_name', Text),
    ('ptransform', beam.PTransform)])  # Extracts -> Extracts

Extractor de entrada

El tfma.extractors.InputExtractor se usa para extraer características sin procesar, etiquetas sin procesar y pesos de ejemplo sin procesar de registros tf.train.Example para usar en cálculos y división de métricas. De forma predeterminada, los valores se almacenan en las claves de extracción features , labels y example_weights , respectivamente. Las etiquetas de modelo de salida única y los pesos de ejemplo se almacenan directamente como valores np.ndarray . Las etiquetas de modelo de salida múltiple y los pesos de ejemplo se almacenan como dictados de valores np.ndarray (codificados por nombre de salida). Si se realiza una evaluación de varios modelos, las etiquetas y los pesos de ejemplo se incrustarán aún más en otro dict (codificado por el nombre del modelo).

PredictExtractor

El tfma.extractors.PredictExtractor ejecuta predicciones del modelo y las almacena bajo las predictions clave en el tfma.Extracts . Las predicciones del modelo de salida única se almacenan directamente como los valores de salida previstos. Las predicciones del modelo de salida múltiple se almacenan como un dict de los valores de salida (codificados por nombre de salida). Si se realiza una evaluación de varios modelos, la predicción se integrará aún más dentro de otro dict (codificado por el nombre del modelo). El valor de salida real utilizado depende del modelo (por ejemplo, las salidas de retorno del estimador TF en forma de dictado, mientras que keras devuelve valores np.ndarray ).

SliceKeyExtractor

El tfma.extractors.SliceKeyExtractor utiliza la especificación de corte para determinar qué cortes se aplican a cada entrada de ejemplo en función de las características extraídas y agrega los valores de corte correspondientes a los extractos para su uso posterior por parte de los evaluadores.

Evaluación

La evaluación es el proceso de tomar un extracto y evaluarlo. Si bien es común realizar la evaluación al final de la tubería de extracción, hay casos de uso que requieren una evaluación antes en el proceso de extracción. Como tales, los evaluadores están asociados con los extractores contra cuya salida deben evaluarse. Un evaluador se define de la siguiente manera:

# An evaluator is a PTransform that takes Extracts as input and
# produces an Evaluation as output. A typical example of an evaluator
# is the MetricsAndPlotsEvaluator that takes the 'features', 'labels',
# and 'predictions' extracts from the PredictExtractor and evaluates
# them using post export metrics to produce metrics and plots dictionaries.
Evaluator = NamedTuple('Evaluator', [
  ('stage_name', Text),
  ('run_after', Text),              # Extractor.stage_name
  ('ptransform', beam.PTransform)]) # Extracts -> Evaluation

Observe que un evaluador es un beam.PTransform que toma tfma.Extracts como entradas. Nada impide que una implementación realice transformaciones adicionales en los extractos como parte del proceso de evaluación. A diferencia de los extractores que deben devolver un tfma.Extracts , no hay restricciones sobre los tipos de resultados que un evaluador puede generar, aunque la mayoría de los evaluadores también devuelven un dictado (por ejemplo, de nombres y valores de métricas).

Evaluador de métricas y parcelas

El tfma.evaluators.MetricsAndPlotsEvaluator toma features , labels y predictions como entrada, las ejecuta a través de tfma.slicer.FanoutSlices para agruparlas por sectores y luego realiza cálculos de métricas y gráficos. Produce resultados en forma de diccionarios de métricas y traza claves y valores (estos luego se convierten en prototipos serializados para su salida por tfma.writers.MetricsAndPlotsWriter ).

Escribir resultados

La etapa WriteResults es donde la salida de la evaluación se escribe en el disco. WriteResults utiliza escritores para escribir los datos en función de las claves de salida. Por ejemplo, un tfma.evaluators.Evaluation puede contener claves para metrics y plots . Luego, estos se asociarían con los diccionarios de métricas y gráficos llamados 'métricas' y 'gráficos'. Los escritores especifican cómo escribir cada archivo:

# A writer is a PTransform that takes evaluation output as input and
# serializes the associated PCollections of data to a sink.
Writer = NamedTuple('Writer', [
  ('stage_name', Text),
  ('ptransform', beam.PTransform)])    # Evaluation -> PDone

MetricsAndPlotsWriter

Proporcionamos un tfma.writers.MetricsAndPlotsWriter que convierte los diccionarios de métricas y diagramas en prototipos serializados y los escribe en el disco.

Si desea usar un formato de serialización diferente, puede crear un escritor personalizado y usarlo en su lugar. Dado que tfma.evaluators.Evaluation pasado a los escritores contiene la salida de todos los evaluadores combinados, se proporciona una transformación auxiliar tfma.writers.Write que los escritores pueden usar en sus implementaciones de ptransform para seleccionar los beam.PCollection apropiados basados ​​en un tecla de salida (ver a continuación un ejemplo).

personalización

El método tfma.run_model_analysis toma argumentos de extractors , evaluators y writers para personalizar los extractores, evaluadores y escritores utilizados por la canalización. Si no se proporcionan argumentos, se tfma.default_extractors , tfma.default_evaluators y tfma.default_writers de forma predeterminada.

Extractores personalizados

Para crear un extractor personalizado, cree un tipo tfma.extractors.Extractor que envuelva un beam.PTransform tomando tfma.Extracts como entrada y devolviendo tfma.Extracts como salida. Hay ejemplos de extractores disponibles en tfma.extractors .

Evaluadores personalizados

Para crear un evaluador personalizado, cree un tipo tfma.evaluators.Evaluator que envuelva un beam.PTransform tomando tfma.Extracts como entrada y devolviendo tfma.evaluators.Evaluation como salida. Un evaluador muy básico podría simplemente tomar los tfma.Extracts entrantes y generarlos para almacenarlos en una tabla. Esto es exactamente lo que hace tfma.evaluators.AnalysisTableEvaluator . Un evaluador más complicado podría realizar procesamiento adicional y agregación de datos. Consulte tfma.evaluators.MetricsAndPlotsEvaluator como ejemplo.

Tenga en cuenta que el propio tfma.evaluators.MetricsAndPlotsEvaluator se puede personalizar para admitir métricas personalizadas (consulte métricas para obtener más detalles).

Escritores personalizados

Para crear un escritor personalizado, cree un tipo tfma.writers.Writer que envuelva un beam.PTransform tomando tfma.evaluators.Evaluation como entrada y devolviendo beam.pvalue.PDone como salida. El siguiente es un ejemplo básico de un escritor para escribir TFRecords que contienen métricas:

tfma.writers.Writer(
  stage_name='WriteTFRecord(%s)' % tfma.METRICS_KEY,
  ptransform=tfma.writers.Write(
    key=tfma.METRICS_KEY,
    ptransform=beam.io.WriteToTFRecord(file_path_prefix=output_file))

Las entradas de un escritor dependen de la salida del evaluador asociado. Para el ejemplo anterior, la salida es un prototipo serializado producido por tfma.evaluators.MetricsAndPlotsEvaluator . Un escritor de tfma.evaluators.AnalysisTableEvaluator sería responsable de escribir un beam.pvalue.PCollection de tfma.Extracts .

Tenga en cuenta que un escritor está asociado con la salida de un evaluador a través de la clave de salida utilizada (por ejemplo, tfma.METRICS_KEY , tfma.ANALYSIS_KEY , etc.).

Ejemplo paso a paso

El siguiente es un ejemplo de los pasos involucrados en la canalización de extracción y evaluación cuando se utilizan tfma.evaluators.MetricsAndPlotsEvaluator y tfma.evaluators.AnalysisTableEvaluator :

run_model_analysis(
    ...
    extractors=[
        tfma.extractors.InputExtractor(...),
        tfma.extractors.PredictExtractor(...),
        tfma.extractors.SliceKeyExtrator(...)
    ],
    evaluators=[
        tfma.evaluators.MetricsAndPlotsEvaluator(...),
        tfma.evaluators.AnalysisTableEvaluator(...)
    ])

ReadInputs

# Out
Extracts {
  'input': bytes                 # CSV, Proto, ...
}

ExtractAndEvaluate

# In:  ReadInputs Extracts
# Out:
Extracts {
  'input': bytes                    # CSV, Proto, ...
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
}

# In:  InputExtractor Extracts
# Out:
Extracts {
  'input': bytes                    # CSV, Proto, ...
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
  'predictions': tensor_like        # Predictions
}

# In: PredictExtractor Extracts
# Out:
Extracts {
  'features': tensor_like           # Raw features
  'labels': tensor_like             # Labels
  'example_weights': tensor_like    # Example weights
  'predictions': tensor_like        # Predictions
  'slice_key': Tuple[bytes...]      # Slice
}

# In: SliceKeyExtractor Extracts
# Out:
Evaluation {
  'metrics': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from metric key to metric values)
  'plots': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from plot key to plot values)
}

# In: SliceKeyExtractor Extracts
# Out:
Evaluation {
  'analysis': PCollection[Extracts] # Final Extracts
}

WriteResults

# In:
Evaluation {
  'metrics': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from metric key to metric values)
  'plots': PCollection[Tuple[slicer.SliceKeyType, Dict[Text, Any]]]  # Tuples of (slice key, dictionary from plot key to plot values)
  'analysis': PCollection[Extracts] # Final Extracts
}
# Out: metrics, plots, and analysis files