Trang này được dịch bởi Cloud Translation API.

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

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. Số liệu được tính toán bên ngoài biểu đồ theo chùm bằng cách sử dụng trực tiếp các lớp số liệu.
Số liệu và biểu đồ TFMA tiêu chuẩn ( tfma.metrics.* )
Số liệu máy ảnh tùy chỉnh (số liệu có nguồn gốc từ tf.keras.metrics.Metric )
Số liệu TFMA tùy chỉnh (số liệu có nguồn gốc từ tfma.metrics.Metric ) bằng cách sử dụng bộ kết hợp chùm tùy chỉnh hoặc số liệu có nguồn gốc từ các số liệu khác).

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

Nhị phân hóa dựa trên ID lớp, K hàng đầu, v.v.
Các 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 nhóm theo khóa truy vấn một cách tự động 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 các phiên bản của 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ấu hình ví dụ cho các loại vấn đề máy học khác nhau.

Số liệu hồi quy

Sau đây là thiết lập cấu hình mẫu 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 số liệu 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à thiết lập cấu hình mẫu cho bài toá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 số liệu 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 nhiều lớp/đa nhãn

Sau đây là thiết lập cấu hình mẫu cho bài toá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 số liệu 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/đa nhãn có thể được nhị phân hóa để tạo ra số liệu cho mỗi lớp, trên 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 nhiều lớp/đa nhãn

Số liệu nhiều lớp/nhiều nhãn có thể được tổng hợp để tạo ra một giá trị tổng hợp duy nhất cho số liệu 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 hóa nên 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ỉ sử dụng các giá trị k hàng đầu 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 vĩ mô có thể được thực hiện bằng cách sử dụng các 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ì giả sử là 0,0. 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 vĩ mô cũng hỗ trợ cài đặt top_k trong đó chỉ sử dụng các giá trị k hàng đầu 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

Chỉ số 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ố chỉ số. 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 thực hiện đánh giá nhiều mô hình, số liệu sẽ được tính 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 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 của mô hình ứng cử viên 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 thích 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")

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

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

TFMA hỗ trợ đánh giá số liệu trên các mô hình có đầ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 đượ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 số liệu 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ác 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__ số liệu (để dễ sử dụng, dấu ngoặc '{' và '}' ở đầu và cuối có thể được bỏ qua). 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á số liệu là một chuỗi các khóa/giá trị số liệu và/hoặc biểu thị khóa/giá trị dựa trên cấu hình được sử dụng.

Khóa số liệu

Khóa số liệu được xác định bằ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 của số liệu:

Tên số liệu ( 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 đánh giá mô hình nhiều đầu ra)
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 một 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ị số liệu được hỗ trợ:

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

Phím vẽ đồ thị

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

Giá trị lô

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

Đánh giáKết quả

Kết quả trả về từ quá trình đánh giá là tfma.EvalResult . Bản ghi này chứa slicing_metrics mã hóa khóa số liệu dưới dạng chính tả nhiều cấp trong đó các cấp tương ứng với tên đầu ra, ID lớp, tên số liệu và giá trị số liệu tương ứng. Đ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 quyề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ế ( xemmetrics_for_slice.proto ).

Tùy chỉnh

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.

Trong cả hai trường hợp, số liệu được định cấu hình bằng cách chỉ định tên của lớp số liệu và mô-đun liên quan. 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 Keras 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 khi triển khai và sau đó đảm bảo mô-đun của chỉ số có sẵn tại thời điểm đánh giá.

Lưu ý rằng đối với các chỉ số được thêm vào khi 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 thức update_state .

Ví dụ về số liệu Keras

Sau đây là 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)

Số liệu 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 khi triển khai và sau đó đảm bảo mô-đun của chỉ số có sẵn tại thời điểm đánh giá.

Số liệu

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 số liệu cùng với hàm tạo các phép tính (có thể là nhiều) cần thiết để tính giá trị số liệu. 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 phép tính 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 cho người đánh giá (hữu ích để tra cứu cài đặt thông số 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 (Không có nếu có một mô hình)
output_names: List[Text] .
- Danh sách tên đầu ra để tính toán số liệu (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 trên cùng, 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 số liệu tổng hợp.
class_weights: Dict[int, float] .
- Trọng số lớp sẽ sử dụng nếu tính toán số liệu 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 chỉ số 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 thông số đó ra khỏi định nghĩa đặc trưng 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.

Tính toán số liệu

MetricComputation được tạo thành từ sự kết hợp của preprocessors và combiner . preprocessors là danh sách preprocessor , là một beam.DoFn lấy các phần trích xuất làm đầu vào và xuất ra 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à example_weights). Bộ combiner là một beam.CombineFn lấy một bộ dữ liệu (khóa lát, đầu ra của bộ tiền xử lý) làm đầu vào và xuất ra một bộ dữ liệu (slice_key, kết quả số liệu 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 tính toán số liệu muốn sử dụng cả hai đầu vào số liệu tiêu chuẩn nhưng tăng cường nó bằng một số tính năng từ các trích xuất features thì có thể sử dụng Bộ xử lý đặ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 bộ duy nhất. giá trị StandardMetricsInputs được chia sẻ được chuyển cho tất cả các bộ kết hợp (các 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).

Ví dụ

Sau đây là một ví dụ rất đơn giản về định nghĩa số liệu TFMA để tính toán Ví dụ:

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 ExampleCountTest(tfma.test.testutil.TensorflowModelAnalysisTest):

  def testExampleCount(self):
    metric = ExampleCount()
    computations = metric.computations(example_weighted=False)
    computation = computations[0]

    with beam.Pipeline() as pipeline:
      result = (
          pipeline
          | 'Create' >> beam.Create([...])  # Add inputs
          | 'PreProcess' >> beam.ParDo(computation.preprocessors[0])
          | 'Process' >> beam.Map(tfma.metrics.to_standard_metric_inputs)
          | 'AddSlice' >> beam.Map(lambda x: ((), x))
          | 'ComputeMetric' >> beam.CombinePerKey(computation.combiner)
      )

      def check_result(got):
        try:
          self.assertLen(got, 1)
          got_slice_key, got_metrics = got[0]
          self.assertEqual(got_slice_key, ())
          key = computation.keys[0]
          self.assertIn(key, got_metrics)
          self.assertAlmostEqual(got_metrics[key], expected_value, places=5)
        except AssertionError as err:
          raise util.BeamAssertException(err)

      util.assert_that(result, check_result, label='result')

class _ExampleCountPreprocessor(beam.DoFn):

  def process(self, extracts: tfma.Extracts) -> Iterable[int]:
    yield 1


class _ExampleCountPreprocessorTest(unittest.TestCase):

  def testExampleCountPreprocessor(self):
    ...  # Init the test case here
    with beam.Pipeline() as pipeline:
      updated_pcoll = (
          pipeline
          | 'Create' >> beam.Create([...])  # Add inputs
          | 'Preprocess'
          >> beam.ParDo(
              _ExampleCountPreprocessor()
          )
      )

      beam_testing_util.assert_that(
          updated_pcoll,
          lambda result: ...,  # Assert the test case
      )


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}

Tính toán số liệu phái sinh

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

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

Ví dụ

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