Bantuan melindungi Great Barrier Reef dengan TensorFlow pada Kaggle Bergabung Tantangan

Metrik dan Plot Analisis Model Tensorflow

Gambaran

TFMA mendukung metrik dan plot berikut:

  • Standar Keras metrik ( tf.keras.metrics.* )
    • Perhatikan bahwa Anda tidak memerlukan model keras untuk menggunakan metrik keras. Metrik dihitung di luar grafik dalam balok menggunakan kelas metrik secara langsung.
  • Standar TFMA metrik dan plot ( tfma.metrics.* )

  • Metrik kustom keras (metrik berasal dari tf.keras.metrics.Metric )

  • Kustom TFMA metrik (metrik berasal dari tfma.metrics.Metric ) menggunakan combiners balok atau metrik berasal dari metrik lainnya).

TFMA juga menyediakan dukungan bawaan untuk mengonversi metrik klasifikasi biner untuk digunakan dengan masalah multi-kelas/multi-label:

  • Binarisasi berdasarkan ID kelas, K teratas, dll.
  • Metrik gabungan berdasarkan rata-rata mikro, rata-rata makro, dll.

TFMA juga menyediakan dukungan bawaan untuk metrik berbasis kueri/peringkat di mana contoh dikelompokkan berdasarkan kunci kueri secara otomatis dalam alur.

Gabungan ada lebih dari 50+ metrik dan plot standar yang tersedia untuk berbagai masalah termasuk regresi, klasifikasi biner, klasifikasi multi-kelas/multi-label, peringkat, dll.

Konfigurasi

Ada dua cara untuk metrik configure di TFMA: (1) menggunakan tfma.MetricsSpec atau (2) dengan menciptakan contoh tf.keras.metrics.* dan / atau tfma.metrics.* Kelas dalam python dan menggunakan tfma.metrics.specs_from_metrics untuk mengkonversikannya ke daftar tfma.MetricsSpec .

Bagian berikut menjelaskan konfigurasi contoh untuk berbagai jenis masalah machine learning.

Metrik Regresi

Berikut ini adalah contoh konfigurasi konfigurasi untuk masalah regresi. Konsultasikan tf.keras.metrics.* Dan tfma.metrics.* Modul untuk kemungkinan metrik tambahan didukung.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    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

Pengaturan yang sama ini dapat dibuat menggunakan kode python berikut:

metrics = [
    tfma.metrics.ExampleCount(name='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)

Perhatikan bahwa pengaturan ini juga tersedia dengan menelepon tfma.metrics.default_regression_specs .

Metrik Klasifikasi Biner

Berikut ini adalah contoh konfigurasi konfigurasi untuk masalah klasifikasi biner. Konsultasikan tf.keras.metrics.* Dan tfma.metrics.* Modul untuk kemungkinan metrik tambahan didukung.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    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

Pengaturan yang sama ini dapat dibuat menggunakan kode python berikut:

metrics = [
    tfma.metrics.ExampleCount(name='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)

Perhatikan bahwa pengaturan ini juga tersedia dengan menelepon tfma.metrics.default_binary_classification_specs .

Metrik Klasifikasi Multi-kelas/Multi-label

Berikut ini adalah contoh konfigurasi konfigurasi untuk masalah klasifikasi multi-kelas. Konsultasikan tf.keras.metrics.* Dan tfma.metrics.* Modul untuk kemungkinan metrik tambahan didukung.

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "ExampleCount" }
    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

Pengaturan yang sama ini dapat dibuat menggunakan kode python berikut:

metrics = [
    tfma.metrics.ExampleCount(name='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)

Perhatikan bahwa pengaturan ini juga tersedia dengan menelepon tfma.metrics.default_multi_class_classification_specs .

Metrik Binarisasi Multi-kelas/Multi-label

Multi-kelas / multi-label metrik dapat binarized untuk menghasilkan metrik per kelas, per top_k, dll menggunakan tfma.BinarizationOptions . Sebagai contoh:

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

Pengaturan yang sama ini dapat dibuat menggunakan kode python berikut:

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

Metrik Agregat Multi-kelas/Multi-label

Metrik multi-kelas / multi-label dapat dikumpulkan untuk menghasilkan nilai agregat tunggal untuk klasifikasi biner metrik dengan menggunakan tfma.AggregationOptions .

Perhatikan bahwa pengaturan agregasi independen dari binarization pengaturan sehingga Anda dapat menggunakan kedua tfma.AggregationOptions dan tfma.BinarizationOptions pada saat yang sama.

Rata-rata Mikro

Averaging mikro dapat dilakukan dengan menggunakan micro_average pilihan dalam tfma.AggregationOptions . Sebagai contoh:

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

Pengaturan yang sama ini dapat dibuat menggunakan kode python berikut:

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

Averaging mikro juga mendukung pengaturan top_k mana hanya nilai-nilai k atas digunakan dalam perhitungan. Sebagai contoh:

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

Pengaturan yang sama ini dapat dibuat menggunakan kode python berikut:

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

Makro / Rata-rata Makro Tertimbang

Makro rata-rata dapat dilakukan dengan menggunakan macro_average atau weighted_macro_average pilihan dalam tfma.AggregationOptions . Kecuali top_k pengaturan yang digunakan, makro membutuhkan pengaturan class_weights untuk mengetahui kelas untuk menghitung rata-rata untuk. Jika class_weight tidak disediakan maka 0,0 diasumsikan. Sebagai contoh:

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

Pengaturan yang sama ini dapat dibuat menggunakan kode python berikut:

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

Seperti averaging mikro, rata-rata makro juga mendukung pengaturan top_k mana hanya nilai-nilai k atas digunakan dalam perhitungan. Sebagai contoh:

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

Pengaturan yang sama ini dapat dibuat menggunakan kode python berikut:

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

Metrik Berbasis Kueri / Peringkat

Permintaan / Peringkat metrik berdasarkan diaktifkan dengan menentukan query_key pilihan dalam spesifikasi metrik. Sebagai contoh:

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

Pengaturan yang sama ini dapat dibuat menggunakan kode python berikut:

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

Metrik Evaluasi Multi-model

TFMA mendukung evaluasi beberapa model secara bersamaan. Ketika evaluasi multi-model dilakukan, metrik akan dihitung untuk setiap model. Sebagai contoh:

from google.protobuf import text_format

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

Jika metrik harus dihitung untuk subset dari model, mengatur model_names di metric_specs . Sebagai contoh:

from google.protobuf import text_format

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

The specs_from_metrics API juga mendukung lewat nama Model:

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

Metrik Perbandingan Model

TFMA mendukung evaluasi metrik perbandingan untuk model kandidat terhadap model dasar. Cara sederhana untuk menyiapkan pasangan model kandidat dan baseline adalah dengan meneruskan eval_shared_model dengan nama model yang tepat (tfma.BASELINE_KEY dan 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")

Metrik perbandingan dihitung secara otomatis untuk semua metrik difabel (saat ini hanya metrik nilai skalar seperti akurasi dan AUC).

Metrik Model Multi-output

TFMA mendukung evaluasi metrik pada model yang memiliki keluaran berbeda. Model multi-output menyimpan prediksi outputnya dalam bentuk dict yang dikunci dengan nama output. Ketika multi-keluaran model yang digunakan, nama-nama output terkait dengan satu set metrik harus ditentukan dalam output_names bagian dari MetricsSpec. Sebagai contoh:

from google.protobuf import text_format

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

The specs_from_metrics API juga mendukung lewat nama keluaran:

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

Menyesuaikan Pengaturan Metrik

TFMA memungkinkan penyesuaian pengaturan yang digunakan dengan metrik yang berbeda. Sebagai contoh Anda mungkin ingin mengubah nama, mengatur ambang batas, dll Hal ini dilakukan dengan menambahkan config bagian untuk metrik config. Konfigurasi ditentukan menggunakan JSON string versi dari parameter yang akan dilewatkan ke metrik __init__ metode (untuk kemudahan penggunaan terkemuka dan trailing '{' dan '}' kurung mungkin dihilangkan). Sebagai contoh:

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

Kustomisasi ini tentu juga didukung secara langsung:

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

Keluaran

Keluaran dari evaluasi metrik adalah serangkaian kunci/nilai metrik dan/atau kunci/nilai plot berdasarkan konfigurasi yang digunakan.

Tombol Metrik

MetricKeys yang didefinisikan menggunakan jenis kunci terstruktur. Kunci ini secara unik mengidentifikasi setiap aspek metrik berikut:

  • Nama metrik ( auc , mean_label , dll)
  • Nama model (hanya digunakan jika evaluasi multi-model)
  • Nama keluaran (hanya digunakan jika model multi-output dievaluasi)
  • Sub kunci (misalnya ID kelas jika model multi-kelas dibinerisasi)

Nilai Metrik

MetricValues didefinisikan menggunakan proto yang encapulates jenis nilai yang berbeda yang didukung oleh metrik yang berbeda (misalnya double , ConfusionMatrixAtThresholds , dll).

Berikut adalah jenis nilai metrik yang didukung:

  • double_value - Sebuah wrapper untuk tipe double.
  • bytes_value - Sebuah byte nilai.
  • bounded_value - Merupakan nilai riil yang bisa menjadi estimasi pointwise, opsional dengan batas-batas perkiraan dari beberapa macam. Memiliki sifat value , lower_bound , dan upper_bound .
  • value_at_cutoffs - Nilai di celana (misalnya presisi @ K, recall @ K). Memiliki properti values , yang masing-masing memiliki sifat cutoff dan value .
  • confusion_matrix_at_thresholds - Kebingungan matriks di ambang. Memiliki properti matrices , masing-masing memiliki properti untuk threshold , precision , recall , dan nilai-nilai matriks kebingungan seperti false_negatives .
  • array_value - Untuk metrik yang mengembalikan sebuah array nilai.

Kunci Plot

PlotKeys mirip dengan metrik kunci kecuali bahwa untuk alasan historis semua nilai plot disimpan dalam proto tunggal sehingga kunci petak tidak memiliki nama.

Nilai Plot

Semua plot yang didukung disimpan dalam proto tunggal yang disebut PlotData .

Hasil Evaluasi

Kembalinya dari evaluasi run adalah tfma.EvalResult . Catatan ini berisi slicing_metrics yang menyandikan kunci metrik sebagai dict multi-level di mana tingkat sesuai dengan nama output, ID kelas, nama metrik, dan nilai metrik masing-masing. Ini dimaksudkan untuk digunakan untuk tampilan UI di notebook Jupiter. Jika akses ke data yang mendasari diperlukan dalam metrics menghasilkan file yang harus digunakan sebagai gantinya (lihat metrics_for_slice.proto ).

Kustomisasi

Selain metrik khusus yang ditambahkan sebagai bagian dari hard yang disimpan (atau EvalSavedModel warisan). Ada dua cara untuk menyesuaikan metrik dalam penyimpanan pasca TFMA: (1) dengan mendefinisikan kelas metrik keras khusus dan (2) dengan mendefinisikan kelas metrik TFMA khusus yang didukung oleh penggabung berkas.

Dalam kedua kasus, metrik dikonfigurasi dengan menentukan nama kelas metrik dan modul terkait. Sebagai contoh:

from google.protobuf import text_format

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

Metrik Keras Kustom

Untuk membuat custom Keras metrik, pengguna perlu untuk memperpanjang tf.keras.metrics.Metric dengan pelaksanaannya dan kemudian pastikan modul metrik ini tersedia pada saat evaluasi.

Perhatikan bahwa untuk metrik menambahkan Model pasca save, TFMA hanya mendukung metrik yang mengambil label (yaitu y_true), prediksi (y_pred), dan contoh berat badan (sample_weight) sebagai parameter ke update_state metode.

Contoh Metrik Keras

Berikut ini adalah contoh metrik keras khusus:

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)

Metrik TFMA Khusus

Untuk membuat TFMA metrik, pengguna perlu untuk memperpanjang tfma.metrics.Metric dengan pelaksanaannya dan kemudian pastikan modul metrik ini tersedia pada saat evaluasi.

Metrik

Sebuah tfma.metrics.Metric implementasi terdiri dari satu set kwargs yang menentukan konfigurasi metrik bersama dengan fungsi untuk menciptakan perhitungan (mungkin beberapa) yang diperlukan untuk calcuate nilai metrik. Ada dua jenis perhitungan utama yang dapat digunakan: tfma.metrics.MetricComputation dan tfma.metrics.DerivedMetricComputation yang dijelaskan dalam bagian di bawah ini. Fungsi yang membuat perhitungan ini akan melewati parameter berikut sebagai input:

  • eval_config: tfam.EvalConfig
    • Konfigurasi eval diteruskan ke evaluator (berguna untuk mencari pengaturan spesifikasi model seperti kunci prediksi yang akan digunakan, dll).
  • model_names: List[Text]
    • Daftar nama model untuk menghitung metrik (Tidak ada jika model tunggal)
  • output_names: List[Text] .
    • Daftar nama keluaran untuk menghitung metrik (Tidak ada jika model tunggal)
  • sub_keys: List[tfma.SubKey] .
    • Daftar sub kunci (ID kelas, K teratas, dll) untuk menghitung metrik untuk (atau Tidak Ada)
  • aggregation_type: tfma.AggregationType
    • Jenis agregasi jika menghitung metrik agregasi.
  • class_weights: Dict[int, float] .
    • Bobot kelas yang akan digunakan jika menghitung metrik agregasi.
  • query_key: Text
    • Kunci kueri yang digunakan jika menghitung metrik berbasis kueri/peringkat.

Jika metrik tidak terkait dengan satu atau beberapa setelan ini, maka parameter tersebut mungkin tidak termasuk dalam definisi tanda tangannya.

Jika metrik dihitung dengan cara yang sama untuk masing-masing model, output, dan sub key, maka utilitas tfma.metrics.merge_per_key_computations dapat digunakan untuk melakukan perhitungan yang sama untuk masing-masing input secara terpisah.

MetrikKomputasi

Sebuah MetricComputation terdiri dari kombinasi dari preprocessor dan combiner . The preprocessor adalah beam.DoFn yang mengambil ekstrak sebagai input dan output keadaan awal yang akan digunakan oleh combiner (lihat arsitektur untuk info lebih lanjut tentang apa yang ekstrak). Jika preprocessor tidak didefinisikan, maka combiner akan diteruskan StandardMetricInputs (metrik input standar berisi label, prediksi, dan example_weights). The combiner adalah beam.CombineFn yang mengambil tupel (key slice, preprocessor output) sebagai input dan output tuple dari (slice_key, metrik hasil dict) sebagai hasilnya.

Perhatikan bahwa mengiris terjadi antara preprocessor dan combiner .

Perhatikan bahwa jika perhitungan metrik ingin membuat penggunaan kedua metrik masukan standar, tapi imbuhnya dengan beberapa fitur dari features ekstrak, maka khusus FeaturePreprocessor dapat digunakan yang akan menggabungkan fitur yang diminta dari beberapa combiners menjadi satu nilai StandardMetricsInputs bersama yang diteruskan ke semua penggabung (penggabung bertanggung jawab untuk membaca fitur yang mereka minati dan mengabaikan yang lainnya).

Contoh

Berikut ini adalah contoh definisi metrik TFMA yang sangat sederhana untuk menghitung 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}

Komputasi Metrik Turunan

Sebuah DerivedMetricComputation terdiri dari fungsi hasil yang digunakan untuk menghitung nilai metrik berdasarkan output dari perhitungan metrik lainnya. Fungsi hasil mengambil dict dari nilai yang dihitung sebagai inputnya dan mengeluarkan dict dari hasil metrik tambahan.

Perhatikan bahwa dapat diterima (disarankan) untuk menyertakan perhitungan yang bergantung pada perhitungan turunan dalam daftar perhitungan yang dibuat oleh metrik. Ini menghindari keharusan membuat dan meneruskan perhitungan yang dibagi di antara beberapa metrik. Evaluator akan secara otomatis melakukan de-dup komputasi yang memiliki definisi yang sama sehingga hanya satu komputasi yang benar-benar dijalankan.

Contoh

The metrik TJUR memberikan contoh yang baik dari metrik berasal.