เมตริกและพล็อตการวิเคราะห์โมเดล 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 มาโครจำเป็นต้องตั้งค่า class_weights เว้นแต่ว่าจะใช้การตั้งค่า top_k เพื่อทราบว่าจะต้องคำนวณค่าเฉลี่ยของคลาสใด หากไม่ได้ระบุ 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 ถูกกำหนดโดยใช้ประเภทคีย์ที่มีโครงสร้าง คีย์นี้จะระบุแต่ละแง่มุมของเมตริกโดยไม่ซ้ำกัน:

  • ชื่อตัวชี้วัด ( auc , mean_label ฯลฯ )
  • ชื่อรุ่น (ใช้เฉพาะในกรณีที่การประเมินหลายรุ่น)
  • ชื่อเอาต์พุต (ใช้เฉพาะเมื่อมีการประเมินโมเดลหลายเอาต์พุต)
  • คีย์ย่อย (เช่น ID คลาส หากโมเดลหลายคลาสถูกไบนาไรซ์)

ค่าเมตริก

MetricValues ​​ถูกกำหนดโดยใช้โปรโตที่สรุปประเภทค่าต่างๆ ที่เมตริกต่างๆ รองรับ (เช่น double , ConfusionMatrixAtThresholds ฯลฯ)

ด้านล่างนี้คือประเภทค่าเมตริกที่รองรับ:

  • double_value - กระดาษห่อสำหรับประเภทคู่
  • bytes_value - ค่าไบต์
  • bounded_value - แสดงถึงมูลค่าจริงซึ่งอาจเป็นการประมาณการแบบจุด หรือมีขอบเขตโดยประมาณบางประเภทหรือไม่ก็ได้ มี value คุณสมบัติ , lower_bound และ upper_bound
  • value_at_cutoffs - ค่าที่จุดตัด (เช่น precision@K,call@K) มี values คุณสมบัติ ซึ่งแต่ละค่ามีคุณสมบัติ cutoff และ value
  • confusion_matrix_at_thresholds - เมทริกซ์ความสับสนที่เกณฑ์ มี matrices ซึ่งแต่ละรายการมีคุณสมบัติสำหรับค่าเมทริกซ์ threshold precision recall และความสับสน เช่น false_negatives
  • array_value - สำหรับหน่วยเมตริกที่ส่งคืนอาร์เรย์ของค่า

พล็อตคีย์

PlotKeys คล้ายกับคีย์เมตริก ยกเว้นว่าด้วยเหตุผลทางประวัติศาสตร์ ค่าของพล็อตทั้งหมดจะถูกเก็บไว้ในโปรโตเดียว ดังนั้นคีย์พล็อตจึงไม่มีชื่อ

ค่าพล็อต

แปลงที่รองรับทั้งหมดจะถูกเก็บไว้ในโปรโตเดียวที่เรียกว่า PlotData

ผลการประเมิน

การส่งคืนจากการรันการประเมินคือ tfma.EvalResult เรกคอร์ดนี้มี slicing_metrics ที่เข้ารหัสคีย์เมทริกเป็น dict หลายระดับ โดยที่ระดับสอดคล้องกับชื่อเอาต์พุต 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]
    • รายการคีย์ย่อย (ID คลาส, 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 ที่รับ tuple ของ (slice key, เอาต์พุตตัวประมวลผลล่วงหน้า) เป็นอินพุต และเอาต์พุต tuple ของ (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 เป็นตัวอย่างที่ดีของเมทริกที่ได้รับ