Halaman ini diterjemahkan oleh Cloud Translation API.

Metrik dan Plot Analisis Model Tensorflow

Ringkasan

TFMA mendukung metrik dan plot berikut:

Metrik keras standar ( tf.keras.metrics.* )
- Perhatikan bahwa Anda tidak memerlukan model keras untuk menggunakan metrik keras. Metrik dihitung di luar grafik dalam beam menggunakan kelas metrik secara langsung.
Metrik dan plot TFMA standar ( tfma.metrics.* )
Metrik keras khusus (metrik berasal dari tf.keras.metrics.Metric )
Metrik TFMA khusus (metrik yang berasal dari tfma.metrics.Metric ) menggunakan penggabung sinar khusus atau metrik yang berasal dari metrik lain).

TFMA juga menyediakan dukungan bawaan untuk mengonversi metrik klasifikasi biner untuk digunakan dengan masalah multikelas/multilabel:

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 di dalam alur.

Jika digabungkan, terdapat lebih dari 50+ metrik dan plot standar yang tersedia untuk berbagai masalah termasuk regresi, klasifikasi biner, klasifikasi kelas jamak/multi-label, pemeringkatan, dll.

Konfigurasi

Ada dua cara untuk mengonfigurasi metrik di TFMA: (1) menggunakan tfma.MetricsSpec atau (2) dengan membuat instance kelas tf.keras.metrics.* dan/atau tfma.metrics.* dengan python dan menggunakan tfma.metrics.specs_from_metrics untuk mengonversinya menjadi daftar tfma.MetricsSpec .

Bagian berikut menjelaskan contoh konfigurasi untuk berbagai jenis masalah pembelajaran mesin.

Metrik Regresi

Berikut ini adalah contoh pengaturan konfigurasi untuk masalah regresi. Lihat modul tf.keras.metrics.* dan tfma.metrics.* untuk mengetahui kemungkinan dukungan metrik tambahan.

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 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 penyiapan ini juga tersedia dengan memanggil tfma.metrics.default_regression_specs .

Metrik Klasifikasi Biner

Berikut ini adalah contoh pengaturan konfigurasi untuk masalah klasifikasi biner. Lihat modul tf.keras.metrics.* dan tfma.metrics.* untuk mengetahui kemungkinan dukungan metrik tambahan.

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 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 penyiapan ini juga tersedia dengan memanggil tfma.metrics.default_binary_classification_specs .

Metrik Klasifikasi Multikelas/Multilabel

Berikut ini adalah contoh pengaturan konfigurasi untuk masalah klasifikasi kelas jamak. Lihat modul tf.keras.metrics.* dan tfma.metrics.* untuk mengetahui kemungkinan dukungan metrik tambahan.

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 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 penyiapan ini juga tersedia dengan memanggil tfma.metrics.default_multi_class_classification_specs .

Metrik Binarisasi Multikelas/Multilabel

Metrik multikelas/multilabel dapat dibinarisasi untuk menghasilkan metrik per kelas, per top_k, dll menggunakan tfma.BinarizationOptions . Misalnya:

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 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 Multikelas/Multilabel

Metrik multikelas/multi-label dapat digabungkan untuk menghasilkan nilai gabungan tunggal untuk metrik klasifikasi biner dengan menggunakan tfma.AggregationOptions .

Perhatikan bahwa pengaturan agregasi tidak bergantung pada pengaturan binarisasi sehingga Anda dapat menggunakan tfma.AggregationOptions dan tfma.BinarizationOptions secara bersamaan.

Rata-rata Mikro

Rata-rata mikro dapat dilakukan dengan menggunakan opsi micro_average dalam tfma.AggregationOptions . Misalnya:

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

Micro averaging juga mendukung pengaturan top_k dimana hanya nilai k teratas yang digunakan dalam perhitungan. Misalnya:

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

Rata-rata makro dapat dilakukan dengan menggunakan opsi macro_average atau weighted_macro_average dalam tfma.AggregationOptions . Kecuali pengaturan top_k digunakan, makro memerlukan pengaturan class_weights untuk mengetahui kelas mana yang rata-rata dihitung. Jika class_weight tidak disediakan maka diasumsikan 0,0. Misalnya:

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 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 halnya micro averaging, macro averaging juga mendukung pengaturan top_k dimana hanya nilai k teratas yang digunakan dalam perhitungan. Misalnya:

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

Metrik berbasis kueri/peringkat diaktifkan dengan menentukan opsi query_key dalam spesifikasi metrik. Misalnya:

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 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. Saat evaluasi multi-model dilakukan, metrik akan dihitung untuk setiap model. Misalnya:

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 perlu dihitung untuk subkumpulan model, tetapkan model_names di metric_specs . Misalnya:

from google.protobuf import text_format

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

API specs_from_metrics juga mendukung penerusan 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 model dasar 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 berdasarkan nama output. Ketika model multi-output digunakan, nama output yang terkait dengan sekumpulan metrik harus ditentukan di bagian output_names pada MetricsSpec. Misalnya:

from google.protobuf import text_format

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

API specs_from_metrics juga mendukung penerusan 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 berbeda. Misalnya Anda mungkin ingin mengubah nama, menetapkan ambang batas, dll. Hal ini dilakukan dengan menambahkan bagian config ke konfigurasi metrik. Konfigurasi ditentukan menggunakan versi string JSON dari parameter yang akan diteruskan ke metode metrik __init__ (untuk kemudahan penggunaan, tanda kurung '{' dan '}' di awal dan akhir dapat dihilangkan). Misalnya:

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 tentunya juga didukung secara langsung:

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

Keluaran

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

Kunci Metrik

MetricKeys ditentukan 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 kelas jamak dibinarisasi)

Nilai Metrik

MetricValues ditentukan menggunakan proto yang merangkum tipe nilai berbeda yang didukung oleh metrik berbeda (misalnya double , ConfusionMatrixAtThresholds , dll).

Berikut adalah jenis nilai metrik yang didukung:

double_value - Pembungkus untuk tipe ganda.
bytes_value - Nilai byte.
bounded_value - Mewakili nilai nyata yang dapat berupa perkiraan yang tepat, secara opsional dengan semacam batasan perkiraan. Memiliki properti value , lower_bound , dan upper_bound .
value_at_cutoffs - Nilai pada titik potong (misalnya presisi@K, recall@K). Memiliki properti values yang masing-masing memiliki properti cutoff dan value .
confusion_matrix_at_thresholds - Matriks kebingungan di ambang batas. Memiliki properti matrices yang masing-masing memiliki properti untuk nilai matriks threshold , precision , recall , dan matriks konfusi seperti false_negatives .
array_value - Untuk metrik yang mengembalikan serangkaian nilai.

Kunci Plot

PlotKeys mirip dengan kunci metrik kecuali karena alasan historis semua nilai plot disimpan dalam satu proto sehingga kunci plot tidak memiliki nama.

Nilai Plot

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

Hasil Evaluasi

Hasil dari evaluasi yang dijalankan adalah tfma.EvalResult . Catatan ini berisi slicing_metrics yang mengkodekan kunci metrik sebagai dict multi-level yang masing-masing levelnya sesuai dengan nama output, ID kelas, nama metrik, dan nilai metrik. Ini dimaksudkan untuk digunakan untuk tampilan UI di notebook Jupiter. Jika akses ke data pokok diperlukan, file hasil metrics harus digunakan (lihat metrics_for_slice.proto ).

Kustomisasi

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

Dalam kedua kasus tersebut, metrik dikonfigurasi dengan menentukan nama kelas metrik dan modul terkait. Misalnya:

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 metrik keras khusus, pengguna perlu memperluas tf.keras.metrics.Metric dengan implementasinya lalu memastikan modul metrik tersedia pada waktu evaluasi.

Perhatikan bahwa untuk metrik yang ditambahkan setelah penyimpanan model, TFMA hanya mendukung metrik yang menggunakan label (yaitu y_true), prediksi (y_pred), dan bobot contoh (sample_weight) sebagai parameter pada metode update_state .

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 metrik TFMA khusus, pengguna perlu memperluas tfma.metrics.Metric dengan implementasinya lalu memastikan modul metrik tersedia pada waktu evaluasi.

Metrik

Implementasi tfma.metrics.Metric terdiri dari sekumpulan kwarg yang menentukan konfigurasi metrik bersama dengan fungsi untuk membuat komputasi (mungkin beberapa) yang diperlukan untuk menghitung nilai metrik. Ada dua jenis komputasi utama yang dapat digunakan: tfma.metrics.MetricComputation dan tfma.metrics.DerivedMetricComputation yang dijelaskan pada bagian di bawah. Fungsi yang membuat komputasi ini akan meneruskan parameter berikut sebagai masukan:

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 (atau Tidak Ada)
aggregation_type: tfma.AggregationType
- Jenis agregasi jika menghitung metrik agregasi.
class_weights: Dict[int, float] .
- Bobot kelas yang akan digunakan saat menghitung metrik agregasi.
query_key: Text
- Kunci kueri digunakan jika menghitung metrik berbasis kueri/peringkat.

Jika metrik tidak dikaitkan dengan satu atau beberapa pengaturan ini, maka metrik tersebut mungkin tidak dimasukkan dalam definisi tanda tangannya.

Jika metrik dihitung dengan cara yang sama untuk setiap model, keluaran, dan sub kunci, maka utilitas tfma.metrics.merge_per_key_computations dapat digunakan untuk melakukan penghitungan yang sama untuk setiap masukan ini secara terpisah.

Komputasi Metrik

MetricComputation terdiri dari kombinasi preprocessors dan combiner . preprocessors adalah daftar preprocessor , yang merupakan beam.DoFn yang mengambil ekstrak sebagai masukannya dan mengeluarkan keadaan awal yang akan digunakan oleh penggabung (lihat arsitektur untuk informasi lebih lanjut tentang apa yang dimaksud dengan ekstrak). Semua praprosesor akan dieksekusi secara berurutan sesuai urutan daftar. Jika preprocessors kosong, maka penggabung akan meneruskan StandardMetricInputs (input metrik standar berisi label, prediksi, dan bobot_contoh). combiner adalah beam.CombineFn yang mengambil tupel (kunci irisan, keluaran praprosesor) sebagai masukannya dan mengeluarkan tupel (kunci_slice, dikt hasil metrik) sebagai hasilnya.

Perhatikan bahwa pemotongan terjadi antara preprocessors dan combiner .

Perhatikan bahwa jika perhitungan metrik ingin menggunakan kedua input metrik standar, namun menambahnya dengan beberapa fitur dari ekstrak features , maka FeaturePreprocessor khusus dapat digunakan yang akan menggabungkan fitur yang diminta dari beberapa penggabung menjadi satu. nilai StandardMetricsInputs bersama yang diteruskan ke semua penggabung (penggabung bertanggung jawab untuk membaca fitur yang mereka minati dan mengabaikan sisanya).

Contoh

Berikut ini adalah contoh yang sangat sederhana dari definisi metrik TFMA untuk menghitung SampleCount:

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],
          preprocessors=[_ExampleCountPreprocessor()],
          combiner=_ExampleCountCombiner(key))
  ]


class ExampleCountTest(tfma.test.testutil.TensorflowModelAnalysisTest):

  def testExampleCount(self):
    metric = ExampleCount()
    computations = metric.computations(example_weighted=False)
    computation = computations[0]

    with beam.Pipeline() as pipeline:
      result = (
          pipeline
          | 'Create' >> beam.Create([...])  # Add inputs
          | 'PreProcess' >> beam.ParDo(computation.preprocessors[0])
          | 'Process' >> beam.Map(tfma.metrics.to_standard_metric_inputs)
          | 'AddSlice' >> beam.Map(lambda x: ((), x))
          | 'ComputeMetric' >> beam.CombinePerKey(computation.combiner)
      )

      def check_result(got):
        try:
          self.assertLen(got, 1)
          got_slice_key, got_metrics = got[0]
          self.assertEqual(got_slice_key, ())
          key = computation.keys[0]
          self.assertIn(key, got_metrics)
          self.assertAlmostEqual(got_metrics[key], expected_value, places=5)
        except AssertionError as err:
          raise util.BeamAssertException(err)

      util.assert_that(result, check_result, label='result')

class _ExampleCountPreprocessor(beam.DoFn):

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


class _ExampleCountPreprocessorTest(unittest.TestCase):

  def testExampleCountPreprocessor(self):
    ...  # Init the test case here
    with beam.Pipeline() as pipeline:
      updated_pcoll = (
          pipeline
          | 'Create' >> beam.Create([...])  # Add inputs
          | 'Preprocess'
          >> beam.ParDo(
              _ExampleCountPreprocessor()
          )
      )

      beam_testing_util.assert_that(
          updated_pcoll,
          lambda result: ...,  # Assert the test case
      )


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

DerivedMetricComputation terdiri dari fungsi hasil yang digunakan untuk menghitung nilai metrik berdasarkan output perhitungan metrik lainnya. Fungsi hasil mengambil satu dikt nilai yang dihitung sebagai masukannya dan mengeluarkan satu dikt hasil metrik tambahan.

Perhatikan bahwa dapat diterima (disarankan) untuk menyertakan penghitungan yang bergantung pada penghitungan turunan dalam daftar penghitungan yang dibuat oleh metrik. Hal ini menghindari keharusan membuat terlebih dahulu dan meneruskan komputasi yang dibagi antara beberapa metrik. Evaluator akan secara otomatis menghapus duplikasi perhitungan yang memiliki definisi yang sama sehingga hanya satu perhitungan yang benar-benar dijalankan.

Contoh

Metrik TJUR memberikan contoh yang baik tentang metrik turunan.