Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Tensorflow Model Analysis Metrics

Panoramica

TFMA supporta le seguenti metriche:

  • Metriche keras standard ( tf.keras.metrics.* )
    • Tieni presente che non è necessario un modello keras per utilizzare le metriche keras. Le metriche vengono calcolate all'esterno del grafico nella trave utilizzando direttamente le classi di metriche.
  • Metriche TFMA standard ( tfma.metrics.* )
  • Metriche keras personalizzate (metriche derivate da tf.keras.metrics.Metric )
  • Metriche TFMA personalizzate (metriche derivate da tfma.metrics.Metric utilizzando combinatori di fasci personalizzati o metriche derivate da altre metriche).

TFMA fornisce anche il supporto integrato per la conversione delle metriche di classificazione binaria da utilizzare con problemi multi-classe / multi-etichetta:

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

TFMA fornisce anche il supporto integrato per le metriche basate su query / ranking in cui gli esempi sono raggruppati automaticamente da 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 multi-classe / multi-etichetta, classifica, ecc.

Configurazione

Esistono due modi per configurare le metriche in TFMA: (1) utilizzando il protocollo MetricsSpec o (2) creando istanze delle tf.keras.metrics.* E / o tfma.metrics.* In python e utilizzando tfma.metrics.specs_from_metrics per convertirli in MetricsSpecs.

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 della configurazione per un problema di regressione. Consulta i tf.keras.metrics.* E tfma.metrics.* Per possibili metriche aggiuntive supportate.

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)

Nota che questa configurazione è disponibile anche chiamando tfma.metrics.default_regression_specs .

Metriche di classificazione binaria

Di seguito è riportato un esempio di configurazione della configurazione per un problema di classificazione binaria. Consulta i tf.keras.metrics.* E tfma.metrics.* Per possibili metriche aggiuntive supportate.

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)

Nota che questa configurazione è disponibile anche chiamando tfma.metrics.default_binary_classification_specs .

Metriche di classificazione multi-classe / multi-etichetta

Di seguito è riportato un esempio di configurazione della configurazione per un problema di classificazione multi-classe. Consulta i tf.keras.metrics.* E tfma.metrics.* Per possibili metriche aggiuntive supportate.

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)

Nota che questa configurazione è disponibile anche chiamando tfma.metrics.default_multi_class_classification_specs .

Metriche binarizzate multi-classe / multi-etichetta

Le metriche multi-classe / multi-etichetta possono essere binarizzate per produrre metriche per classe, per top_k, ecc. Utilizzando 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 multi-classe / multi-etichetta

Le metriche multi-classe / multi-etichetta possono essere aggregate per produrre un singolo valore aggregato per una metrica di classificazione binaria.

Micro media

Media micro può essere eseguita in modo indipendente o come parte di una binarizzazione di metriche utilizzando l' 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 macro / macro ponderata

La media macro deve essere eseguita come parte di una binarizzazione delle metriche insieme alle opzioni maro_average o weighted_macro_average all'interno di tfma.AggregationOptions . 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] } }
    aggregate: { macro_average: true }
    // Metrics to both binarize and aggregate
    metrics { class_name: "AUC" }
    ...
  }
""", tfma.EvalConfig()).metrics_specs

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

metrics = [
    // Metrics to both binarize and aggregate
    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]}),
    aggregate=tfma.AggregationOptions(macro_average=True))

Metriche basate su query / ranking

Le metriche basate su query / ranking vengono abilitate specificando l'opzione query_key nelle specifiche delle metriche. Per esempio:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    query_key: "doc_id"
    binarize { top_k_list: { values: [1, 2] } }
    metrics { class_name: "NDCG" config: '"gain_key": "gain"' }
  }
  metrics_specs {
    query_key: "doc_id"
    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'),
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics, query_key='doc_id', binarize=tfma.BinarizationOptions(
        top_k_list={'values': [1,2]}))

metrics = [
    tfma.metrics.MinLabelPosition(name='min_label_position')
]
metrics_specs.extend(
    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, le metriche verranno calcolate per ogni 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 calcolate per un sottoinsieme di modelli, impostare model_names in 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

L'API specs_from_metrics supporta anche il passaggio di nomi di modelli:

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 il candidato e la coppia di modelli di base consiste nel trasmettere un eval_shared_model con i nomi di modello appropriati (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/candiate/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-grado (attualmente solo metriche di valori scalari come accuratezza e AUC).

Metriche del modello multiuscita

TFMA supporta la valutazione delle metriche su modelli con output diversi. I modelli multi-output memorizzano le previsioni dell'output sotto forma di un dict codificato in base al nome dell'output. Quando vengono utilizzati modelli multi-output, i nomi degli output associati a una serie di metriche devono essere specificati nella sezione output_names di MetricsSpec. Per esempio:

from google.protobuf import text_format

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

L'API specs_from_metrics supporta anche il passaggio di nomi di output:

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. Ad esempio, potresti voler cambiare il nome, impostare le soglie, ecc. Questo viene fatto aggiungendo una sezione di config alla configurazione della metrica. La configurazione viene specificata utilizzando la versione stringa JSON dei parametri che verrebbero passati al metodo __init__ metriche (per facilità d'uso le parentesi "{" e "}" iniziali e finali 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 metrica è una serie di chiavi / valori metrici e / o chiavi / valori del grafico in base alla configurazione utilizzata.

Chiavi metriche

Le chiavi metriche vengono definite utilizzando 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 se la valutazione multi-modello)
  • Nome output (utilizzato solo se vengono valutati modelli multi-output)
  • Sottochiave (ad es. ID classe se il modello multi-classe è binarizzato)

Valore metrico

MetricValues vengono definiti utilizzando un proto che racchiude i diversi tipi di valore supportati dalle diverse metriche (ad esempio double , ConfusionMatrixAtThresholds , ecc.).

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

  • double_value - Un wrapper per un tipo double.
  • bytes_value - Un valore di byte.
  • bounded_value - Rappresenta un valore reale che potrebbe essere una stima puntuale, opzionalmente con limiti approssimativi di qualche tipo. Ha proprietà value , lower_bound e upper_bound .
  • value_at_cutoffs - Valore ai cutoff (es. precisione @ K, richiamo @ K). Ha values proprietà, ognuno dei quali ha proprietà di cutoff e value .
  • confusion_matrix_at_thresholds - Matrice di confusione alle soglie. Dispone di matrices proprietà, ognuna delle quali dispone di proprietà per valori di matrice di threshold , precision , recall e confusione come false_negatives .
  • array_value - Per le metriche che restituiscono un array di valori.

Plot Keys

PlotKeys sono simili alle chiavi metriche tranne per il fatto che per motivi storici tutti i valori dei grafici sono memorizzati in un unico protocollo, quindi la chiave del grafico non ha un nome.

Valori del grafico

Tutti i grafici supportati vengono memorizzati in un unico protocollo denominato PlotData .

EvalResult

Il risultato di un'esecuzione di valutazione è un EvalResult . Questo record contiene slicing_metrics che codificano la chiave della metrica come un dict multilivello in cui i livelli corrispondono rispettivamente al nome dell'output, all'ID della classe, al nome della metrica e al valore della metrica. È concepito per essere utilizzato per la visualizzazione dell'interfaccia utente in un notebook Jupiter. Se è necessario l'accesso ai dati sottostanti, è necessario utilizzare il file dei risultati delle metrics (vedere 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 salvataggio post TFMA: (1) definendo una classe metrica keras personalizzata e (2) definendo una classe metrica TFMA personalizzata supportata da un combinatore di raggi.

In entrambi i casi, le metriche vengono configurate specificando il nome della classe di metriche 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 Keras personalizzate

Per creare una metrica keras personalizzata, gli utenti devono estendere tf.keras.metrics.Metric con la loro implementazione e quindi assicurarsi che il modulo della metrica sia disponibile al momento della valutazione.

Si noti che per le metriche aggiunte dopo il salvataggio del modello, TFMA supporta solo le metriche che accettano l'etichetta (ad esempio y_true), la previsione (y_pred) e il peso di esempio (sample_weight) come parametri per il metodo update_state .

Esempio di metrica di 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 una metrica TFMA personalizzata, gli utenti devono estendere tfma.metrics.Metric con la loro implementazione e quindi assicurarsi che il modulo della metrica sia disponibile al momento della valutazione.

Metrico

tfma.metrics.Metric è composta da un insieme di kwarg che definiscono la configurazione delle metriche insieme a una funzione per creare i calcoli (possibilmente multipli) necessari per calcolare il valore della metrica. Esistono due tipi di calcolo principali che possono essere utilizzati: tfma.metrics.MetricComputation e tfma.metrics.DerivedMetricComputation descritti nelle sezioni seguenti. Alla funzione che crea questi calcoli verranno passati i seguenti parametri come input:

  • eval_config: tfam.EvalConfig
    • La configurazione eval 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 sottochiavi (ID classe, K in alto, ecc.) Per calcolare le metriche (o Nessuno)
  • class_weights: Dict[int, float] .
    • Pesi delle classi da utilizzare se si calcola una metrica di aggregazione.
  • query_key: Text
    • Chiave di query utilizzata se si calcola una metrica basata su query / ranking.

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

Se una metrica viene calcolata allo stesso modo per ogni modello, output e sottochiave, è possibile utilizzare l'utilità tfma.metrics.merge_per_key_computations per eseguire gli stessi calcoli per ciascuno di questi input separatamente.

MetricComputation

Un MetricComputation è costituito da una combinazione di un preprocessor e un combiner . Il preprocessor è un beam.DoFn che prende gli estratti come input e restituisce lo stato iniziale che verrà utilizzato dal combinatore (vedi architettura per maggiori informazioni su cosa sono gli estratti). Se un preprocessor non è definito, al combinatore verranno passati StandardMetricInputs (gli input metrici standard contengono etichette, previsioni e example_weights). Il combiner è un beam.CombineFn che accetta una tupla di (slice key, output del preprocessore) come input e restituisce una tupla di (slice_key, metric results dict) come risultato.

Notare che l'affettamento avviene tra il preprocessor e il combiner .

Si noti che se un calcolo metrico desidera utilizzare entrambi gli input metrici standard, ma lo aumenta con alcune delle funzionalità dagli estratti di features , è possibile utilizzare lo speciale FeaturePreprocessor che unirà le funzionalità richieste da più combinatori in un unico Shared StandardMetricsInputs valore che viene passato a tutti i combinatori (i combinatori sono responsabili della lettura delle caratteristiche 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: List[int]) -> int:
    result = 0
    for accumulator in accumulators:
      result += accumulator
    return result

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

DerivedMetricComputation

Un DerivedMetricComputation è costituito da una funzione di risultato utilizzata per calcolare i valori di metrica in base all'output di altri calcoli di metrica. La funzione di risultato accetta un dict di valori calcolati come input e restituisce un dict di risultati metrici aggiuntivi.

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

Esempio

Le metriche TJUR forniscono un buon esempio di metriche derivate.