Architettura di analisi del modello Tensorflow

Panoramica

La pipeline TensorFlow Model Analysis (TFMA) è illustrata come segue:

Gasdotto TFMA

La pipeline è composta da quattro componenti principali:

  • Leggi input
  • Estrazione
  • Valutazione
  • Scrivi risultati

Questi componenti utilizzano due tipi principali: tfma.Extracts e tfma.evaluators.Evaluation . Il tipo tfma.Extracts rappresenta i dati estratti durante l'elaborazione della pipeline e possono corrispondere a uno o più esempi per il modello. tfma.evaluators.Evaluation rappresenta l'output della valutazione degli estratti in vari punti durante il processo di estrazione. Per fornire un'API flessibile, questi tipi sono solo dicts in cui le chiavi sono definite (riservate per l'uso) da diverse implementazioni. Le tipologie sono così definite:

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

Si noti che tfma.Extracts non viene mai scritto direttamente, devono sempre passare attraverso un valutatore per produrre un tfma.evaluators.Evaluation che viene quindi scritto. Si noti inoltre che tfma.Extracts sono dicts che sono archiviati in un beam.pvalue.PCollection (cioè beam.PTransform s prendono come input beam.pvalue.PCollection[tfma.Extracts] ) mentre un tfma.evaluators.Evaluation è un dict i cui valori sono beam.pvalue.PCollection s (ovvero beam.PTransform s prendono il dict stesso come argomento per l'input beam.value.PCollection ). In altre parole tfma.evaluators.Evaluation viene utilizzato in fase di costruzione della pipeline, ma tfma.Extracts viene utilizzato in fase di esecuzione della pipeline.

Leggi input

La fase ReadInputs è costituita da una trasformazione che prende gli input grezzi (tf.train.Example, CSV, ...) e li converte in estratti. Oggi gli estratti sono rappresentati come byte di input non elaborati archiviati in tfma.INPUT_KEY , tuttavia gli estratti possono essere in qualsiasi forma compatibile con la pipeline di estrazione, il che significa che crea tfma.Extracts come output e che tali estratti sono compatibili con downstream estrattori. Spetta ai diversi estrattori documentare chiaramente ciò di cui hanno bisogno.

Estrazione

Il processo di estrazione è un elenco di beam.PTransform che vengono eseguiti in serie. Gli estrattori prendono tfma.Extracts come input e restituiscono tfma.Extracts come output. L'estrattore prototipo è tfma.extractors.PredictExtractor che utilizza l'estratto di input prodotto dalla trasformazione degli input di lettura e lo esegue attraverso un modello per produrre estratti di previsioni. Gli estrattori personalizzati possono essere inseriti in qualsiasi punto purché le loro trasformazioni siano conformi alle tfma.Extracts in e tfma.Extracts out. Un estrattore è definito come segue:

# 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

InputExtractor

tfma.extractors.InputExtractor viene utilizzato per estrarre funzioni non elaborate, etichette non elaborate e pesi di esempio non elaborati dai record tf.train.Example per l'utilizzo nelle sezioni e nei calcoli delle metriche. Per impostazione predefinita, i valori sono archiviati rispettivamente nelle features delle chiavi di estrazione, nelle labels e example_weights . Le etichette dei modelli a output singolo e i pesi di esempio vengono archiviati direttamente come valori np.ndarray . Le etichette dei modelli multi-output e i pesi di esempio vengono archiviati come dict di valori np.ndarray (indicati dal nome dell'output). Se viene eseguita la valutazione multimodello, le etichette e i pesi di esempio verranno ulteriormente incorporati all'interno di un altro dict (indicato dal nome del modello).

Predict Extractor

tfma.extractors.PredictExtractor esegue le previsioni del modello e le memorizza sotto le predictions chiave nel dict tfma.Extracts . Le previsioni del modello a output singolo vengono archiviate direttamente come valori di output previsti. Le previsioni del modello multi-output vengono archiviate come dict di valori di output (indicati dal nome dell'output). Se viene eseguita la valutazione multimodello, la previsione verrà ulteriormente incorporata all'interno di un altro dict (indicato dal nome del modello). Il valore di output effettivo utilizzato dipende dal modello (ad esempio, gli output di ritorno dello stimatore TF sotto forma di dict mentre keras restituisce valori np.ndarray ).

SliceKey Extractor

tfma.extractors.SliceKeyExtractor usa le specifiche di slicing per determinare quali slice si applicano a ciascun input di esempio in base alle funzionalità estratte e aggiunge i valori di slicing corrispondenti alle estrazioni per un uso successivo da parte dei valutatori.

Valutazione

La valutazione è il processo di prendere un estratto e valutarlo. Sebbene sia comune eseguire la valutazione alla fine della pipeline di estrazione, ci sono casi d'uso che richiedono una valutazione nelle prime fasi del processo di estrazione. In quanto tali valutatori sono associati agli estrattori di cui dovrebbero essere valutati l'output. Un valutatore è definito come segue:

# 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

Si noti che un valutatore è un beam.PTransform che accetta tfma.Extracts come input. Non c'è nulla che impedisca a un'implementazione di eseguire ulteriori trasformazioni sugli estratti come parte del processo di valutazione. A differenza degli estrattori che devono restituire un dict tfma.Extracts , non ci sono restrizioni sui tipi di output che un valutatore può produrre sebbene la maggior parte dei valutatori restituisca anche un dict (ad es. di nomi e valori di metrica).

MetricsAndPlotsEvaluator

Il tfma.evaluators.MetricsAndPlotsEvaluator prende le features , le labels e le predictions come input, le esegue attraverso tfma.slicer.FanoutSlices per raggrupparle per sezioni, quindi esegue le metriche e traccia i calcoli. Produce output sotto forma di dizionari di metriche e traccia chiavi e valori (questi vengono successivamente convertiti in prototipi serializzati per l'output da tfma.writers.MetricsAndPlotsWriter ).

Scrivi risultati

La fase WriteResults è dove l'output di valutazione viene scritto su disco. WriteResults utilizza i writer per scrivere i dati in base alle chiavi di output. Ad esempio, un tfma.evaluators.Evaluation può contenere chiavi per metrics e plots . Questi sarebbero quindi associati ai dizionari di metriche e grafici chiamati "metriche" e "trame". Gli autori specificano come scrivere ogni file:

# 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

Scrittore di metriche e trame

Forniamo un tfma.writers.MetricsAndPlotsWriter che converte le metriche e traccia i dizionari in prototipi serializzati e li scrive su disco.

Se desideri utilizzare un formato di serializzazione diverso, puoi creare uno scrittore personalizzato e utilizzarlo al suo posto. Poiché tfma.evaluators.Evaluation passato ai writer contiene l'output per tutti i valutatori combinati, viene fornita una trasformazione tfma.writers.Write che i writer possono utilizzare nelle loro implementazioni ptransform per selezionare il beam.PCollection appropriato basato su un chiave di uscita (vedi sotto per un esempio).

Personalizzazione

Il metodo tfma.run_model_analysis accetta gli argomenti extractors , evaluators e writers per personalizzare gli estrattori, i valutatori e i writer utilizzati dalla pipeline. Se non vengono forniti argomenti, per impostazione predefinita vengono utilizzati tfma.default_extractors , tfma.default_evaluators e tfma.default_writers .

Estrattori personalizzati

Per creare un estrattore personalizzato, crea un tipo tfma.extractors.Extractor che esegue il wrapping di una beam.PTransform prendendo tfma.Extracts come input e restituendo tfma.Extracts come output. Esempi di estrattori sono disponibili in tfma.extractors .

Valutatori personalizzati

Per creare un valutatore personalizzato, crea un tipo tfma.evaluators.Evaluator che esegue il wrapping di un beam.PTransform prendendo tfma.Extracts come input e restituendo tfma.evaluators.Evaluation come output. Un valutatore molto semplice potrebbe semplicemente prendere i tfma.Extracts in arrivo e riprodurli per archiviarli in una tabella. Questo è esattamente ciò che fa tfma.evaluators.AnalysisTableEvaluator . Un valutatore più complicato potrebbe eseguire ulteriori elaborazioni e aggregazioni di dati. Vedere tfma.evaluators.MetricsAndPlotsEvaluator come esempio.

Tieni presente che tfma.evaluators.MetricsAndPlotsEvaluator stesso può essere personalizzato per supportare metriche personalizzate (consulta le metriche per maggiori dettagli).

Scrittori personalizzati

Per creare un writer personalizzato, creare un tipo tfma.writers.Writer che esegue il wrapping di un beam.PTransform prendendo tfma.evaluators.Evaluation come input e restituendo beam.pvalue.PDone come output. Quello che segue è un esempio di base di uno scrittore per scrivere TFRecords contenenti metriche:

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

Gli input di uno scrittore dipendono dall'output del valutatore associato. Per l'esempio precedente, l'output è un prototipo serializzato prodotto da tfma.evaluators.MetricsAndPlotsEvaluator . Uno scrittore per tfma.evaluators.AnalysisTableEvaluator sarebbe responsabile della scrittura di una beam.pvalue.PCollection di tfma.Extracts .

Si noti che uno scrittore è associato all'output di un valutatore tramite la chiave di output utilizzata (ad esempio tfma.METRICS_KEY , tfma.ANALYSIS_KEY , ecc.).

Esempio passo dopo passo

Di seguito è riportato un esempio dei passaggi coinvolti nella pipeline di estrazione e valutazione quando vengono utilizzati sia tfma.evaluators.MetricsAndPlotsEvaluator che 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