Số liệu và sơ đồ phân tích mô hình Tensorflow

Sử dụng bộ sưu tập để sắp xếp ngăn nắp các trang Lưu và phân loại nội dung dựa trên lựa chọn ưu tiên của bạn.

Tổng quan

TFMA hỗ trợ các số liệu và biểu đồ sau:

  • Số liệu máy ảnh tiêu chuẩn ( tf.keras.metrics.* )
    • Lưu ý rằng bạn không cần mô hình máy ảnh để sử dụng số liệu máy ảnh. Các chỉ số được tính toán bên ngoài biểu đồ trong chùm bằng cách trực tiếp sử dụng các lớp chỉ số.

  • Số liệu và sơ đồ TFMA tiêu chuẩn ( tfma.metrics.* )

  • Số liệu máy ảnh tùy chỉnh (số liệu bắt nguồn từ tf.keras.metrics.Metric )

  • Chỉ số TFMA tùy chỉnh (chỉ số bắt nguồn từ tfma.metrics.Metric ) bằng cách sử dụng bộ kết hợp chùm tia tùy chỉnh hoặc chỉ số bắt nguồn từ các chỉ số khác).

TFMA cũng cung cấp hỗ trợ tích hợp để chuyển đổi các chỉ số phân loại nhị phân để sử dụng với các sự cố đa lớp/đa nhãn:

  • Nhị phân hóa dựa trên ID lớp, K hàng đầu, v.v.
  • Số liệu tổng hợp dựa trên trung bình vi mô, trung bình vĩ mô, v.v.

TFMA cũng cung cấp hỗ trợ tích hợp cho các số liệu dựa trên truy vấn/xếp hạng trong đó các ví dụ được tự động nhóm theo khóa truy vấn trong quy trình.

Kết hợp lại, có hơn 50 số liệu và sơ đồ tiêu chuẩn có sẵn cho nhiều vấn đề khác nhau bao gồm hồi quy, phân loại nhị phân, phân loại nhiều lớp/đa nhãn, xếp hạng, v.v.

Cấu hình

Có hai cách để định cấu hình số liệu trong TFMA: (1) sử dụng tfma.MetricsSpec hoặc (2) bằng cách tạo phiên bản của các tf.keras.metrics.* và/hoặc tfma.metrics.* trong python và sử dụng tfma.metrics.specs_from_metrics để chuyển đổi chúng thành danh sách tfma.MetricsSpec .

Các phần sau đây mô tả các cấu hình ví dụ cho các loại vấn đề học máy khác nhau.

Số liệu hồi quy

Sau đây là một thiết lập cấu hình ví dụ cho một vấn đề hồi quy. Tham khảo các mô-đun tf.keras.metrics.* và tfma.metrics.* để biết các chỉ số bổ sung có thể được hỗ trợ.

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

Thiết lập tương tự này có thể được tạo bằng mã python sau:

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)

Lưu ý rằng thiết lập này cũng có sẵn bằng cách gọi tfma.metrics.default_regression_specs .

Số liệu phân loại nhị phân

Sau đây là một thiết lập cấu hình ví dụ cho một vấn đề phân loại nhị phân. Tham khảo các mô-đun tf.keras.metrics.* và tfma.metrics.* để biết các chỉ số bổ sung có thể được hỗ trợ.

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

Thiết lập tương tự này có thể được tạo bằng mã python sau:

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)

Lưu ý rằng thiết lập này cũng có sẵn bằng cách gọi tfma.metrics.default_binary_classification_specs .

Số liệu phân loại đa lớp/đa nhãn

Sau đây là một thiết lập cấu hình ví dụ cho vấn đề phân loại nhiều lớp. Tham khảo các mô-đun tf.keras.metrics.* và tfma.metrics.* để biết các chỉ số bổ sung có thể được hỗ trợ.

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

Thiết lập tương tự này có thể được tạo bằng mã python sau:

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)

Lưu ý rằng thiết lập này cũng có sẵn bằng cách gọi tfma.metrics.default_multi_class_classification_specs .

Số liệu nhị phân đa lớp/đa nhãn

Số liệu nhiều lớp/nhiều nhãn có thể được nhị phân hóa để tạo số liệu cho mỗi lớp, mỗi top_k, v.v. bằng cách sử dụng tfma.BinarizationOptions . Ví dụ:

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

Thiết lập tương tự này có thể được tạo bằng mã python sau:

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]}))

Số liệu tổng hợp đa lớp/đa nhãn

Có thể tổng hợp các chỉ số nhiều loại/nhiều nhãn để tạo ra một giá trị tổng hợp duy nhất cho chỉ số phân loại nhị phân bằng cách sử dụng tfma.AggregationOptions .

Lưu ý rằng cài đặt tổng hợp độc lập với cài đặt nhị phân, do đó bạn có thể sử dụng cả tfma.AggregationOptions và tfma.BinarizationOptions cùng một lúc.

trung bình vi mô

Tính trung bình vi mô có thể được thực hiện bằng cách sử dụng tùy chọn micro_average trong tfma.AggregationOptions . Ví dụ:

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

Thiết lập tương tự này có thể được tạo bằng mã python sau:

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))

Tính trung bình vi mô cũng hỗ trợ cài đặt top_k trong đó chỉ k giá trị hàng đầu được sử dụng trong tính toán. Ví dụ:

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

Thiết lập tương tự này có thể được tạo bằng mã python sau:

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]}))

Vĩ mô / Trung bình vĩ mô có trọng số

Tính trung bình macro có thể được thực hiện bằng cách sử dụng tùy chọn macro_average hoặc weighted_macro_average trong tfma.AggregationOptions . Trừ khi cài đặt top_k được sử dụng, macro yêu cầu đặt class_weights để biết lớp nào cần tính trung bình. Nếu class_weight không được cung cấp thì 0,0 được giả định. Ví dụ:

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

Thiết lập tương tự này có thể được tạo bằng mã python sau:

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)}))

Giống như tính trung bình vi mô, tính trung bình macro cũng hỗ trợ cài đặt top_k trong đó chỉ các giá trị k hàng đầu được sử dụng trong tính toán. Ví dụ:

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

Thiết lập tương tự này có thể được tạo bằng mã python sau:

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]}))

Số liệu dựa trên truy vấn / xếp hạng

Số liệu dựa trên truy vấn/xếp hạng được bật bằng cách chỉ định tùy chọn query_key trong thông số kỹ thuật của số liệu. Ví dụ:

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

Thiết lập tương tự này có thể được tạo bằng mã python sau:

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')

Số liệu đánh giá đa mô hình

TFMA hỗ trợ đánh giá nhiều mô hình cùng lúc. Khi đánh giá nhiều mô hình được thực hiện, số liệu sẽ được tính toán cho từng mô hình. Ví dụ:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    # no model_names means all models
    ...
  }
""", tfma.EvalConfig()).metrics_specs

Nếu số liệu cần được tính toán cho một tập hợp con các mô hình, hãy đặt model_names trong metric_specs . Ví dụ:

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 cũng hỗ trợ chuyển tên mô hình:

metrics = [
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics, model_names=['my-model1'])

Số liệu so sánh mô hình

TFMA hỗ trợ đánh giá các số liệu so sánh cho một mô hình ứng cử viên so với mô hình cơ sở. Một cách đơn giản để thiết lập cặp mô hình cơ sở và ứng cử viên là chuyển eval_shared_model với tên mô hình phù hợp (tfma.BASELINE_KEY và 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")

Các chỉ số so sánh được tính toán tự động cho tất cả các chỉ số có thể khác biệt (hiện chỉ có các chỉ số giá trị vô hướng như độ chính xác và AUC).

Số liệu mô hình đa đầu ra

TFMA hỗ trợ đánh giá số liệu trên các mô hình có kết quả đầu ra khác nhau. Các mô hình nhiều đầu ra lưu trữ các dự đoán đầu ra của chúng dưới dạng một lệnh chính tả được khóa theo tên đầu ra. Khi sử dụng mô hình nhiều đầu ra, tên của các đầu ra được liên kết với một tập hợp chỉ số phải được chỉ định trong phần output_names của MetricsSpec. Ví dụ:

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 cũng hỗ trợ chuyển tên đầu ra:

metrics = [
    ...
]
metrics_specs = tfma.metrics.specs_from_metrics(
    metrics, output_names=['my-output'])

Tùy chỉnh cài đặt số liệu

TFMA cho phép tùy chỉnh cài đặt được sử dụng với các số liệu khác nhau. Ví dụ: bạn có thể muốn thay đổi tên, đặt ngưỡng, v.v. Điều này được thực hiện bằng cách thêm phần config vào cấu hình số liệu. Cấu hình được chỉ định bằng cách sử dụng phiên bản chuỗi JSON của các tham số sẽ được chuyển đến phương thức __init__ của số liệu (để dễ sử dụng, có thể bỏ qua dấu ngoặc '{' và '}' ở đầu và cuối). Ví dụ:

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

Tất nhiên, tùy chỉnh này cũng được hỗ trợ trực tiếp:

metrics = [
   tfma.metrics.ConfusionMatrixAtThresholds(thresholds=[0.3, 0.5, 0.8]),
]
metrics_specs = tfma.metrics.specs_from_metrics(metrics)

đầu ra

Đầu ra của đánh giá chỉ số là một loạt khóa/giá trị chỉ số và/hoặc biểu đồ khóa/giá trị dựa trên cấu hình được sử dụng.

Phím số liệu

MetricKeys được xác định bằng cách sử dụng loại khóa có cấu trúc. Khóa này xác định duy nhất từng khía cạnh sau đây của số liệu:

  • Tên chỉ số ( auc , mean_label , v.v.)
  • Tên mô hình (chỉ được sử dụng nếu đánh giá nhiều mô hình)
  • Tên đầu ra (chỉ được sử dụng nếu các mô hình nhiều đầu ra được đánh giá)
  • Khóa phụ (ví dụ: ID lớp nếu mô hình nhiều lớp được nhị phân hóa)

Giá trị số liệu

MetricValues ​​được xác định bằng cách sử dụng proto gói gọn các loại giá trị khác nhau được hỗ trợ bởi các số liệu khác nhau (ví dụ: double , ConfusionMatrixAtThresholds , v.v.).

Dưới đây là các loại giá trị chỉ số được hỗ trợ:

  • double_value - Trình bao bọc cho loại kép.
  • bytes_value - Một giá trị byte.
  • bounded_value - Biểu thị giá trị thực có thể là ước tính theo điểm, tùy chọn với giới hạn gần đúng thuộc một số loại. Có thuộc tính value , lower_bound và upper_bound .
  • value_at_cutoffs - Giá trị tại ngưỡng (ví dụ: precision@K, thu hồi@K). Có values thuộc tính, mỗi trong số đó có các thuộc tính cutoff và value .
  • confusion_matrix_at_thresholds lẫn_matrix_at_thresholds - Ma trận nhầm lẫn ở ngưỡng. Có matrices thuộc tính , mỗi ma trận có thuộc tính cho các giá trị ma trận threshold , precision , recall và nhầm lẫn chẳng hạn như false_negatives .
  • array_value - Đối với các chỉ số trả về một mảng giá trị.

Chìa khóa cốt truyện

PlotKeys tương tự như các khóa số liệu ngoại trừ vì lý do lịch sử, tất cả các giá trị của lô được lưu trữ trong một proto duy nhất nên khóa lô không có tên.

Giá trị cốt truyện

Tất cả các ô được hỗ trợ được lưu trữ trong một proto duy nhất có tên là PlotData .

Đánh giá kết quả

Kết quả trả về từ một lần chạy đánh giá là một tfma.EvalResult . Bản ghi này chứa slicing_metrics mã hóa khóa chỉ số dưới dạng chính tả đa cấp trong đó các cấp tương ứng với tên đầu ra, ID lớp, tên chỉ số và giá trị chỉ số. Điều này nhằm mục đích sử dụng để hiển thị giao diện người dùng trong sổ ghi chép Jupiter. Nếu cần truy cập vào dữ liệu cơ bản thì nên sử dụng tệp kết quả metrics thay thế (xem metrics_for_slice.proto ).

tùy biến

Ngoài các số liệu tùy chỉnh được thêm vào như một phần của máy ảnh đã lưu (hoặc EvalSavedModel cũ). Có hai cách để tùy chỉnh số liệu trong lưu bài đăng TFMA: (1) bằng cách xác định lớp số liệu máy ảnh tùy chỉnh và (2) bằng cách xác định lớp số liệu TFMA tùy chỉnh được hỗ trợ bởi bộ kết hợp chùm tia.

Trong cả hai trường hợp, chỉ số được định cấu hình bằng cách chỉ định tên của loại chỉ số và mô-đun được liên kết. Ví dụ:

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    metrics { class_name: "MyMetric" module: "my.module"}
  }
""", tfma.EvalConfig()).metrics_specs

Số liệu máy ảnh tùy chỉnh

Để tạo chỉ số máy ảnh tùy chỉnh, người dùng cần mở rộng tf.keras.metrics.Metric bằng triển khai của họ, sau đó đảm bảo mô-đun của chỉ số khả dụng tại thời điểm đánh giá.

Lưu ý rằng đối với các chỉ số được thêm vào lưu mô hình bài đăng, TFMA chỉ hỗ trợ các chỉ số lấy nhãn (tức là y_true), dự đoán (y_pred) và trọng số mẫu (sample_weight) làm tham số cho phương pháp update_state .

Ví dụ về số liệu máy ảnh

Sau đây là một ví dụ về số liệu máy ảnh tùy chỉnh:

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)

Chỉ số TFMA tùy chỉnh

Để tạo chỉ số TFMA tùy chỉnh, người dùng cần mở rộng tfma.metrics.Metric với triển khai của họ và sau đó đảm bảo mô-đun của chỉ số khả dụng tại thời điểm đánh giá.

Hệ mét

Việc triển khai tfma.metrics.Metric được tạo thành từ một tập hợp các kwargs xác định cấu hình chỉ số cùng với một hàm để tạo các phép tính (có thể là nhiều phép tính) cần thiết để tính giá trị chỉ số. Có hai loại tính toán chính có thể được sử dụng: tfma.metrics.MetricComputation và tfma.metrics.DerivedMetricComputation được mô tả trong các phần bên dưới. Hàm tạo ra các tính toán này sẽ được truyền các tham số sau làm đầu vào:

  • eval_config: tfam.EvalConfig
    • Cấu hình eval được chuyển đến người đánh giá (hữu ích để tra cứu các cài đặt thông số kỹ thuật của mô hình, chẳng hạn như khóa dự đoán sẽ sử dụng, v.v.).
  • model_names: List[Text]
    • Danh sách tên mô hình để tính toán số liệu cho (Không có nếu mô hình đơn lẻ)
  • output_names: List[Text] .
    • Danh sách tên đầu ra để tính toán số liệu cho (Không có nếu một mô hình)
  • sub_keys: List[tfma.SubKey] .
    • Danh sách các khóa phụ (ID lớp, K hàng đầu, v.v.) để tính toán số liệu cho (hoặc Không có)
  • aggregation_type: tfma.AggregationType
    • Loại tổng hợp nếu tính toán một chỉ số tổng hợp.
  • class_weights: Dict[int, float] .
    • Các trọng số của lớp sẽ sử dụng nếu tính toán một chỉ số tổng hợp.
  • query_key: Text
    • Khóa truy vấn được sử dụng nếu tính toán số liệu dựa trên truy vấn/xếp hạng.

Nếu một số liệu không được liên kết với một hoặc nhiều cài đặt này thì nó có thể loại bỏ các tham số đó khỏi định nghĩa chữ ký của nó.

Nếu một số liệu được tính toán theo cùng một cách cho từng mô hình, đầu ra và khóa phụ, thì tiện ích tfma.metrics.merge_per_key_computations có thể được sử dụng để thực hiện các phép tính tương tự cho từng đầu vào này một cách riêng biệt.

Số Liệu Tính Toán

Một MetricComputation được tạo thành từ sự kết hợp của preprocessors và combiner . Bộ preprocessors là danh sách của preprocessor , là một beam.DoFn lấy phần trích xuất làm đầu vào và xuất trạng thái ban đầu sẽ được bộ kết hợp sử dụng (xem kiến ​​trúc để biết thêm thông tin về phần trích xuất là gì). Tất cả các bộ tiền xử lý sẽ được thực hiện tuần tự theo thứ tự của danh sách. Nếu preprocessors trống, thì bộ kết hợp sẽ được chuyển qua StandardMetricInputs (đầu vào số liệu tiêu chuẩn chứa nhãn, dự đoán và trọng số_ví dụ). Bộ kết hợp là một combiner beam.CombineFn một bộ (phím lát cắt, đầu ra của bộ tiền xử lý) làm đầu vào và xuất một bộ gồm (slice_key, metric results dict) làm kết quả.

Lưu ý rằng việc cắt xảy ra giữa preprocessors và combiner .

Lưu ý rằng nếu một phép tính số liệu muốn sử dụng cả hai đầu vào số liệu tiêu chuẩn, nhưng bổ sung thêm một số tính năng từ các features trích xuất, thì có thể sử dụng FeaturePreprocessor đặc biệt để hợp nhất các tính năng được yêu cầu từ nhiều bộ kết hợp thành một tính năng duy nhất. giá trị StandardMetricsInputs được chia sẻ được chuyển đến tất cả các bộ kết hợp (bộ kết hợp chịu trách nhiệm đọc các tính năng mà chúng quan tâm và bỏ qua phần còn lại).

Thí dụ

Sau đây là một ví dụ rất đơn giản về định nghĩa chỉ số TFMA để tính toán 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}

Xuất phátMetricTính toán

DerivedMetricComputation được tạo thành từ một hàm kết quả được sử dụng để tính toán các giá trị chỉ số dựa trên đầu ra của các tính toán chỉ số khác. Hàm kết quả lấy một lệnh gồm các giá trị được tính toán làm đầu vào và xuất một lệnh gồm các kết quả chỉ số bổ sung.

Lưu ý rằng có thể chấp nhận (khuyến nghị) đưa các phép tính mà một phép tính dẫn xuất phụ thuộc vào danh sách các phép tính được tạo bởi một số liệu. Điều này giúp tránh phải tạo trước và chuyển các tính toán được chia sẻ giữa nhiều chỉ số. Người đánh giá sẽ tự động loại bỏ các phép tính trùng lặp có cùng định nghĩa để chỉ một phép tính thực sự được chạy.

Thí dụ

Số liệu TJUR cung cấp một ví dụ điển hình về số liệu dẫn xuất.