Các chỉ số và lô phân tích mô hình Tensorflow

Tổng quat

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

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

  • Chỉ số tùy chỉnh keras (số liệu có nguồn gốc từ tf.keras.metrics.Metric )

  • Chỉ số tùy chỉnh TFMA (số liệu có nguồn gốc từ tfma.metrics.Metric ) sử dụng tổ hợp chùm tùy chỉnh hoặc số liệu thu được từ số liệu khác).

TFMA cũng cung cấp hỗ trợ tích hợp để chuyển đổi các 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:

  • Binarization dựa trên ID lớp, K hàng đầu, v.v.
  • Các chỉ số 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 chỉ số 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 tự động trong đường dẫn.

Kết hợp có hơn 50 chỉ số và biểu đồ 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 để số liệu cấu hình trong TFMA: (1) sử dụng tfma.MetricsSpec hoặc (2) bằng cách tạo ra các trường hợp tf.keras.metrics.* và / hoặc tfma.metrics.* Lớp trong python và sử dụng tfma.metrics.specs_from_metrics để chuyển đổi chúng vào một danh sách các 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.

Chỉ số 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 tf.keras.metrics.*tfma.metrics.* Mô-đun cho 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 cách sử dụ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 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 bài toán phân loại nhị phân. Tham khảo tf.keras.metrics.*tfma.metrics.* Mô-đun cho 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 cách sử dụ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 sẵn bằng cách gọi tfma.metrics.default_binary_classification_specs .

Chỉ số phân loại nhiều lớp / nhiều nhãn

Sau đây là một ví dụ về thiết lập cấu hình cho một bài toán phân loại nhiều lớp. Tham khảo tf.keras.metrics.*tfma.metrics.* Mô-đun cho 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 cách sử dụ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 sẵn bằng cách gọi tfma.metrics.default_multi_class_classification_specs .

Các chỉ số được trộn lẫn nhiều lớp / nhiều nhãn

Số liệu đa lớp / đa nhãn có thể được binarized để sản xuất số liệu cho mỗi lớp, mỗi top_k, vv 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 cách sử dụ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]}))

Chỉ số tổng hợp nhiều lớp / nhiều nhãn

Số liệu đa lớp / đa nhãn có thể được tổng hợp để tạo ra một giá trị tổng hợp duy nhất cho một phân loại nhị phân số liệu bằng cách sử dụng tfma.AggregationOptions .

Lưu ý rằng các thiết lập kết hợp độc lập với binarization thiết lập để bạn có thể sử dụng cả hai tfma.AggregationOptionstfma.BinarizationOptions cùng một lúc.

Trung bình vi mô

Micro trung bình có thể được thực hiện bằng cách sử dụng các micro_average tùy chọn 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 cách sử dụ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))

Micro trung bình cũng hỗ trợ thiết top_k nơi chỉ có giá trị k đầu được sử dụng trong việc 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 cách sử dụ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]}))

Macro / Trung bình Macro có trọng số

Macro trung bình có thể được thực hiện bằng cách sử dụng các macro_average hoặc weighted_macro_average tùy chọn trong tfma.AggregationOptions . Trừ khi top_k thiết lập được sử dụng, vĩ mô đòi hỏi phải thiết lập các class_weights để biết được các lớp học để tính trung bình cho. Nếu một class_weight không được cung cấp sau đó 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 cách sử dụ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ư trung bình nhỏ, trung bình vĩ mô cũng hỗ trợ thiết top_k nơi chỉ có giá trị k đầu được sử dụng trong việc 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 cách sử dụ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

Query / xếp hạng số liệu dựa được kích hoạt bằng cách xác định query_key tùy chọn trong các số liệu kỹ thuật. 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 cách sử dụ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')

Các chỉ số đánh giá đa mô hình

TFMA hỗ trợ đánh giá nhiều mô hình cùng một lúc. Khi đánh giá nhiều mô hình được thực hiện, các chỉ số 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 phải được tính cho một tập hợp con của các mô hình, thiết lập 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

Các specs_from_metrics API cũng hỗ trợ thông qua 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 chỉ số so sánh cho một mô hình ứng 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 ứng viên và mô hình cơ sở là truyền theo 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")

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 nhau (hiện chỉ có các chỉ số giá trị vô hướng như độ chính xác và AUC).

Chỉ số mô hình nhiều đầ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 khóa chính tả theo tên đầu ra. Khi của mô hình đa sản lượng được sử dụng, tên của các kết quả đầu ra liên kết với một tập hợp các số liệu phải được xác định trong output_names phần 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

Các specs_from_metrics API cũng hỗ trợ thông qua 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, thiết lập ngưỡng, vv Điều này được thực hiện bằng cách thêm một config phần để cấu hình hệ mét. Các cấu hình được quy định bằng cách sử dụng chuỗi phiên bản JSON của các thông số đó sẽ được chuyển tới các số liệu __init__ phương pháp (để dễ sử dụng hàng đầu và dấu '{' và '}' khung 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ùy chỉnh này tất nhiên 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)

Kết quả đầu ra

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

Các phím số liệu

MetricKeys được định nghĩa bằng một loại chìa khóa cấu trúc. Khóa này xác định duy nhất từng khía cạnh sau của chỉ số:

  • Tên Metric ( auc , mean_label , vv)
  • 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 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 mã hóa)

Giá trị số liệu

MetricValues được xác định bằng proto rằng encapulates các loại giá trị khác nhau được hỗ trợ bởi các số liệu khác nhau (ví dụ như double , ConfusionMatrixAtThresholds , vv).

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

  • double_value - Một wrapper cho một loại kép.
  • bytes_value - Một byte giá trị.
  • bounded_value - Đại diện cho một giá trị thực sự mà có thể là một ước tính pointwise, tùy chọn với giới hạn tương đối của một số loại. Có tính value , lower_bound , và upper_bound .
  • value_at_cutoffs - Giá trị tại cutoffs (ví dụ chính xác @ K, thu hồi @ K). Có tài sản values , mỗi trong số đó có các đặc tính cutoffvalue .
  • confusion_matrix_at_thresholds - ma trận Lẫn lộn ở ngưỡng. Có sở hữu matrices , mỗi trong số đó có các thuộc tính cho threshold , precision , recall , và các giá trị ma trận nhầm lẫn như false_negatives .
  • array_value - Đối với số liệu mà trả về một mảng các giá trị.

Các phím lô

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

Giá trị lô đất

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

EvalResult

Sự trở lại từ một chạy đánh giá là một tfma.EvalResult . Kỷ lục này chứa slicing_metrics rằng mã hóa phím số liệu như một dict đa cấp nơi các mức tương ứng với tên đầu ra, lớp ID, tên số liệu, và giá trị metric tương ứng. Điều này nhằm mục đích được sử dụng để hiển thị giao diện người dùng trong máy tính xách tay Jupiter. Nếu truy cập vào các dữ liệu cơ bản là cần thiết các metrics kết quả tập tin nên được sử dụng thay thế (xem metrics_for_slice.proto ).

Tùy biến

Ngoài các chỉ số tùy chỉnh được thêm vào như một phần của keras đã lưu (hoặc EvalSavedModel kế thừa). 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 chỉ số keras tùy chỉnh và (2) bằng cách xác định lớp chỉ số TFMA tùy chỉnh được hỗ trợ bởi bộ kết hợp chùm.

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 lớp 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

Chỉ số Keras tùy chỉnh

Để tạo một phong tục keras số liệu, người dùng cần phải mở rộng tf.keras.metrics.Metric với thực hiện của họ và sau đó chắc chắn mô-đun của số liệu có sẵn vào thời điểm đánh giá.

Lưu ý rằng đối số liệu thêm bài mô hình tiết kiệm, TFMA chỉ hỗ trợ số liệu mà phải mất nhãn (ví dụ y_true), dự đoán (y_pred), và ví dụ trọng lượng (sample_weight) như tham số cho các update_state phương pháp.

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

Sau đây là ví dụ về chỉ số keras 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 một TFMA số tùy chỉnh, người dùng cần phải mở rộng tfma.metrics.Metric với thực hiện của họ và sau đó chắc chắn mô-đun của số liệu có sẵn vào thời điểm đánh giá.

Hệ mét

Một tfma.metrics.Metric thực hiện được tạo thành từ một tập hợp các kwargs xác định cấu hình các số liệu cùng với một chức năng để tạo tính toán (có thể nhiều) cần thiết để calcuate giá trị số liệu. Có hai loại tính toán chính mà có thể được sử dụng: tfma.metrics.MetricComputationtfma.metrics.DerivedMetricComputation được mô tả trong các phần dưới đây. Hàm tạo các phép tính này sẽ được chuyể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ố kỹ thuật của mô hình như khóa dự đoán để 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 mô hình đơn)
  • output_names: List[Text] .
    • Danh sách tên đầu ra để tính toán các chỉ số cho (Không có nếu mô hình đơn)
  • 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 các chỉ số cho (hoặc Không có)
  • aggregation_type: tfma.AggregationType
    • Loại tổng hợp nếu tính toán một số liệu tổng hợp.
  • class_weights: Dict[int, float] .
    • Trọng số lớp để sử dụng nếu tính toán một 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 chỉ số 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 thông số đó ra khỏi định nghĩa chữ ký của nó.

Nếu một thước đo được tính theo cùng một cách cho mỗi mô hình, sản lượng, và chìa khóa phụ, sau đó tiện ích tfma.metrics.merge_per_key_computations thể được sử dụng để thực hiện các tính toán tương tự cho mỗi người trong các đầu vào riêng biệt.

MetricComputation

Một MetricComputation được tạo thành từ sự kết hợp của một preprocessor và một combiner . Các preprocessor là một beam.DoFn mà có chiết xuất như là đầu vào và đầu ra tình trạng ban đầu sẽ được sử dụng bởi các bộ kết hợp (xem kiến trúc để biết thêm về những gì chiết xuất). Nếu một preprocessor không được định nghĩa, sau đó bộ kết hợp sẽ được chuyển StandardMetricInputs (đầu vào số liệu tiêu chuẩn chứa nhãn, dự đoán, và example_weights). Các combiner là một beam.CombineFn mà phải mất một tuple của (key lát, sản lượng Preprocessor) là đầu vào của nó và kết quả đầu ra một tuple của (slice_key, kết quả số liệu dict) như kết quả của nó.

Lưu ý rằng cắt xảy ra giữa preprocessorcombiner .

Lưu ý rằng nếu một tính toán metric muốn tận dụng cả đầu vào số liệu tiêu chuẩn, nhưng tăng thêm nó với một vài trong số các tính năng từ các features chiết xuất, sau đó đặc biệt FeaturePreprocessor thể được sử dụng mà sẽ hợp nhất các tính năng được yêu cầu từ nhiều tổ hợp thành một đơn chia sẻ giá trị StandardMetricsInputs được chuyển cho 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à họ 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 số liệu TFMA để tính toán Số lượng 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],
          preprocessor=_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

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

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

Thí dụ

Các số liệu TJUR cung cấp một ví dụ tốt về số liệu có nguồn gốc.