ภาพรวม
TFMA รองรับเมตริกและพล็อตต่อไปนี้:
- เมตริก keras มาตรฐาน (
tf.keras.metrics.*
)- โปรดทราบว่าคุณไม่จำเป็นต้องมีโมเดล keras เพื่อใช้เมตริก keras ระบบจะคำนวณเมตริกนอกกราฟในลำแสงโดยใช้คลาสเมตริกโดยตรง
เมตริกและแปลง TFMA มาตรฐาน (
tfma.metrics.*
)เมตริก keras ที่กำหนดเอง (เมตริกที่ได้มาจาก
tf.keras.metrics.Metric
)เมตริก TFMA แบบกำหนดเอง (เมตริกที่ได้มาจาก
tfma.metrics.Metric
) โดยใช้ตัวรวมลำแสงแบบกำหนดเองหรือเมตริกที่ได้มาจากเมตริกอื่นๆ)
TFMA ยังให้การสนับสนุนในตัวสำหรับการแปลงเมตริกการจำแนกประเภทไบนารีสำหรับใช้กับปัญหาหลายคลาส/หลายป้ายกำกับ:
- ไบนาไรเซชันตามคลาส ID, K อันดับต้น ๆ เป็นต้น
- เมตริกรวมอิงตามค่าเฉลี่ยระดับไมโคร ค่าเฉลี่ยระดับมหภาค ฯลฯ
TFMA ยังให้การสนับสนุนในตัวสำหรับเมตริกตามการสืบค้น/การจัดอันดับ โดยที่ตัวอย่างจะถูกจัดกลุ่มตามคีย์การสืบค้นโดยอัตโนมัติในไปป์ไลน์
เมื่อรวมกันแล้วมีเมตริกและพล็อตมาตรฐานมากกว่า 50 รายการสำหรับปัญหาต่างๆ รวมถึงการถดถอย การจำแนกไบนารี การจำแนกหลายคลาส/หลายป้ายกำกับ การจัดอันดับ ฯลฯ
การกำหนดค่า
มีสองวิธีในการกำหนดค่าเมตริกใน TFMA: (1) โดยใช้ tfma.MetricsSpec
หรือ (2) โดยการสร้างอินสแตนซ์ของ tf.keras.metrics.*
และ/หรือ tfma.metrics.*
ใน python และใช้ tfma.metrics.specs_from_metrics
เพื่อแปลงเป็นรายการ tfma.MetricsSpec
ส่วนต่อไปนี้จะอธิบายตัวอย่างการกำหนดค่าสำหรับปัญหาการเรียนรู้ของเครื่องประเภทต่างๆ
เมตริกการถดถอย
ต่อไปนี้เป็นตัวอย่างการตั้งค่าสำหรับปัญหาการถดถอย ดู tf.keras.metrics.*
และ tfma.metrics.*
สำหรับเมตริกเพิ่มเติมที่รองรับ
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
การตั้งค่าเดียวกันนี้สามารถสร้างได้โดยใช้รหัสหลามต่อไปนี้:
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)
โปรดทราบว่าการตั้งค่านี้ยังใช้ได้โดยการเรียก tfma.metrics.default_regression_specs
เมตริกการจำแนกประเภทไบนารี
ต่อไปนี้เป็นตัวอย่างการตั้งค่าสำหรับปัญหาการจัดประเภทไบนารี ดู tf.keras.metrics.*
และ tfma.metrics.*
สำหรับเมตริกเพิ่มเติมที่รองรับ
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
การตั้งค่าเดียวกันนี้สามารถสร้างได้โดยใช้รหัสหลามต่อไปนี้:
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)
โปรดทราบว่าการตั้งค่านี้ยังใช้ได้โดยการเรียก tfma.metrics.default_binary_classification_specs
เมตริกการจำแนกประเภทหลายชั้น/หลายป้าย
ต่อไปนี้คือตัวอย่างการตั้งค่าคอนฟิกูเรชันสำหรับปัญหาการจัดประเภทแบบหลายคลาส ดู tf.keras.metrics.*
และ tfma.metrics.*
สำหรับเมตริกเพิ่มเติมที่รองรับ
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
การตั้งค่าเดียวกันนี้สามารถสร้างได้โดยใช้รหัสหลามต่อไปนี้:
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)
โปรดทราบว่าการตั้งค่านี้ยังใช้ได้โดยการเรียก tfma.metrics.default_multi_class_classification_specs
เมตริกไบนาริซแบบหลายคลาส/หลายป้ายกำกับ
เมตริกหลายคลาส/หลายป้ายกำกับสามารถแปลงเป็นไบนารีเพื่อสร้างเมตริกต่อคลาส ต่อ top_k ฯลฯ โดยใช้ tfma.BinarizationOptions
ตัวอย่างเช่น:
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
การตั้งค่าเดียวกันนี้สามารถสร้างได้โดยใช้รหัสหลามต่อไปนี้:
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]}))
เมตริกรวมหลายคลาส/หลายป้ายกำกับ
สามารถรวมเมตริกหลายคลาส/หลายป้ายกำกับเพื่อสร้างค่ารวมเดียวสำหรับเมตริกการจำแนกประเภทไบนารีได้โดยใช้ tfma.AggregationOptions
โปรดทราบว่าการตั้งค่าการรวมจะไม่ขึ้นอยู่กับการตั้งค่าไบนารี ดังนั้นคุณจึงสามารถใช้ทั้ง tfma.AggregationOptions
และ tfma.BinarizationOptions
ได้พร้อมกัน
ค่าเฉลี่ยไมโคร
การหาค่าเฉลี่ยระดับไมโครสามารถทำได้โดยใช้ตัวเลือก micro_average
ภายใน tfma.AggregationOptions
ตัวอย่างเช่น:
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
การตั้งค่าเดียวกันนี้สามารถสร้างได้โดยใช้รหัสหลามต่อไปนี้:
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
ที่ใช้เฉพาะค่า k อันดับสูงสุดในการคำนวณ ตัวอย่างเช่น:
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
การตั้งค่าเดียวกันนี้สามารถสร้างได้โดยใช้รหัสหลามต่อไปนี้:
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]}))
มาโคร / ค่าเฉลี่ยมาโครถ่วงน้ำหนัก
การหาค่าเฉลี่ยมาโครสามารถทำได้โดยใช้ตัวเลือก macro_average
หรือ weighted_macro_average
ภายใน tfma.AggregationOptions
เว้นแต่จะใช้การตั้งค่า top_k
มาโครจำเป็นต้องตั้งค่า class_weights
เพื่อให้ทราบว่าจะคำนวณค่าเฉลี่ยสำหรับคลาสใด หากไม่ได้ระบุ class_weight
จะถือว่า 0.0 ตัวอย่างเช่น:
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
การตั้งค่าเดียวกันนี้สามารถสร้างได้โดยใช้รหัสหลามต่อไปนี้:
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)}))
เช่นเดียวกับการหาค่าเฉลี่ยแบบไมโคร การหาค่าเฉลี่ยแบบมาโครยังรองรับการตั้งค่า top_k
ซึ่งจะใช้เฉพาะค่า k สูงสุดในการคำนวณ ตัวอย่างเช่น:
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
การตั้งค่าเดียวกันนี้สามารถสร้างได้โดยใช้รหัสหลามต่อไปนี้:
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]}))
แบบสอบถาม / เมตริกตามการจัดอันดับ
เปิดใช้งานเมตริกตามการค้นหา/การจัดอันดับโดยระบุตัวเลือก query_key
ในข้อมูลจำเพาะของเมตริก ตัวอย่างเช่น:
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
การตั้งค่าเดียวกันนี้สามารถสร้างได้โดยใช้รหัสหลามต่อไปนี้:
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')
เมตริกการประเมินหลายรุ่น
TFMA รองรับการประเมินหลายรูปแบบในเวลาเดียวกัน เมื่อทำการประเมินหลายรุ่น จะมีการคำนวณเมตริกสำหรับแต่ละรุ่น ตัวอย่างเช่น:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
# no model_names means all models
...
}
""", tfma.EvalConfig()).metrics_specs
หากจำเป็นต้องคำนวณเมตริกสำหรับชุดย่อยของโมเดล ให้ตั้งค่า model_names
ใน metric_specs
ตัวอย่างเช่น:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
model_names: ["my-model1"]
...
}
""", tfma.EvalConfig()).metrics_specs
specs_from_metrics
API ยังรองรับการส่งผ่านชื่อรุ่น:
metrics = [
...
]
metrics_specs = tfma.metrics.specs_from_metrics(
metrics, model_names=['my-model1'])
เมตริกการเปรียบเทียบรุ่น
TFMA รองรับการประเมินเมตริกเปรียบเทียบสำหรับโมเดลที่พิจารณาเทียบกับโมเดลพื้นฐาน วิธีง่ายๆ ในการตั้งค่าตัวเลือกตัวเลือกและคู่โมเดลพื้นฐานคือการส่งต่อ eval_shared_model ด้วยชื่อโมเดลที่เหมาะสม (tfma.BASELINE_KEY และ 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")
เมตริกเปรียบเทียบจะคำนวณโดยอัตโนมัติสำหรับเมตริกที่แยกความแตกต่างได้ทั้งหมด (ปัจจุบันมีเพียงเมตริกค่าสเกลาร์ เช่น ความแม่นยำ และ AUC)
เมตริกโมเดลหลายเอาต์พุต
TFMA รองรับการประเมินเมตริกบนโมเดลที่มีเอาต์พุตต่างกัน โมเดลหลายเอาต์พุตจัดเก็บการคาดคะเนเอาต์พุตในรูปแบบของ Dict ที่ป้อนชื่อเอาต์พุต เมื่อใช้โมเดลหลายเอาต์พุต ชื่อของเอาต์พุตที่เกี่ยวข้องกับชุดของเมตริกจะต้องระบุในส่วน output_names
ของ MetricsSpec ตัวอย่างเช่น:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
output_names: ["my-output"]
...
}
""", tfma.EvalConfig()).metrics_specs
specs_from_metrics
API ยังรองรับการส่งผ่านชื่อเอาต์พุต:
metrics = [
...
]
metrics_specs = tfma.metrics.specs_from_metrics(
metrics, output_names=['my-output'])
ปรับแต่งการตั้งค่าเมตริก
TFMA อนุญาตให้ปรับแต่งการตั้งค่าที่ใช้กับเมตริกต่างๆ ตัวอย่างเช่น คุณอาจต้องการเปลี่ยนชื่อ ตั้งค่าเกณฑ์ เป็นต้น ซึ่งทำได้โดยการเพิ่มส่วนการกำหนด config
ให้กับการกำหนดค่าเมตริก มีการระบุการกำหนดค่าโดยใช้พารามิเตอร์เวอร์ชันสตริง JSON ที่จะส่งผ่านไปยังเมธอด __init__
ของเมตริก (เพื่อความสะดวกในการใช้งาน อาจละวงเล็บ '{' และ '}' นำหน้าและต่อท้าย) ตัวอย่างเช่น:
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
แน่นอนว่าการปรับแต่งนี้ได้รับการสนับสนุนโดยตรงเช่นกัน:
metrics = [
tfma.metrics.ConfusionMatrixAtThresholds(thresholds=[0.3, 0.5, 0.8]),
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)
ผลลัพธ์
ผลลัพธ์ของการประเมินเมตริกคือชุดของคีย์/ค่าเมตริก และ/หรือพล็อตคีย์/ค่าตามการกำหนดค่าที่ใช้
คีย์เมตริก
MetricKeys ถูกกำหนดโดยใช้ประเภทคีย์ที่มีโครงสร้าง คีย์นี้ระบุแต่ละด้านของเมตริกโดยไม่ซ้ำกัน:
- ชื่อตัวชี้วัด (
mean_label
auc
) - ชื่อรุ่น (ใช้เฉพาะเมื่อประเมินหลายรุ่น)
- ชื่อเอาต์พุต (ใช้เฉพาะเมื่อมีการประเมินโมเดลหลายเอาต์พุต)
- คีย์ย่อย (เช่น ID คลาส หากโมเดลหลายคลาสเป็นแบบไบนารี)
ค่าเมตริก
MetricValues ถูกกำหนดโดยใช้โปรโตที่สรุปประเภทค่าต่างๆ ที่สนับสนุนโดยเมตริกต่างๆ (เช่น double
, ConfusionMatrixAtThresholds
เป็นต้น)
ด้านล่างนี้คือประเภทค่าเมตริกที่รองรับ:
-
double_value
- เสื้อคลุมสำหรับประเภทคู่ -
bytes_value
- ค่าไบต์ -
bounded_value
- แสดงถึงมูลค่าจริงซึ่งอาจเป็นค่าประมาณแบบจุด โดยสามารถเลือกใช้ขอบเขตโดยประมาณบางประเภทได้ มีvalue
คุณสมบัติ ,lower_bound
และupper_bound
-
value_at_cutoffs
- มูลค่าที่จุดตัด (เช่น ความแม่นยำ@K, การเรียกคืน@K) มีvalues
คุณสมบัติ ซึ่งแต่ละค่ามีคุณสมบัติทางcutoff
และvalue
- Confusion_matrix_at_thresholds - เมทริกซ์ความ
confusion_matrix_at_thresholds
ที่เกณฑ์ มีเมทริกซ์คุณสมบัติ ซึ่งแต่ละmatrices
มีคุณสมบัติสำหรับthreshold
precision
การrecall
และค่าเมทริกซ์ความสับสน เช่นfalse_negatives
-
array_value
- สำหรับเมตริกที่ส่งคืนอาร์เรย์ของค่า
พล็อตคีย์
PlotKeys คล้ายกับเมตริกคีย์ ยกเว้นว่าด้วยเหตุผลทางประวัติศาสตร์ ค่าการพล็อตทั้งหมดจะถูกจัดเก็บไว้ในโปรโตเดียว ดังนั้นคีย์พล็อตจึงไม่มีชื่อ
ค่าพล็อต
พล็อตที่รองรับทั้งหมดจะถูกจัดเก็บไว้ในโปรโตเดียวที่เรียกว่า PlotData
EvalResult
ผลตอบแทนจากการเรียกใช้การประเมินคือ tfma.EvalResult
เร็กคอร์ดนี้มี slicing_metrics
ที่เข้ารหัสคีย์เมตริกเป็นคำสั่งหลายระดับ โดยที่ระดับต่างๆ สอดคล้องกับชื่อเอาต์พุต, ID คลาส, ชื่อเมตริก และค่าเมตริกตามลำดับ สิ่งนี้มีวัตถุประสงค์เพื่อใช้สำหรับการแสดง UI ในโน้ตบุ๊ก Jupiter หากจำเป็นต้องเข้าถึงข้อมูลพื้นฐาน ควรใช้ไฟล์ผลลัพธ์ metrics
แทน (ดู ที่ metrics_for_slice.proto )
การปรับแต่ง
นอกเหนือจากเมตริกแบบกำหนดเองที่เพิ่มเป็นส่วนหนึ่งของ keras ที่บันทึกไว้ (หรือ EvalSavedModel เดิม) มีสองวิธีในการปรับแต่งเมตริกในการบันทึกภายหลัง TFMA: (1) โดยการกำหนดคลาสเมตริก keras ที่กำหนดเองและ (2) โดยการกำหนดคลาสเมตริก TFMA ที่กำหนดเองซึ่งสนับสนุนโดยตัวรวมคาน
ในทั้งสองกรณี เมทริกได้รับการกำหนดค่าโดยการระบุชื่อของคลาสเมทริกและโมดูลที่เกี่ยวข้อง ตัวอย่างเช่น:
from google.protobuf import text_format
metrics_specs = text_format.Parse("""
metrics_specs {
metrics { class_name: "MyMetric" module: "my.module"}
}
""", tfma.EvalConfig()).metrics_specs
เมตริก Keras แบบกำหนดเอง
ในการสร้างเมตริก keras ที่กำหนดเอง ผู้ใช้จำเป็นต้องขยาย tf.keras.metrics.Metric
ด้วยการนำไปใช้ จากนั้นตรวจสอบให้แน่ใจว่าโมดูลของเมตริกพร้อมใช้งานในเวลาประเมิน
โปรดทราบว่าสำหรับเมตริกที่เพิ่มการบันทึกโมเดลโพสต์ TFMA รองรับเฉพาะเมตริกที่ใช้ป้ายกำกับ (เช่น y_true) การคาดคะเน (y_pred) และน้ำหนักตัวอย่าง (sample_weight) เป็นพารามิเตอร์สำหรับเมธอด update_state
ตัวอย่างเมตริก Keras
ต่อไปนี้เป็นตัวอย่างเมตริก keras ที่กำหนดเอง:
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)
เมตริก TFMA แบบกำหนดเอง
ในการสร้างเมตริก TFMA แบบกำหนดเอง ผู้ใช้ต้องขยาย tfma.metrics.Metric
ด้วยการนำไปใช้ จากนั้นตรวจสอบให้แน่ใจว่าโมดูลของเมตริกพร้อมใช้งานในเวลาประเมิน
เมตริก
การใช้งาน tfma.metrics.Metric
ประกอบด้วยชุด kwargs ที่กำหนดการกำหนดค่าเมตริกพร้อมกับฟังก์ชันสำหรับสร้างการคำนวณ (อาจเป็นหลายรายการ) ที่จำเป็นในการคำนวณค่าเมตริก มีสองประเภทการคำนวณหลักที่สามารถใช้ได้: tfma.metrics.MetricComputation
และ tfma.metrics.DerivedMetricComputation
ที่อธิบายไว้ในส่วนด้านล่าง ฟังก์ชันที่สร้างการคำนวณเหล่านี้จะถูกส่งผ่านพารามิเตอร์ต่อไปนี้เป็นอินพุต:
-
eval_config: tfam.EvalConfig
- การกำหนดค่า eval ส่งผ่านไปยังผู้ประเมิน (มีประโยชน์สำหรับการค้นหาการตั้งค่าข้อมูลจำเพาะของโมเดล เช่น คีย์การคาดคะเนที่จะใช้ เป็นต้น)
-
model_names: List[Text]
- รายชื่อรุ่นที่จะคำนวณเมตริกสำหรับ (ไม่มีถ้าเป็นรุ่นเดียว)
-
output_names: List[Text]
- รายการชื่อเอาต์พุตเพื่อคำนวณเมตริกสำหรับ (ไม่มีหากเป็นรุ่นเดียว)
-
sub_keys: List[tfma.SubKey]
- รายการคีย์ย่อย (รหัสคลาส, K อันดับต้น ฯลฯ) เพื่อคำนวณเมตริกสำหรับ (หรือไม่มี)
-
aggregation_type: tfma.AggregationType
- ประเภทของการรวมหากคำนวณเมตริกการรวม
-
class_weights: Dict[int, float]
.- น้ำหนักของคลาสที่จะใช้หากคำนวณเมตริกการรวม
-
query_key: Text
- คีย์ข้อความค้นหาที่ใช้เมื่อคำนวณเมตริกตามข้อความค้นหา/การจัดอันดับ
หากเมตริกไม่เชื่อมโยงกับการตั้งค่าเหล่านี้ตั้งแต่หนึ่งรายการขึ้นไป ระบบอาจละพารามิเตอร์เหล่านั้นออกจากการกำหนดลายเซ็น
หากเมตริกคำนวณด้วยวิธีเดียวกันสำหรับแต่ละรุ่น เอาต์พุต และคีย์ย่อย คุณสามารถใช้ยูทิลิตี tfma.metrics.merge_per_key_computations
เพื่อดำเนินการคำนวณเดียวกันสำหรับแต่ละอินพุตเหล่านี้แยกกันได้
การคำนวณเมตริก
MetricComputation
ประกอบด้วย preprocessors
และตัว combiner
preprocessors
คือรายการของ preprocessor
ซึ่งเป็น beam.DoFn
ที่รับการแตกข้อมูลเป็นอินพุตและเอาต์พุตสถานะเริ่มต้นที่ตัวรวมจะใช้ (ดู สถาปัตยกรรม สำหรับข้อมูลเพิ่มเติมเกี่ยวกับสิ่งที่แยก) ตัวประมวลผลล่วงหน้าทั้งหมดจะถูกดำเนินการตามลำดับของรายการ หากตัว preprocessors
ว่างเปล่า ตัวรวมจะถูกส่งผ่าน StandardMetricInputs (อินพุตเมตริกมาตรฐานประกอบด้วยป้ายกำกับ การคาดคะเน และ example_weights) combiner
คือ beam.CombineFn
ที่รับทูเพิลของ (คีย์สไลซ์, เอาต์พุตตัวประมวลผลล่วงหน้า) เป็นอินพุตและเอาต์พุตทูเพิลของ (slice_key, dict ผลลัพธ์เมตริก) เป็นผลลัพธ์
โปรดทราบว่าการแบ่งส่วนเกิดขึ้นระหว่างตัว preprocessors
และตัว combiner
โปรดทราบว่าหากการคำนวณแบบเมตริกต้องการใช้ทั้งอินพุตเมตริกมาตรฐาน แต่เพิ่มคุณลักษณะบางอย่างจาก features
ที่แยกออกมา คุณสามารถใช้ FeaturePreprocessor แบบพิเศษซึ่งจะรวมคุณลักษณะที่ร้องขอจากตัวรวมหลายตัวเข้าเป็นตัวเดียว ค่า StandardMetricsInputs ที่ใช้ร่วมกันซึ่งส่งผ่านไปยังตัวรวมทั้งหมด (ตัวรวมมีหน้าที่ในการอ่านคุณสมบัติที่พวกเขาสนใจและไม่สนใจส่วนที่เหลือ)
ตัวอย่าง
ต่อไปนี้คือตัวอย่างง่ายๆ ของคำจำกัดความเมตริก TFMA สำหรับการคำนวณ 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
ประกอบด้วยฟังก์ชันผลลัพธ์ที่ใช้ในการคำนวณค่าเมตริกตามผลลัพธ์ของการคำนวณเมตริกอื่นๆ ฟังก์ชันผลลัพธ์ใช้คำสั่งของค่าที่คำนวณเป็นอินพุตและเอาต์พุตเป็นคำสั่งของผลลัพธ์เมตริกเพิ่มเติม
โปรดทราบว่าเป็นที่ยอมรับ (แนะนำ) ให้รวมการคำนวณที่การคำนวณที่ได้รับขึ้นอยู่กับรายการการคำนวณที่สร้างโดยเมตริก เพื่อหลีกเลี่ยงการสร้างล่วงหน้าและผ่านการคำนวณที่ใช้ร่วมกันระหว่างเมตริกต่างๆ ผู้ประเมินจะขจัดข้อมูลซ้ำของการคำนวณที่มีคำจำกัดความเดียวกันโดยอัตโนมัติ เพื่อให้มีการประมวลผลจริงเพียงรายการเดียว
ตัวอย่าง
เมตริก TJUR เป็นตัวอย่างที่ดีของเมตริกที่ได้รับมา