Join TensorFlow at Google I/O, May 11-12 Register now

Arquitetura de análise de modelo do Tensorflow

Visão geral

O pipeline TensorFlow Model Analysis (TFMA) é descrito da seguinte maneira:

Pipeline TFMA

O pipeline é composto por quatro componentes principais:

  • Ler entradas
  • Extração
  • Avaliação
  • Escreva os resultados

Esses componentes fazem uso de dois tipos principais: tfma.Extracts e tfma.evaluators.Evaluation . O tipo tfma.Extracts representa dados que são extraídos durante processamento de tubagem enquanto que o tipo tfma.evaluators.Evaluation representa a saída de avaliar os extractos em vários pontos durante o processo de extracção. Para fornecer uma API flexível, esses tipos são apenas ditos onde as chaves são definidas (reservadas para uso) por diferentes implementações. Os tipos são definidos da seguinte forma:

# 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]

Note-se que tfma.Extracts nunca são escritos diretamente devem sempre passar por um avaliador para produzir um tfma.evaluators.Evaluation que é então escrito. Além disso, note que tfma.Extracts são dicts que são armazenados em uma beam.pvalue.PCollection (isto é beam.PTransform tomada s como entrada beam.pvalue.PCollection[tfma.Extracts] ), enquanto que um tfma.evaluators.Evaluation é um dicionário cujos valores são beam.pvalue.PCollection s (isto é, beam.PTransform s tomar a própria Dict como o argumento para o beam.value.PCollection entrada). Em outras palavras, o tfma.evaluators.Evaluation é usado em tempo de construção do gasoduto, mas os tfma.Extracts são usados em tempo de execução pipeline.

Ler entradas

O ReadInputs fase é composta de uma transformação que leva matérias-primas (tf.train.Example, CSV, ...) e os converte em extratos. Hoje, os extractos são representados como entrada em bruto bytes armazenados sob tfma.INPUT_KEY , no entanto, os extractos podem ser de qualquer forma que seja compatível com a extracção oleoduto - o que significa que ele cria tfma.Extracts como de saída, e que estes extractos são compatíveis com a jusante extratores. Cabe aos diferentes extratores documentar claramente o que precisam.

Extração

O processo de extracção é uma lista de beam.PTransform s que são executados em série. Os extratores tomar tfma.Extracts como entrada e retorno tfma.Extracts como saída. O extractor de proto-típico é o tfma.extractors.PredictExtractor que usa o extracto de entrada produzido por as entradas de leitura transformar e executa-lo através de um modelo para produzir previsões extractos. Extratores personalizado pode ser inserido em qualquer ponto desde suas transformadas em conformidade com as tfma.Extracts em e tfma.Extracts fora API. Um extrator é definido da seguinte forma:

# 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

Note-se que fora dos casos muito especiais, é quase sempre o caso que um tfma.Extracts em um beam.pvalue.PCollection corresponderá a um exemplo do modelo.

InputExtractor

O tfma.extractors.InputExtractor é utilizado para extrair características matérias-primas, etiquetas, e os exemplos em bruto de pesos tf.train.Example registos para utilização nas métricas de corte e de cálculos. Por padrão, os valores são armazenados sob as teclas de extrair features , labels , e example_weights respectivamente. Etiquetas do modelo de saída única e exemplos de pesos são armazenados directamente como np.ndarray valores. Multi-saída etiquetas modelo e exemplos de pesos são armazenados como dicts de np.ndarray valores introduzidos (por nome de saída). Se a avaliação de vários modelos for realizada, os rótulos e pesos de exemplo serão posteriormente incorporados em outro dicionário (digitados pelo nome do modelo).

PredictExtractor

O tfma.extractors.PredictExtractor corre previsões do modelo e os armazena na chave de predictions no tfma.Extracts dict. As previsões do modelo de saída única são armazenadas diretamente como os valores de saída previstos. As previsões do modelo de múltiplas saídas são armazenadas como um dicionário de valores de saída (codificados por nome de saída). Se a avaliação de vários modelos for realizada, a previsão será incorporada posteriormente em outro dicionário (codificado pelo nome do modelo). A saída de valor real usada depende do modelo (por exemplo, TF saídas de retorno do estimador sob a forma de um dicionário Considerando Keras retornos np.ndarray valores).

SliceKeyExtractor

O tfma.extractors.SliceKeyExtractor utiliza a especificação de corte para determinar quais as fatias de aplicar-se a cada entrada de exemplo, com base nas características extraídas e adiciona os valores de corte coresponding para os extractos para uso posterior pelos avaliadores.

Avaliação

Avaliação é o processo de pegar um extrato e avaliá-lo. Embora seja comum realizar a avaliação no final do pipeline de extração, há casos de uso que requerem avaliação no início do processo de extração. Como tais avaliadores estão associados aos extratores cuja saída eles devem ser avaliados. Um avaliador é definido da seguinte forma:

# 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 um avaliador é um beam.PTransform que leva tfma.Extracts como entradas. Não há nada que impeça uma implementação de realizar transformações adicionais nas extrações como parte do processo de avaliação. Ao contrário de extratores que deve retornar um tfma.Extracts dict, não há restrições sobre os tipos de saídas de um avaliador pode produzir embora a maioria dos avaliadores também retornar um dicionário (por exemplo, de nomes de métricas e valores).

MetricsAndPlotsEvaluator

O tfma.evaluators.MetricsAndPlotsEvaluator leva features , labels , e predictions como entrada, executa-los através tfma.slicer.FanoutSlices agrupá-los por fatias, e em seguida, executa métricas e gráficos de cálculos. Ela produz saídas em forma de dicionários de métricas e teclas de terrenos e valores (estes são mais tarde convertidos em Protos serializados para a saída por tfma.writers.MetricsAndPlotsWriter ).

Escreva os resultados

O WriteResults estágio é onde a saída de avaliação é escrita para o disco. WriteResults usa gravadores para gravar os dados com base nas chaves de saída. Por exemplo, um tfma.evaluators.Evaluation pode conter chaves para metrics e plots . Estes seriam então associados aos dicionários de métricas e gráficos chamados 'métricas' e 'gráficos'. Os escritores especificam como escrever cada arquivo:

# 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

Nós fornecemos uma tfma.writers.MetricsAndPlotsWriter que converte as métricas e gráficos de dicionários para protos serializados e escreve-los no disco.

Se desejar usar um formato de serialização diferente, você pode criar um gravador personalizado e usá-lo em seu lugar. Desde o tfma.evaluators.Evaluation passado para os escritores contém a saída para todos os avaliadores combinadas, uma tfma.writers.Write helper transformar é fornecido que os escritores podem usar em suas ptransform implementações para selecionar o apropriado beam.PCollection s com base em uma chave de saída (veja abaixo um exemplo).

Costumização

O tfma.run_model_analysis método leva extractors , evaluators e writers argumentos para customing Os extratores, avaliadores e escritores usados pelo pipeline. Se nenhum argumento for fornecido então tfma.default_extractors , tfma.default_evaluators e tfma.default_writers são usados por padrão.

Extratores personalizados

Para criar um extrator de costume, criar um tfma.extractors.Extractor tipo que envolve uma beam.PTransform tomar tfma.Extracts como entrada e retornar tfma.Extracts como saída. Exemplos de extractores estão disponíveis sob tfma.extractors .

Avaliadores personalizados

Para criar um avaliador de costume, criar um tfma.evaluators.Evaluator tipo que envolve uma beam.PTransform tomar tfma.Extracts como entrada e retornar tfma.evaluators.Evaluation como saída. Um avaliador muito básico pode apenas tomar as recebidas tfma.Extracts e enviá-las para armazenar em uma tabela. Este é exatamente o que o tfma.evaluators.AnalysisTableEvaluator faz. Um avaliador mais complicado pode executar processamento adicional e agregação de dados. Ver o tfma.evaluators.MetricsAndPlotsEvaluator como um exemplo ..

Note que o tfma.evaluators.MetricsAndPlotsEvaluator em si pode ser personalizado para métricas personalizadas de apoio (ver métricas para mais detalhes).

Escritores Personalizados

Para criar um escritor personalizado, criar um tfma.writers.Writer tipo que envolve uma beam.PTransform tomada tfma.evaluators.Evaluation como entrada e retornar beam.pvalue.PDone como saída. A seguir está um exemplo básico de um escritor para escrever TFRecords contendo 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))

As entradas de um escritor dependem da saída do avaliador associado. Para o exemplo acima, o resultado é um proto serializados produzido pelo tfma.evaluators.MetricsAndPlotsEvaluator . Um escritor para o tfma.evaluators.AnalysisTableEvaluator seria responsável por escrever um beam.pvalue.PCollection de tfma.Extracts .

Note-se que um escritor está associado com a saída de um avaliador através da tecla de saída utilizado (por exemplo, tfma.METRICS_KEY , tfma.ANALYSIS_KEY , etc).

Exemplo passo a passo

O seguinte é um exemplo dos passos envolvidos na conduta de extracção e de avaliação quando tanto o tfma.evaluators.MetricsAndPlotsEvaluator e tfma.evaluators.AnalysisTableEvaluator são utilizados:

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