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 propertivalue
,lower_bound
, danupper_bound
. -
value_at_cutoffs
- Nilai pada cutoffs (misalnya presisi@K, recall@K). Memilikivalues
property, yang masing-masing memiliki sifatcutoff
danvalue
. - Confusion_matrix_at_thresholds - Matriks
confusion_matrix_at_thresholds
di ambang batas. Memilikimatrices
properti, yang masing-masing memiliki properti untuk nilaithreshold
,precision
,recall
, dan matriks kebingungan sepertifalse_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.