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 berkas menggunakan kelas metrik secara langsung.
Metrik dan plot TFMA standar ( tfma.metrics.* )
Metrik keras khusus (metrik diturunkan dari tf.keras.metrics.Metric )
Metrik TFMA khusus (metrik yang diturunkan dari tfma.metrics.Metric ) menggunakan penggabung balok khusus atau metrik yang diturunkan dari metrik lain).

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

Binarisasi berdasarkan class ID, top K, 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 mengonfigurasi metrik di TFMA: (1) menggunakan tfma.MetricsSpec atau (2) dengan membuat instance tf.keras.metrics.* dan/atau tfma.metrics.* di python dan menggunakan tfma.metrics.specs_from_metrics untuk mengubahnya 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 tf.keras.metrics.* dan tfma.metrics.* untuk kemungkinan metrik tambahan yang 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 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 tf.keras.metrics.* dan tfma.metrics.* untuk kemungkinan metrik tambahan yang 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 penyiapan ini juga tersedia dengan memanggil tfma.metrics.default_binary_classification_specs .

Metrik Klasifikasi Multi-kelas/Multi-label

Berikut ini adalah contoh pengaturan konfigurasi untuk masalah klasifikasi multi-kelas. Lihat tf.keras.metrics.* dan tfma.metrics.* untuk kemungkinan metrik tambahan yang 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 penyiapan ini juga tersedia dengan memanggil tfma.metrics.default_multi_class_classification_specs .

Metrik Biner Multi-kelas/Multi-label

Metrik multi-kelas/multi-label dapat dibinerisasi 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 digabungkan untuk menghasilkan satu nilai gabungan 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 di 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))

Rata-rata mikro juga mendukung pengaturan top_k di mana hanya nilai top k yang 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

Rata-rata makro dapat dilakukan dengan menggunakan opsi macro_average atau weighted_macro_average di dalam tfma.AggregationOptions . Kecuali pengaturan top_k digunakan, makro memerlukan pengaturan class_weights untuk mengetahui kelas mana yang akan dihitung rata-ratanya. Jika class_weight tidak disediakan maka diasumsikan 0,0. 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 rata-rata mikro, rata-rata makro juga mendukung pengaturan top_k di mana hanya nilai k teratas yang 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

Metrik berbasis kueri/peringkat diaktifkan dengan menentukan opsi query_key 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 Multimodel

TFMA mendukung evaluasi beberapa model sekaligus. 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 perlu dihitung untuk subkumpulan model, setel 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

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 baseline. Cara sederhana untuk menyiapkan kandidat dan pasangan model dasar adalah dengan meneruskan eval_shared_model dengan nama model yang sesuai (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 yang dapat dibedakan (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 model multi-output digunakan, nama output yang terkait dengan kumpulan metrik harus ditentukan di bagian output_names 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

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 yang berbeda. Misalnya Anda mungkin ingin mengubah nama, menetapkan ambang batas, dll. 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). 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 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

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

Kunci Metrik

MetricKey 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 output (hanya digunakan jika model multi-output dievaluasi)
Subkunci (misalnya ID kelas jika model multi-kelas di-binarisasi)

Nilai Metrik

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

Di bawah ini adalah jenis nilai metrik yang didukung:

double_value - Pembungkus untuk tipe ganda.
bytes_value - Nilai byte.
bounded_value - Mewakili nilai nyata yang bisa menjadi perkiraan titik, opsional dengan semacam batas perkiraan. Memiliki properti value , lower_bound , dan upper_bound .
value_at_cutoffs - Nilai pada cutoffs (misalnya presisi@K, recall@K). Memiliki values property, yang masing-masing memiliki sifat cutoff dan value .
Confusion_matrix_at_thresholds - Matriks confusion_matrix_at_thresholds di ambang batas. Memiliki matrices properti, yang masing-masing memiliki properti untuk nilai threshold , precision , recall , dan matriks kebingungan seperti false_negatives .
array_value - Untuk metrik yang mengembalikan array nilai.

Kunci Plot

PlotKey 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

Pengembalian dari proses evaluasi adalah tfma.EvalResult . Catatan ini berisi slicing_metrics yang menyandikan kunci metrik sebagai dict multi-tingkat di mana level masing-masing sesuai dengan nama keluaran, 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 sebagai gantinya (lihat metrics_for_slice.proto ).

Kustomisasi

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

Dalam kedua kasus, metrik dikonfigurasikan 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 Khusus

Untuk membuat metrik keras khusus, pengguna perlu memperluas tf.keras.metrics.Metric dengan penerapannya dan kemudian memastikan modul metrik tersedia pada waktu evaluasi.

Perhatikan bahwa untuk metrik yang ditambahkan penyimpanan model pos, TFMA hanya mendukung metrik yang mengambil label (yaitu y_true), prediksi (y_pred), dan bobot contoh (sample_weight) sebagai parameter ke 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 Kustom

Untuk membuat metrik TFMA khusus, pengguna perlu memperluas tfma.metrics.Metric dengan penerapannya, 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 perhitungan (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 ini. Fungsi yang membuat komputasi ini akan meneruskan 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 subkunci (ID kelas, K atas, 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 untuk digunakan jika menghitung metrik agregasi.
query_key: Text
- Kunci kueri digunakan jika menghitung metrik berbasis kueri/peringkat.

Jika metrik tidak dikaitkan dengan satu atau beberapa setelan ini, metrik tersebut dapat meninggalkan parameter tersebut dari definisi tanda tangannya.

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

Perhitungan Metrik

MetricComputation terdiri dari kombinasi preprocessors dan combiner . preprocessors adalah daftar preprocessor , yang merupakan beam.DoFn yang mengambil ekstrak sebagai inputnya dan menampilkan keadaan awal yang akan digunakan oleh penggabung (lihat arsitektur untuk info lebih lanjut tentang apa itu ekstrak). Semua preprosesor akan dieksekusi secara berurutan sesuai urutan daftar. Jika preprocessors kosong, penggabung akan diteruskan StandardMetricInputs (input metrik standar berisi label, prediksi, dan bobot_contoh). combiner adalah beam.CombineFn yang mengambil tuple (kunci slice, output preprosesor) sebagai inputnya dan mengeluarkan tuple (slice_key, hasil metrik dict) sebagai hasilnya.

Perhatikan bahwa pemotongan terjadi antara preprocessors dan combiner .

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

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],
          preprocessors=[_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}

DerivedMetricComputation

DerivedMetricComputation terdiri dari fungsi hasil yang digunakan untuk menghitung nilai metrik berdasarkan keluaran perhitungan metrik lainnya. Fungsi result 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 antara beberapa metrik. Evaluator akan secara otomatis men-de-dup komputasi yang memiliki definisi yang sama sehingga hanya satu komputasi yang benar-benar dijalankan.

Contoh

Metrik TJUR memberikan contoh yang baik dari metrik turunan.