Arquitetura de análise de modelo Tensorflow

Visão geral

O pipeline do TensorFlow Model Analysis (TFMA) é representado da seguinte forma:

O pipeline é composto por quatro componentes principais:

• Ler entradas
• Extração
• Avaliação
• Gravar resultados

Esses componentes fazem uso de dois tipos principais: tfma.Extracts e tfma.evaluators.Evaluation . O tipo tfma.Extracts representa os dados que são extraídos durante o processamento do pipeline e podem corresponder a um ou mais exemplos para o modelo. tfma.evaluators.Evaluation representa a saída da avaliação dos extratos em vários pontos durante o processo de extração. Para fornecer uma API flexível, esses tipos são apenas ditados 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 que tfma.Extracts nunca são escritos diretamente, eles sempre devem passar por um avaliador para produzir um tfma.evaluators.Evaluation que é então escrito. Observe também que tfma.Extracts são dicts armazenados em um beam.pvalue.PCollection (ou seja, beam.PTransform s recebem como entrada beam.pvalue.PCollection[tfma.Extracts] ), enquanto um tfma.evaluators.Evaluation é um dict cujos valores são beam.pvalue.PCollection s (ou seja, beam.PTransform s tomam o próprio dict como argumento para a entrada beam.value.PCollection ). Em outras palavras, o tfma.evaluators.Evaluation é usado no tempo de construção do pipeline, mas o tfma.Extracts é usado no tempo de execução do pipeline.

Ler entradas

O estágio ReadInputs é composto por uma transformação que recebe entradas brutas (tf.train.Example, CSV, ...) e as converte em extrações. Hoje as extrações são representadas como bytes de entrada brutos armazenados em tfma.INPUT_KEY , no entanto, as extrações podem estar em qualquer formato compatível com o pipeline de extração -- o que significa que ele cria tfma.Extracts como saída e que essas extrações são compatíveis com downstream extratores. Cabe aos diferentes extratores documentar claramente o que eles exigem.

Extração

O processo de extração é uma lista de beam.PTransform s que são executadas em série. Os extratores recebem tfma.Extracts como entrada e retornam tfma.Extracts como saída. O extrator prototípico é o tfma.extractors.PredictExtractor que usa o extrato de entrada produzido pela transformação de entradas de leitura e o executa por meio de um modelo para produzir extratos de previsões. Extratores personalizados podem ser inseridos em qualquer ponto, desde que suas transformações estejam em conformidade com a tfma.Extracts in e tfma.Extracts out. 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

Extrator de entrada

O tfma.extractors.InputExtractor é usado para extrair recursos brutos, rótulos brutos e pesos brutos de exemplo dos registros tf.train.Example para uso em fatias e cálculos de métricas. Por padrão, os valores são armazenados nas chaves de extração features , labels e example_weights respectivamente. Rótulos de modelo de saída única e pesos de exemplo são armazenados diretamente como valores np.ndarray . Rótulos de modelo de várias saídas e pesos de exemplo são armazenados como dicts de valores np.ndarray (codificados por nome de saída). Se a avaliação de vários modelos for realizada, os rótulos e os pesos de exemplo serão incorporados em outro dict (codificado pelo nome do modelo).

Extrator de previsão

O tfma.extractors.PredictExtractor executa previsões de modelo e as armazena sob as principais predictions no dict tfma.Extracts . 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 várias saídas são armazenadas como um dict de valores de saída (codificados pelo nome da saída). Se a avaliação de vários modelos for realizada, a previsão será incorporada em outro dict (codificado pelo nome do modelo). O valor de saída real usado depende do modelo (por exemplo, as saídas de retorno do estimador TF na forma de um dict enquanto keras retorna valores np.ndarray ).

SliceKeyExtractor

O tfma.extractors.SliceKeyExtractor usa a especificação de fatiamento para determinar quais fatias se aplicam a cada entrada de exemplo com base nos recursos extraídos e adiciona os valores de fatia correspondentes às extrações para uso posterior pelos avaliadores.

Avaliação

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

Avaliador de Métricas e Parcelas

O tfma.evaluators.MetricsAndPlotsEvaluator recebe features , labels e predictions como entrada, executa-os por meio de tfma.slicer.FanoutSlices para agrupá-los por fatias e, em seguida, executa cálculos de métricas e gráficos. Ele produz saídas na forma de dicionários de métricas e plota chaves e valores (estes são posteriormente convertidos em protos serializados para saída por tfma.writers.MetricsAndPlotsWriter ).

Gravar resultados

O estágio WriteResults é onde a saída de avaliação é gravada no disco. WriteResults usa escritores 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 'plotagens'. 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

Escritor de Métricas e Parcelas

Fornecemos um tfma.writers.MetricsAndPlotsWriter que converte os dicionários de métricas e gráficos em protos serializados e os grava em disco.

Se você deseja usar um formato de serialização diferente, pode criar um gravador personalizado e usá-lo. Como o tfma.evaluators.Evaluation passado para os escritores contém a saída para todos os avaliadores combinados, uma transformação auxiliar tfma.writers.Write é fornecida que os escritores podem usar em suas implementações de ptransform para selecionar os beam.PCollection s apropriados com base em um chave de saída (veja abaixo um exemplo).

Costumização

O método tfma.run_model_analysis usa argumentos de extractors , evaluators e writers para personalizar os extratores, avaliadores e gravadores usados ​​pelo pipeline. Se nenhum argumento for fornecido, tfma.default_extractors , tfma.default_evaluators e tfma.default_writers serão usados ​​por padrão.

Extratores personalizados

Para criar um extrator personalizado, crie um tipo tfma.extractors.Extractor que envolva um beam.PTransform recebendo tfma.Extracts como entrada e retornando tfma.Extracts como saída. Exemplos de extratores estão disponíveis em tfma.extractors .

Avaliadores personalizados

Para criar um avaliador personalizado, crie um tipo tfma.evaluators.Evaluator que envolva um beam.PTransform recebendo tfma.Extracts como entrada e retornando tfma.evaluators.Evaluation como saída. Um avaliador muito básico pode simplesmente pegar os tfma.Extracts de entrada e produzi-los para armazenar em uma tabela. Isso é exatamente o que o tfma.evaluators.AnalysisTableEvaluator faz. Um avaliador mais complicado pode realizar processamento adicional e agregação de dados. Veja o tfma.evaluators.MetricsAndPlotsEvaluator como exemplo.

Observe que o próprio tfma.evaluators.MetricsAndPlotsEvaluator pode ser personalizado para oferecer suporte a métricas personalizadas (consulte as métricas para obter mais detalhes).

Gravadores personalizados

Para criar um gravador personalizado, crie um tipo tfma.writers.Writer que envolva um beam.PTransform usando tfma.evaluators.Evaluation como entrada e retornando beam.pvalue.PDone como saída. O seguinte é 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, a saída é um proto serializado produzido pelo tfma.evaluators.MetricsAndPlotsEvaluator . Um escritor para o tfma.evaluators.AnalysisTableEvaluator seria responsável por escrever um beam.pvalue.PCollection de tfma.Extracts .

Observe que um gravador está associado à saída de um avaliador por meio da chave de saída usada (por exemplo, tfma.METRICS_KEY , tfma.ANALYSIS_KEY , etc).

Exemplo passo a passo

Veja a seguir um exemplo das etapas envolvidas no pipeline de extração e avaliação quando tfma.evaluators.MetricsAndPlotsEvaluator e tfma.evaluators.AnalysisTableEvaluator são usados:

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

• tfma.extractors.InputExtractor

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

• tfma.extractors.PredictExtractor

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

• tfma.extractors.SliceKeyExtractor

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

• tfma.evaluators.MetricsAndPlotsEvaluator (run_after: SLICE_KEY_EXTRACTOR_STAGE_NAME )

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

• tfma.evaluators.AnalysisTableEvaluator (run_after: LAST_EXTRACTOR_STAGE_NAME )

# 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