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/multi-label 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 rata-rata mikro, rata-rata makro 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 propertivalue
,lower_bound
, danupper_bound
. -
value_at_cutoffs
- Nilai pada titik potong (misalnya presisi@K, recall@K). Memiliki propertivalues
yang masing-masing memiliki properticutoff
danvalue
. -
confusion_matrix_at_thresholds
- Matriks kebingungan di ambang batas. Memiliki propertimatrices
yang masing-masing memiliki properti untuk nilai matriksthreshold
,precision
,recall
, dan matriks konfusi sepertifalse_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 subkunci (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.