Google I/O'da TensorFlow'a katılın, 11-12 Mayıs Şimdi kaydolun

Tensorflow Model Analiz Metrikleri ve Grafikleri

genel bakış

TFMA, aşağıdaki metrikleri ve grafikleri destekler:

  • Standart (ölçümlerini keras tf.keras.metrics.* )
    • Keras metriklerini kullanmak için bir keras modeline ihtiyacınız olmadığını unutmayın. Metrikler, doğrudan metrik sınıfları kullanılarak kirişte grafiğin dışında hesaplanır.
  • Standart TFMA ölçümlerini ve araziler ( tfma.metrics.* )

  • Gümrük keras metrikleri (türetilen metrikleri tf.keras.metrics.Metric )

  • Özel TFMA metrikleri (türetilen metrikleri tfma.metrics.Metric özel kiriş birleştiricileri veya diğer metrikleri türetilen metrikleri) kullanılarak).

TFMA ayrıca çok sınıflı/çok etiketli problemlerde kullanılmak üzere ikili sınıflandırma ölçütlerini dönüştürmek için yerleşik destek sağlar:

  • Sınıf kimliğine, üst K'ye vb. dayalı ikilileştirme.
  • Mikro ortalamaya, makro ortalamaya vb. dayalı toplu ölçümler.

TFMA, örneklerin ardışık düzende otomatik olarak bir sorgu anahtarıyla gruplandırıldığı sorgu/sıralama tabanlı ölçümler için yerleşik destek de sağlar.

Kombine olarak, regresyon, ikili sınıflandırma, çok sınıflı/çok etiketli sınıflandırma, sıralama vb. dahil olmak üzere çeşitli problemler için 50'den fazla standart metrik ve grafik mevcuttur.

Yapılandırma

TFMA içinde yapılandırmak ölçümlerine iki yol vardır: (1) kullanarak tfma.MetricsSpec örneklerini oluşturarak veya (2) tf.keras.metrics.* ve / veya tfma.metrics.* Piton ve kullanmada sınıflar tfma.metrics.specs_from_metrics listesine dönüştürmek için tfma.MetricsSpec .

Aşağıdaki bölümlerde, farklı türde makine öğrenimi sorunları için örnek yapılandırmalar açıklanmaktadır.

Regresyon Metrikleri

Aşağıda, bir regresyon sorunu için örnek bir yapılandırma kurulumu yer almaktadır. Consult tf.keras.metrics.* Ve tfma.metrics.* Olası ek metrikler için modüller destekledi.

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

Bu aynı kurulum, aşağıdaki python kodu kullanılarak oluşturulabilir:

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)

Bu kurulum da arayarak geniş bir yelpaze olduğunu unutmayın tfma.metrics.default_regression_specs .

İkili Sınıflandırma Metrikleri

Aşağıda bir ikili sınıflandırma problemi için örnek bir yapılandırma kurulumu yer almaktadır. Consult tf.keras.metrics.* Ve tfma.metrics.* Olası ek metrikler için modüller destekledi.

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

Bu aynı kurulum, aşağıdaki python kodu kullanılarak oluşturulabilir:

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)

Bu kurulum da arayarak geniş bir yelpaze olduğunu unutmayın tfma.metrics.default_binary_classification_specs .

Çok Sınıflı/Çok Etiketli Sınıflandırma Metrikleri

Aşağıda, çok sınıflı bir sınıflandırma problemi için örnek bir yapılandırma kurulumu yer almaktadır. Consult tf.keras.metrics.* Ve tfma.metrics.* Olası ek metrikler için modüller destekledi.

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

Bu aynı kurulum, aşağıdaki python kodu kullanılarak oluşturulabilir:

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)

Bu kurulum da arayarak geniş bir yelpaze olduğunu unutmayın tfma.metrics.default_multi_class_classification_specs .

Çok Sınıflı/Çok Etiketli İkili Metrikler

Çok sınıf / çok etiket ölçümlerini kullanarak vb top_k başına, sınıf başına ölçümlerini üretmek için ikileştirildikten edilebilir tfma.BinarizationOptions . Örneğin:

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

Bu aynı kurulum, aşağıdaki python kodu kullanılarak oluşturulabilir:

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

Çok Sınıflı/Çok Etiketli Toplam Metrikler

Çok sınıf / çok etiket ölçümlerini kullanarak metrik bir ikili sınıflandırma için tek bir toplam bir değer üretmek için toplanır edilebilir tfma.AggregationOptions .

Her iki kullanabilmesi toplama ayarları ikili hale ayarlarından bağımsız olduğunu Not tfma.AggregationOptions ve tfma.BinarizationOptions aynı anda.

Mikro Ortalama

Mikro ortalama kullanılarak yapılabilir micro_average içinde seçeneği tfma.AggregationOptions . Örneğin:

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

Bu aynı kurulum, aşağıdaki python kodu kullanılarak oluşturulabilir:

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

Mikro ortalama da ayarı destekleyen top_k sadece üst k değerleri hesaplamasında kullanılır. Örneğin:

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

Bu aynı kurulum, aşağıdaki python kodu kullanılarak oluşturulabilir:

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

Makro / Ağırlıklı Makro Ortalaması

Makro ortalama kullanılarak yapılabilir macro_average veya weighted_macro_average içinde seçenekleri tfma.AggregationOptions . Sürece top_k ayarları kullanılır, makro ayarı gerektiren class_weights için ortalama hesaplamak için hangi sınıfları bilmek için. Bir ederse class_weight sonra sağlanmaz 0.0 varsayılır. Örneğin:

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

Bu aynı kurulum, aşağıdaki python kodu kullanılarak oluşturulabilir:

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

Mikro ortalamasından gibi, makro ortalama alma da ayarı destekleyen top_k sadece üst k değerleri hesaplamasında kullanılır. Örneğin:

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

Bu aynı kurulum, aşağıdaki python kodu kullanılarak oluşturulabilir:

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

Sorgu / Sıralama Tabanlı Metrikler

Sorgu / sıralaması tabanlı metrikler belirterek etkindir query_key ölçütleri gözlük seçeneği. Örneğin:

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

Bu aynı kurulum, aşağıdaki python kodu kullanılarak oluşturulabilir:

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

Çok Modelli Değerlendirme Metrikleri

TFMA, aynı anda birden fazla modelin değerlendirilmesini destekler. Çoklu model değerlendirmesi yapıldığında her model için metrikler hesaplanacaktır. Örneğin:

from google.protobuf import text_format

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

Ölçümlerini modellerin bir alt kümesi için hesaplanabilir gerekiyorsa, set model_names içinde metric_specs . Örneğin:

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 ayrıca model isimleri geçen destekler:

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

Model Karşılaştırma Metrikleri

TFMA, bir aday model için karşılaştırma ölçütlerinin bir temel modele karşı değerlendirilmesini destekler. Aday ve temel model çiftini kurmanın basit bir yolu, uygun model adlarıyla (tfma.BASELINE_KEY ve tfma.CANDIDATE_KEY) bir eval_shared_model iletmektir:


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

Karşılaştırma metrikleri, tüm farklı metrikler için otomatik olarak hesaplanır (şu anda yalnızca doğruluk ve AUC gibi skaler değer metrikleri).

Çok çıkışlı Model Metrikleri

TFMA, farklı çıktılara sahip modellerde metriklerin değerlendirilmesini destekler. Çok çıktılı modeller, çıktı tahminlerini çıktı adına göre anahtarlanmış bir dict biçiminde saklar. Çoklu çıktı modeli en kullanıldığında, bir metrik kümesi ile ilişkili çıkışları adları belirtilmelidir output_names MetricsSpec bölümü. Örneğin:

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 ayrıca çıkış isimleri geçen destekler:

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

Metrik Ayarlarını Özelleştirme

TFMA, farklı metriklerle kullanılan ayarların özelleştirilmesine izin verir. Örneğin bu bir ekleyerek yapılır vs. isim, belirlenen eşikleri, değiştirmek isteyebilirsiniz config metrik config bölümüne. Yapılandırma ölçümlerini geçirilen olacaktır parametrelerin JSON dizesi versiyonu kullanılarak belirtilir __init__ yöntemi (kullanım kolaylığı için ön ve arka '{' ve '}' parantez atlanabilir). Örneğin:

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

Bu özelleştirme elbette doğrudan da desteklenmektedir:

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

çıktılar

Bir metrik değerlendirmenin çıktısı, kullanılan konfigürasyona dayalı olarak bir dizi metrik anahtar/değer ve/veya çizim anahtarı/değeridir.

Metrik Anahtarları

MetricKeys yapılandırılmış bir anahtar türü ile oluşturulur. Bu anahtar, bir metriğin aşağıdaki özelliklerinin her birini benzersiz bir şekilde tanımlar:

  • Ölçüm adı ( auc , mean_label , vs)
  • Model adı (yalnızca çok modelli değerlendirmede kullanılır)
  • Çıktı adı (yalnızca çok çıktılı modeller değerlendirilirse kullanılır)
  • Alt anahtar (örneğin, çok sınıflı model ikilileştirilmişse sınıf kimliği)

Metrik Değeri

MetricValues (örneğin, farklı metrik tarafından desteklenen farklı değer türleri encapulates bir proto kullanılarak tanımlanır double , ConfusionMatrixAtThresholds , vb).

Aşağıda desteklenen metrik değer türleri verilmiştir:

  • double_value - bir sargı kağıdı bir çift türü.
  • bytes_value - bir değer bayt.
  • bounded_value - isteğe bağlı olarak bir çeşit yaklaşık sınırları ile, bir noktasal tahmin olabilir gerçek değerini temsil eder. Özellikleri Has value , lower_bound ve upper_bound .
  • value_at_cutoffs - cutoffs Değer (K @ örneğin hassas, K @ hatırlama). Mülkiyet Has values özellikleri vardır, her biri, cutoff ve value .
  • confusion_matrix_at_thresholds - eşiklerinde hata matrisi. Özelliği vardır matrices için özelliklere sahip, her biri, threshold , precision , recall gibi, ve karışıklık matris değerlerinin false_negatives .
  • array_value - değerler dizisi geri metrikleri için.

Arsa Anahtarları

PlotKeys arsa anahtarı adı yok bu yüzden tarihi nedenlerden ötürü tüm araziler değerleri tek proto saklanır dışında metrik tuşları ile benzerdir.

Arsa Değerleri

Desteklenen tüm araziler adlı tek proto saklanır PlotData .

DeğerlendirmeSonucu

Bir değerlendirme çalışması dönüş bir olduğunu tfma.EvalResult . Bu kayıt içeren slicing_metrics seviyeleri, sırasıyla çıkış adı, sınıf numarası, metrik adı ve metrik değere karşılık, çok katlı bir dict metrik anahtar kodlar. Bu, bir Jüpiter not defterinde UI ekranı için kullanılmak üzere tasarlanmıştır. Tabi temel veri erişim Eğer metrics dosya yerine kullanılması gerektiğini neden (bkz metrics_for_slice.proto ).

özelleştirme

Kaydedilmiş keraların (veya eski EvalSavedModel) parçası olarak eklenen özel metriklere ek olarak. TFMA kaydetme sonrası metrikleri özelleştirmenin iki yolu vardır: (1) özel bir keras metrik sınıfı tanımlayarak ve (2) bir ışın birleştirici tarafından desteklenen özel bir TFMA metrik sınıfı tanımlayarak.

Her iki durumda da metrikler, metrik sınıfının ve ilişkili modülün adı belirtilerek yapılandırılır. Örneğin:

from google.protobuf import text_format

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

Özel Keras Metrikleri

Özel metrik keras oluşturmak için kullanıcılar uzatmak gerekir tf.keras.metrics.Metric kendi uygulamasıyla ardından emin metriğin modül değerlendirme anda kullanılabilir olduğundan emin olun.

Tasarrufu sonrası modeli eklendi ölçümler için de, TFMA sadece etiket almak ölçümleri desteklediğini Not (yani y_true), tahmin (y_pred) ve parametre olarak örnek ağırlığı (sample_weight) update_state yöntemiyle.

Keras Metrik Örneği

Aşağıda özel bir keras metriği örneği verilmiştir:

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)

Özel TFMA Metrikleri

Metrik özel TFMA oluşturmak için kullanıcılar uzatmak gerekir tfma.metrics.Metric kendi uygulamasıyla ardından emin metriğin modül değerlendirme anda kullanılabilir olduğundan emin olun.

Metrik

Bir tfma.metrics.Metric uygulama metrikleri değeri calcuate için gerekli hesaplamaları (muhtemelen çok sayıda) oluşturmak için bir işlevi ile birlikte metrikleri yapılandırmasını tanımlayan kwargs bir dizi oluşur. : Kullanılabilen iki ana hesaplama türü vardır tfma.metrics.MetricComputation ve tfma.metrics.DerivedMetricComputation aşağıdaki bölümlerde açıklanmıştır. Bu hesaplamaları oluşturan işlev, aşağıdaki parametreleri girdi olarak iletilecektir:

  • eval_config: tfam.EvalConfig
    • Değerlendirme yapılandırması, değerlendiriciye iletilir (kullanılacak tahmin anahtarı vb. gibi model spesifikasyon ayarlarını aramak için kullanışlıdır).
  • model_names: List[Text]
    • Metrikleri hesaplamak için model adlarının listesi (Tek model ise Yok)
  • output_names: List[Text] .
    • Metrikleri hesaplamak için çıktı adlarının listesi (Tek model ise Yok)
  • sub_keys: List[tfma.SubKey] .
    • (veya Yok) için metrikleri hesaplamak için alt anahtarların listesi (sınıf kimliği, üst K, vb.)
  • aggregation_type: tfma.AggregationType
    • Bir toplama metriği hesaplanıyorsa toplama türü.
  • class_weights: Dict[int, float] .
    • Bir toplama metriği hesaplanıyorsa kullanılacak sınıf ağırlıkları.
  • query_key: Text
    • Sorgu/sıralama tabanlı bir metrik hesaplanıyorsa kullanılan sorgu anahtarı.

Bir metrik bu ayarlardan bir veya daha fazlasıyla ilişkili değilse, bu parametreleri imza tanımının dışında bırakabilir.

Bir metrik her model çıkış ve bir alt anahtarı için aynı şekilde hesaplanır, daha sonra yardımcı tfma.metrics.merge_per_key_computations ayrı ayrı bu girişlerin her biri için, aynı hesaplamaları gerçekleştirmek için kullanılabilir.

Metrik Hesaplama

Bir MetricComputation bir kombinasyonundan oluşur preprocessor ve combiner . preprocessor a, beam.DoFn girdi olarak özleri alır ve (bakınız birleştiricisi tarafından kullanılacak başlangıç durumunu üretir mimari ekstreleridir ne daha fazla bilgi için). Bir ise preprocessor tanımlanmamıştır, daha sonra birleştirici geçilecek StandardMetricInputs (standart metrik giriş etiketler, tahminler ve example_weights içerir). combiner a, beam.CombineFn , girdi olarak bir demet (dilim anahtarı, ön işlemci çıkış) alır ve bunun sonucunda, (slice_key, metrik sonuçlar dict) bir başlığın çıktı olarak verir.

Dilimleme arasında meydana geldiği belirtilmelidir preprocessor ve combiner .

Not bir metrik hesaplama hem standart metrik girdi kullanımını sağlamak, ancak gelen özelliklerden birkaçı ile çoğaltmak istiyorsa features ekstrelerinin, daha sonra özel FeaturePreprocessor tek içine birden birleştiircisinde talep özelliklerini birleştirmek hangi kullanılabilir tüm birleştiricilere iletilen paylaşılan StandardMetricsInputs değeri (birleştiriciler, ilgilendikleri özellikleri okumaktan ve gerisini yok saymaktan sorumludur).

Örnek

Aşağıda, ExampleCount'u hesaplamak için çok basit bir TFMA metrik tanımı örneği verilmiştir:

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}

TüretilmişMetrik Hesaplama

Bir DerivedMetricComputation diğer metrik hesaplamalar çıkışına dayanarak metrik değerlerini hesaplamak için kullanılan bir sonuç fonksiyonu oluşur. Sonuç işlevi, girdisi olarak hesaplanan değerlerin bir diktesini alır ve ek metrik sonuçlarının bir diktesini verir.

Türetilmiş bir hesaplamanın bağlı olduğu hesaplamaları bir metrik tarafından oluşturulan hesaplamalar listesine dahil etmenin kabul edilebilir (önerilir) olduğuna dikkat edin. Bu, birden çok metrik arasında paylaşılan hesaplamaları önceden oluşturmak ve geçmek zorunda kalmaz. Değerlendirici, aynı tanıma sahip hesaplamaları otomatik olarak tekilleştirecek ve böylece tek bir hesaplama gerçekten çalıştırılacaktır.

Örnek

TJUR metrikleri türetilen ölçütler iyi bir örnek teşkil eder.