เมตริกและพล็อตการวิเคราะห์โมเดล Tensorflow

จัดทุกอย่างให้เป็นระเบียบอยู่เสมอด้วยคอลเล็กชัน บันทึกและจัดหมวดหมู่เนื้อหาตามค่ากำหนดของคุณ

ภาพรวม

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 เป็นตัวอย่างที่ดีของเมตริกที่ได้รับมา