Unisciti alla community di SIG TFX-Addons e aiutaci a rendere TFX ancora migliore! Iscriviti a SIG TFX-Addons

Metriche e grafici di analisi del modello Tensorflow

Panoramica

TFMA supporta le seguenti metriche e grafici:

  • Standard Keras metriche ( tf.keras.metrics.* )
    • Tieni presente che non è necessario un modello Keras per utilizzare le metriche Keras. Le metriche vengono calcolate al di fuori del grafico in beam utilizzando direttamente le classi di metriche.
  • Standard TFMA metriche e trame ( tfma.metrics.* )

  • Le metriche personalizzate keras (metriche derivate da tf.keras.metrics.Metric )

  • Le metriche personalizzate TFMA (metriche derivate da tfma.metrics.Metric ) utilizzando combinatori fascio o le metriche derivate da altre metriche).

TFMA fornisce anche il supporto integrato per la conversione delle metriche di classificazione binaria da utilizzare con problemi multiclasse/multietichetta:

  • Binarizzazione basata su ID classe, top K, ecc.
  • Metriche aggregate basate su micro media, macro media, ecc.

TFMA fornisce anche supporto integrato per metriche basate su query/classifica in cui gli esempi sono raggruppati automaticamente in base a una chiave di query nella pipeline.

Combinati ci sono oltre 50 metriche e grafici standard disponibili per una varietà di problemi tra cui regressione, classificazione binaria, classificazione multiclasse/multietichetta, ranking, ecc.

Configurazione

Ci sono due modi per metriche di configurazione in TFMA: (1) con la tfma.MetricsSpec o (2) con la creazione di istanze di tf.keras.metrics.* e / o tfma.metrics.* Classi in Python e utilizzando tfma.metrics.specs_from_metrics per convertirli in un elenco di tfma.MetricsSpec .

Le sezioni seguenti descrivono configurazioni di esempio per diversi tipi di problemi di apprendimento automatico.

Metriche di regressione

Di seguito è riportato un esempio di configurazione di un problema di regressione. Consultare le tf.keras.metrics.* E tfma.metrics.* Moduli per eventuali ulteriori parametri supportati.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "WeightedExampleCount" }
    metrics { class_name: "MeanSquaredError" }
    metrics { class_name: "Accuracy" }
    metrics { class_name: "MeanLabel" }
    metrics { class_name: "MeanPrediction" }
    metrics { class_name: "Calibration" }
    metrics {
      class_name: "CalibrationPlot"
      config: '"min_value": 0, "max_value": 10'
    }
  }
""", tfma.EvalConfig()).metrics_specs

Questa stessa configurazione può essere creata utilizzando il seguente codice Python:

metrics = [
    tfma.metrics.ExampleCount(name='example_count'),
    tfma.metrics.WeightedExampleCount(name='weighted_example_count'),
    tf.keras.metrics.MeanSquaredError(name='mse'),
    tf.keras.metrics.Accuracy(name='accuracy'),
    tfma.metrics.MeanLabel(name='mean_label'),
    tfma.metrics.MeanPrediction(name='mean_prediction'),
    tfma.metrics.Calibration(name='calibration'),
    tfma.metrics.CalibrationPlot(
        name='calibration', min_value=0, max_value=10)
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)

Si noti che questa configurazione è inoltre disponibile chiamando tfma.metrics.default_regression_specs .

Metriche di classificazione binaria

Di seguito è riportato un esempio di configurazione di un problema di classificazione binaria. Consultare le tf.keras.metrics.* E tfma.metrics.* Moduli per eventuali ulteriori parametri supportati.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "WeightedExampleCount" }
    metrics { class_name: "BinaryCrossentropy" }
    metrics { class_name: "BinaryAccuracy" }
    metrics { class_name: "AUC" }
    metrics { class_name: "AUCPrecisionRecall" }
    metrics { class_name: "MeanLabel" }
    metrics { class_name: "MeanPrediction" }
    metrics { class_name: "Calibration" }
    metrics { class_name: "ConfusionMatrixPlot" }
    metrics { class_name: "CalibrationPlot" }
  }
""", tfma.EvalConfig()).metrics_specs

Questa stessa configurazione può essere creata utilizzando il seguente codice Python:

metrics = [
    tfma.metrics.ExampleCount(name='example_count'),
    tfma.metrics.WeightedExampleCount(name='weighted_example_count'),
    tf.keras.metrics.BinaryCrossentropy(name='binary_crossentropy'),
    tf.keras.metrics.BinaryAccuracy(name='accuracy'),
    tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
    tf.keras.metrics.AUC(
        name='auc_precision_recall', curve='PR', num_thresholds=10000),
    tf.keras.metrics.Precision(name='precision'),
    tf.keras.metrics.Recall(name='recall'),
    tfma.metrics.MeanLabel(name='mean_label'),
    tfma.metrics.MeanPrediction(name='mean_prediction'),
    tfma.metrics.Calibration(name='calibration'),
    tfma.metrics.ConfusionMatrixPlot(name='confusion_matrix_plot'),
    tfma.metrics.CalibrationPlot(name='calibration_plot')
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)

Si noti che questa configurazione è inoltre disponibile chiamando tfma.metrics.default_binary_classification_specs .

Metriche di classificazione multiclasse/multietichetta

Di seguito è riportato un esempio di configurazione di un problema di classificazione multiclasse. Consultare le tf.keras.metrics.* E tfma.metrics.* Moduli per eventuali ulteriori parametri supportati.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    metrics { class_name: "WeightedExampleCount" }
    metrics { class_name: "SparseCategoricalCrossentropy" }
    metrics { class_name: "SparseCategoricalAccuracy" }
    metrics { class_name: "Precision" config: '"top_k": 1' }
    metrics { class_name: "Precision" config: '"top_k": 3' }
    metrics { class_name: "Recall" config: '"top_k": 1' }
    metrics { class_name: "Recall" config: '"top_k": 3' }
    metrics { class_name: "MultiClassConfusionMatrixPlot" }
  }
""", tfma.EvalConfig()).metrics_specs

Questa stessa configurazione può essere creata utilizzando il seguente codice Python:

metrics = [
    tfma.metrics.ExampleCount(name='example_count'),
    tfma.metrics.WeightedExampleCount(name='weighted_example_count'),
    tf.keras.metrics.SparseCategoricalCrossentropy(
        name='sparse_categorical_crossentropy'),
    tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'),
    tf.keras.metrics.Precision(name='precision', top_k=1),
    tf.keras.metrics.Precision(name='precision', top_k=3),
    tf.keras.metrics.Recall(name='recall', top_k=1),
    tf.keras.metrics.Recall(name='recall', top_k=3),
    tfma.metrics.MultiClassConfusionMatrixPlot(
        name='multi_class_confusion_matrix_plot'),
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)

Si noti che questa configurazione è inoltre disponibile chiamando tfma.metrics.default_multi_class_classification_specs .

Metriche binarie multiclasse/multietichetta

Metriche multi-classe / multi-etichetta può essere binarizzate per produrre metriche per classe, per top_k, ecc utilizzando i tfma.BinarizationOptions . Per esempio:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    binarize: { class_ids: { values: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] } }
    // Metrics to binarize
    metrics { class_name: "AUC" }
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Questa stessa configurazione può essere creata utilizzando il seguente codice Python:

metrics = [
    // Metrics to binarize
    tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics, binarize=tfma.BinarizationOptions(
        class_ids={'values': [0,1,2,3,4,5,6,7,8,9]}))

Metriche aggregate multiclasse/multietichetta

Metriche più classi / multi-etichette possono essere aggregati per produrre un singolo valore aggregato per una classificazione binaria metrica utilizzando tfma.AggregationOptions .

Notare che le impostazioni di aggregazione sono indipendenti binarizzazione impostazioni in modo da poter utilizzare sia tfma.AggregationOptions e tfma.BinarizationOptions allo stesso tempo.

Micro media

Media Micro può essere eseguita utilizzando il micro_average opzione all'interno tfma.AggregationOptions . Per esempio:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    aggregate: { micro_average: true }
    // Metrics to aggregate
    metrics { class_name: "AUC" }
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Questa stessa configurazione può essere creata utilizzando il seguente codice Python:

metrics = [
    // Metrics to aggregate
    tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics, aggregate=tfma.AggregationOptions(micro_average=True))

Media micro supporta anche modificando top_k cui vengono utilizzati solo i valori k migliori nel calcolo. Per esempio:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    aggregate: {
      micro_average: true
      top_k_list: { values: [1, 3] }
    }
    // Metrics to aggregate
    metrics { class_name: "AUC" }
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Questa stessa configurazione può essere creata utilizzando il seguente codice Python:

metrics = [
    // Metrics to aggregate
    tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics,
    aggregate=tfma.AggregationOptions(micro_average=True,
                                      top_k_list={'values': [1, 3]}))

Macro / Media macro ponderata

Macro media può essere eseguita utilizzando i macro_average o weighted_macro_average opzioni all'interno tfma.AggregationOptions . A meno che top_k vengono utilizzate le impostazioni, macro richiede l'impostazione dei class_weights al fine di sapere quali classi per calcolare la media per. Se un class_weight non è previsto quindi 0.0 viene assunto. Per esempio:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    aggregate: {
      macro_average: true
      class_weights: { key: 0 value: 1.0 }
      class_weights: { key: 1 value: 1.0 }
      class_weights: { key: 2 value: 1.0 }
      class_weights: { key: 3 value: 1.0 }
      class_weights: { key: 4 value: 1.0 }
      class_weights: { key: 5 value: 1.0 }
      class_weights: { key: 6 value: 1.0 }
      class_weights: { key: 7 value: 1.0 }
      class_weights: { key: 8 value: 1.0 }
      class_weights: { key: 9 value: 1.0 }
    }
    // Metrics to aggregate
    metrics { class_name: "AUC" }
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Questa stessa configurazione può essere creata utilizzando il seguente codice Python:

metrics = [
    // Metrics to aggregate
    tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics,
    aggregate=tfma.AggregationOptions(
        macro_average=True, class_weights={i: 1.0 for i in range(10)}))

Come micro media, macro media supporta anche modificando top_k cui vengono utilizzati solo i valori k migliori nel calcolo. Per esempio:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    aggregate: {
      macro_average: true
      top_k_list: { values: [1, 3] }
    }
    // Metrics to aggregate
    metrics { class_name: "AUC" }
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Questa stessa configurazione può essere creata utilizzando il seguente codice Python:

metrics = [
    // Metrics to aggregate
    tf.keras.metrics.AUC(name='auc', num_thresholds=10000),
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics,
    aggregate=tfma.AggregationOptions(macro_average=True,
                                      top_k_list={'values': [1, 3]}))

Metriche basate su query/classifica

Query / ranking metriche basate sono abilitati specificando l' query_key opzione nelle metriche specifiche. Per esempio:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    query_key: "doc_id"
    metrics {
      class_name: "NDCG"
      config: '"gain_key": "gain", "top_k_list": [1, 2]'
    }
    metrics { class_name: "MinLabelPosition" }
  }
""", tfma.EvalConfig()).metrics_specs

Questa stessa configurazione può essere creata utilizzando il seguente codice Python:

metrics = [
    tfma.metrics.NDCG(name='ndcg', gain_key='gain', top_k_list=[1, 2]),
    tfma.metrics.MinLabelPosition(name='min_label_position')
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics, query_key='doc_id')

Metriche di valutazione multi-modello

TFMA supporta la valutazione di più modelli contemporaneamente. Quando viene eseguita la valutazione multi-modello, verranno calcolate le metriche per ciascun modello. Per esempio:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    # no model_names means all models
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Se le metriche devono essere calcolati per un sottoinsieme di modelli, impostare model_names nelle metric_specs . Per esempio:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    model_names: ["my-model1"]
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Lo specs_from_metrics API supporta passando anche nomi di modello:

metrics = [
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics, model_names=['my-model1'])

Metriche di confronto dei modelli

TFMA supporta la valutazione delle metriche di confronto per un modello candidato rispetto a un modello di base. Un modo semplice per impostare la coppia del modello candidato e di base è passare lungo un eval_shared_model con i nomi di modello corretti (tfma.BASELINE_KEY e tfma.CANDIDATE_KEY):


eval_config = text_format.Parse("""
  model_specs {
    # ... model_spec without names ...
  }
  metrics_spec {
    # ... metrics ...
  }
""", tfma.EvalConfig())

eval_shared_models = [
  tfma.default_eval_shared_model(
      model_name=tfma.CANDIDATE_KEY,
      eval_saved_model_path='/path/to/saved/candidate/model',
      eval_config=eval_config),
  tfma.default_eval_shared_model(
      model_name=tfma.BASELINE_KEY,
      eval_saved_model_path='/path/to/saved/baseline/model',
      eval_config=eval_config),
]

eval_result = tfma.run_model_analysis(
    eval_shared_models,
    eval_config=eval_config,
    # This assumes your data is a TFRecords file containing records in the
    # tf.train.Example format.
    data_location="/path/to/file/containing/tfrecords",
    output_path="/path/for/output")

Le metriche di confronto vengono calcolate automaticamente per tutte le metriche diff-able (attualmente solo metriche di valore scalare come accuratezza e AUC).

Metriche del modello multi-output

TFMA supporta la valutazione delle metriche su modelli con output diversi. I modelli multi-output memorizzano le loro previsioni di output sotto forma di un dict codificato per nome di output. Quando vengono utilizzati multi-uscita del modello, i nomi delle uscite associate con un insieme di parametri devono essere specificati nella output_names sezione del MetricsSpec. Per esempio:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    output_names: ["my-output"]
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Lo specs_from_metrics API supporta passando anche nomi di uscita:

metrics = [
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics, output_names=['my-output'])

Personalizzazione delle impostazioni delle metriche

TFMA consente la personalizzazione delle impostazioni utilizzate con metriche diverse. Per esempio si potrebbe desiderare di cambiare il nome, impostare le soglie, ecc Questo viene fatto con l'aggiunta di una config sezione per la configurazione metrica. La configurazione viene specificato utilizzando la versione stringa JSON dei parametri che si ripercuoterebbero alle metriche __init__ metodo (per facilità d'uso del iniziali e finali '{' e '}' parentesi possono essere omesse). Per esempio:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics {
      class_name: "ConfusionMatrixAtThresholds"
      config: '"thresholds": [0.3, 0.5, 0.8]'
    }
  }
""", tfma.MetricsSpec()).metrics_specs

Questa personalizzazione è ovviamente supportata anche direttamente:

metrics = [
   tfma.metrics.ConfusionMatrixAtThresholds(thresholds=[0.3, 0.5, 0.8]),
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)

Uscite

L'output di una valutazione della metrica è una serie di chiavi/valori di metrica e/o chiavi/valori del grafico in base alla configurazione utilizzata.

Chiavi metriche

MetricKeys sono definiti usando un tipo di chiave strutturato. Questa chiave identifica in modo univoco ciascuno dei seguenti aspetti di una metrica:

  • Nome della metrica ( auc , mean_label , ecc)
  • Nome del modello (utilizzato solo in caso di valutazione multi-modello)
  • Nome dell'uscita (utilizzato solo se vengono valutati modelli a più uscite)
  • Sottochiave (ad es. ID classe se il modello multiclasse è binarizzato)

Valore metrico

MetricValues sono definiti usando un proto che encapulates i diversi tipi di valore supportati dai diversi parametri (ad esempio double , ConfusionMatrixAtThresholds , ecc).

Di seguito sono riportati i tipi di valori di metrica supportati:

  • double_value - Un wrapper per un doppio tipo.
  • bytes_value - Un byte valore.
  • bounded_value - Rappresenta un valore reale che potrebbe essere una stima puntuale, eventualmente con limiti approssimativi di qualche tipo. Ha proprietà value , lower_bound e upper_bound .
  • value_at_cutoffs - Value at tagli (ad esempio precisione @ K, richiamo @ K). Ha proprietà values , ognuno dei quali ha le proprietà cutoff e value .
  • confusion_matrix_at_thresholds - matrice di confusione a soglie. Ha immobili matrices , ciascuno dei quali ha proprietà di threshold , precision , recall , e valori matrice di confusione come false_negatives .
  • array_value - Per le metriche che restituiscono una matrice di valori.

Tasti di trama

PlotKeys sono simili alle chiavi metriche, tranne che per ragioni storiche tutti i valori trame sono memorizzati in un unico proto così la chiave trama non ha un nome.

Valori del grafico

Tutte le trame supportati vengono memorizzate in un unico proto chiamato PlotData .

EvalResult

Il ritorno da una corsa di valutazione è un tfma.EvalResult . Questo record contiene slicing_metrics che codificano la chiave metrica come dict multi-livello in cui i livelli corrispondono rispettivamente a nome di output, ID classe, nome della metrica e valore metrico. Questo è pensato per essere utilizzato per la visualizzazione dell'interfaccia utente in un notebook Jupiter. Se l'accesso ai dati sottostanti è necessario il metrics risultato file deve essere usato al posto (vedi metrics_for_slice.proto ).

personalizzazione

Oltre alle metriche personalizzate che vengono aggiunte come parte di un Keras salvato (o EvalSavedModel legacy). Esistono due modi per personalizzare le metriche nel post-salvataggio TFMA: (1) definendo una classe metrica Keras personalizzata e (2) definendo una classe metrica TFMA personalizzata supportata da un combinatore di fasci.

In entrambi i casi, le metriche vengono configurate specificando il nome della classe metrica e del modulo associato. Per esempio:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "MyMetric" module: "my.module"}
  }
""", tfma.EvalConfig()).metrics_specs

Metriche personalizzate Keras

Per creare un costume Keras metrica, gli utenti hanno bisogno di estendere tf.keras.metrics.Metric con la loro attuazione e quindi assicurarsi il modulo della metrica è disponibile in fase di valutazione.

Si noti che per le metriche aggiunti modello palo risparmi, TFMA supporta solo le metriche che prendono etichetta (cioè y_true), predizione (y_pred), ed esempio peso (sample_weight) come parametri al update_state metodo.

Esempio di metrica Keras

Di seguito è riportato un esempio di una metrica Keras personalizzata:

class MyMetric(tf.keras.metrics.Mean):

  def __init__(self, name='my_metric', dtype=None):
    super(MyMetric, self).__init__(name=name, dtype=dtype)

  def update_state(self, y_true, y_pred, sample_weight=None):
    return super(MyMetric, self).update_state(
        y_pred, sample_weight=sample_weight)

Metriche TFMA personalizzate

Per creare un TFMA metrica personalizzata, gli utenti hanno bisogno di estendere tfma.metrics.Metric con la loro attuazione e quindi assicurarsi il modulo della metrica è disponibile in fase di valutazione.

Metrica

Un tfma.metrics.Metric attuazione è costituito da un insieme di kwargs che definiscono la configurazione metriche insieme ad una funzione per creare i calcoli (possibilmente multiple) necessari per calcuate valore metriche. Esistono due principali tipi di calcolo che possono essere utilizzati: tfma.metrics.MetricComputation e tfma.metrics.DerivedMetricComputation descritti nella sezione sottostante. Alla funzione che crea questi calcoli verranno passati i seguenti parametri come input:

  • eval_config: tfam.EvalConfig
    • La configurazione di valutazione è passata al valutatore (utile per cercare le impostazioni delle specifiche del modello come la chiave di previsione da utilizzare, ecc.).
  • model_names: List[Text]
    • Elenco dei nomi dei modelli per cui calcolare le metriche (Nessuno se modello singolo)
  • output_names: List[Text] .
    • Elenco dei nomi di output per cui calcolare le metriche (Nessuno se modello singolo)
  • sub_keys: List[tfma.SubKey] .
    • Elenco di chiavi secondarie (ID classe, top K, ecc.) per calcolare le metriche per (o nessuna)
  • aggregation_type: tfma.AggregationType
    • Tipo di aggregazione se si calcola una metrica di aggregazione.
  • class_weights: Dict[int, float] .
    • Pesi di classe da utilizzare se si calcola una metrica di aggregazione.
  • query_key: Text
    • Chiave di query utilizzata se si calcola una metrica basata su query/classifica.

Se una metrica non è associata a una o più di queste impostazioni, potrebbe non includere tali parametri nella definizione della firma.

Se una metrica è calcolato nello stesso modo per ciascun modello, uscita e chiave secondaria, l'utilità tfma.metrics.merge_per_key_computations possono essere utilizzati per eseguire gli stessi calcoli per ciascuno di questi ingressi separatamente.

Calcolo metrico

Un MetricComputation è costituito da una combinazione di un preprocessor e un combiner . Il preprocessor è un beam.DoFn che prende estratti come input e restituisce lo stato iniziale che verrà utilizzato dal combinatore (vedi architettura per maggiori informazioni su quali sono estratti). Se un preprocessor non è definito, allora il combinatore verrà passato StandardMetricInputs (ingressi metrici standard contiene etichette, previsioni e example_weights). Il combiner è un beam.CombineFn che prende una tupla di (chiave fetta, uscita preprocessore) come input e restituisce una tupla di (slice_key, risultati metrici dict) come risultato.

Si noti che affettare avviene tra il preprocessor e il combiner .

Si noti che se un computo metrico vuole fare uso di entrambi gli ingressi metriche standard, ma aggiunto un formato di alcune delle caratteristiche dalle features estratti, quindi lo speciale FeaturePreprocessor può essere utilizzato, che si fondono le caratteristiche richieste da più combinatori in un unico valore condiviso StandardMetricsInputs che viene passato a tutti i combinatori (i combinatori sono responsabili della lettura delle funzionalità a cui sono interessati e ignorano il resto).

Esempio

Quello che segue è un esempio molto semplice di definizione della metrica TFMA per il calcolo di ExampleCount:

class ExampleCount(tfma.metrics.Metric):

  def __init__(self, name: Text = 'example_count'):
    super(ExampleCount, self).__init__(_example_count, name=name)


def _example_count(
    name: Text = 'example_count') -> tfma.metrics.MetricComputations:
  key = tfma.metrics.MetricKey(name=name)
  return [
      tfma.metrics.MetricComputation(
          keys=[key],
          preprocessor=_ExampleCountPreprocessor(),
          combiner=_ExampleCountCombiner(key))
  ]


class _ExampleCountPreprocessor(beam.DoFn):

  def process(self, extracts: tfma.Extracts) -> Iterable[int]:
    yield 1


class _ExampleCountCombiner(beam.CombineFn):

  def __init__(self, metric_key: tfma.metrics.MetricKey):
    self._metric_key = metric_key

  def create_accumulator(self) -> int:
    return 0

  def add_input(self, accumulator: int, state: int) -> int:
    return accumulator + state

  def merge_accumulators(self, accumulators: Iterable[int]) -> int:
    accumulators = iter(accumulators)
    result = next(accumulator)
    for accumulator in accumulators:
      result += accumulator
    return result

  def extract_output(self,
                     accumulator: int) -> Dict[tfma.metrics.MetricKey, int]:
    return {self._metric_key: accumulator}

Calcolo metrico derivato

Un DerivedMetricComputation è costituito da una funzione risultato che viene utilizzato per calcolare i valori metrici basati sulla produzione di altri calcoli metrici. La funzione result accetta un dict di valori calcolati come input e restituisce un dict di risultati di metrica aggiuntivi.

Si noti che è accettabile (consigliato) includere i calcoli da cui dipende un calcolo derivato nell'elenco dei calcoli creati da una metrica. Ciò evita di dover pre-creare e passare calcoli condivisi tra più metriche. Il valutatore deduplica automaticamente i calcoli che hanno la stessa definizione in modo che venga effettivamente eseguito un solo calcolo.

Esempio

Le metriche TJUR fornisce un buon esempio di metriche derivate.