Unisciti alla comunità SIG TFX-Addons e contribuisci a rendere TFX ancora migliore!

Architettura di analisi del modello Tensorflow

Panoramica

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

Pipeline TFMA

La pipeline è composta da quattro componenti principali:

  • Leggi input
  • Estrazione
  • Valutazione
  • Scrivi risultati

Questi componenti fanno uso di due tipi principali: tfma.Extracts e tfma.evaluators.Evaluation . Il tipo tfma.Extracts rappresenta i dati estratti durante l'elaborazione della pipeline mentre il tipo 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 dei dettami in cui le chiavi sono definite (riservate per l'uso) da diverse implementazioni. I tipi sono definiti come segue:

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

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

Leggi input

La fase ReadInputs è costituita da una trasformazione che prende input grezzi (tf.train.Example, CSV, ...) e li converte in estratti. Oggi gli estratti sono rappresentati come byte di input non tfma.INPUT_KEY memorizzati 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 quegli estratti sono compatibili con il downstream estrattori. Spetta ai diversi estrattori documentare chiaramente ciò di cui hanno bisogno.

Estrazione

Il processo di estrazione è un elenco di beam.PTransform eseguiti in serie. Gli estrattori accettano tfma.Extracts come input e restituiscono tfma.Extracts come output. Il proto-tipico estrattore è tfma.extractors.PredictExtractor che utilizza l'estrazione di input prodotta dalla trasformazione degli input letti e lo esegue attraverso un modello per produrre estratti di previsioni. Gli estrattori personalizzati possono essere inseriti in qualsiasi punto a condizione che 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

Si noti che al di fuori di casi molto speciali, è quasi sempre il caso che un tfma.Extracts in un beam.pvalue.PCollection corrisponda a un esempio dal modello.

InputExtractor

tfma.extractors.InputExtractor viene utilizzato per estrarre feature non tfma.extractors.InputExtractor , etichette non tf.train.Example e pesi di esempio non tf.train.Example da tf.train.Example record da utilizzare nelle tf.train.Example e nei calcoli delle metriche. Per impostazione predefinita, i valori vengono memorizzati rispettivamente nelle features estrazione delle chiavi, nelle labels e nei 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 memorizzati come dati di valori np.ndarray (con chiave in base al nome dell'output). Se viene eseguita la valutazione multi-modello, le etichette e i pesi di esempio verranno ulteriormente incorporati in un altro dict (codificato dal nome del modello).

PredictExtractor

tfma.extractors.PredictExtractor esegue le previsioni del modello e le memorizza nelle 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 un dettato dei valori di output (con chiave in base al nome dell'output). Se viene eseguita la valutazione multi-modello, la previsione verrà ulteriormente incorporata in un altro dict (codificato in base al nome del modello). Il valore di output effettivo utilizzato dipende dal modello (ad esempio, gli output restituiti dallo stimatore TF sotto forma di dict mentre keras restituisce valori np.ndarray ).

SliceKeyExtractor

tfma.extractors.SliceKeyExtractor utilizza le specifiche di slicing per determinare quali slice si applicano a ciascun input di esempio in base alle caratteristiche estratte e aggiunge i valori di slicing corrispondenti agli estratti 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 la valutazione nelle prime fasi del processo di estrazione. In quanto tali valutatori sono associati agli estrattori di cui devono essere valutati i risultati. 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 trasformazioni aggiuntive 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 metriche).

MetricsAndPlotsEvaluator

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

Scrivi risultati

La fase WriteResults è dove l'output di valutazione viene scritto su disco. WriteResults usa 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 delle metriche e dei grafici chiamati "metriche" e "grafici". 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

MetricsAndPlotsWriter

Forniamo un tfma.writers.MetricsAndPlotsWriter che converte i dizionari di metriche e grafici in protos serializzati e li scrive su disco.

Se desideri utilizzare un formato di serializzazione diverso, puoi creare un writer personalizzato e utilizzarlo invece. Poiché la tfma.evaluators.Evaluation passata ai writer contiene l'output per tutti i valutatori combinati, viene fornita una trasformazione helper tfma.writers.Write che i writer possono utilizzare nelle loro implementazioni ptransform per selezionare il beam.PCollection appropriato. tasto output (vedi sotto per un esempio).

Personalizzazione

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

Estrattori personalizzati

Per creare un estrattore personalizzato, creare un tipo tfma.extractors.Extractor che avvolge un 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 programma di valutazione personalizzato, creare un tipo tfma.evaluators.Evaluator che avvolge 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 arrivo e visualizzarli per l'archiviazione in una tabella. Questo è esattamente ciò che fa tfma.evaluators.AnalysisTableEvaluator . Un valutatore più complicato potrebbe eseguire un'ulteriore elaborazione e aggregazione dei dati. Vedi tfma.evaluators.MetricsAndPlotsEvaluator come esempio.

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

Scrittori personalizzati

Per creare un writer personalizzato, creare un tipo tfma.writers.Writer che beam.PTransform un beam.PTransform prendendo tfma.evaluators.Evaluation come input e restituendo beam.pvalue.PDone come output. Quello che segue è un esempio di base di un writer 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 tfma.evaluators.MetricsAndPlotsEvaluator 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 un writer è associato all'output di un analizzatore tramite la chiave di output utilizzata (ad esempio tfma.METRICS_KEY , tfma.ANALYSIS_KEY , ecc.).

Esempio passo 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