Tensorflow Model Analizi Metrikleri ve Grafikleri

Genel Bakış

TFMA aşağıdaki ölçümleri ve grafikleri destekler:

  • Standart keras metrikleri ( tf.keras.metrics.* )
    • Keras metriklerini kullanmak için keras modeline ihtiyacınız olmadığını unutmayın. Metrikler, doğrudan metrik sınıfları kullanılarak ışındaki grafiğin dışında hesaplanır.

  • Standart TFMA ölçümleri ve grafikleri ( tfma.metrics.* )

  • Özel keras ölçümleri ( tf.keras.metrics.Metric türetilen ölçümler)

  • Özel ışın birleştiricileri veya diğer ölçümlerden türetilen ölçümler kullanılarak özel TFMA ölçümleri ( tfma.metrics.Metric türetilen ölçümler).

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

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

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

Birleştirilmiş olarak, regresyon, ikili sınıflandırma, çok sınıflı/çok etiketli sınıflandırma, sıralama vb. gibi çeşitli problemler için 50'den fazla standart ölçüm ve çizim mevcuttur.

Yapılandırma

TFMA'da metrikleri yapılandırmanın iki yolu vardır: (1) tfma.MetricsSpec kullanarak veya (2) python'da tf.keras.metrics.* ve/veya tfma.metrics.* sınıflarının örneklerini oluşturarak ve tfma.metrics.specs_from_metrics bunları bir tfma.MetricsSpec listesine dönüştürmek için.

Aşağıdaki bölümlerde farklı makine öğrenimi sorunlarına yönelik örnek yapılandırmalar açıklanmaktadır.

Regresyon Metrikleri

Aşağıda bir regresyon sorunu için örnek bir yapılandırma kurulumu bulunmaktadır. Desteklenen olası ek ölçümler için tf.keras.metrics.* ve tfma.metrics.* modüllerine bakın.

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

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 kurulumun tfma.metrics.default_regression_specs çağrılarak da yapılabileceğini unutmayın.

İkili Sınıflandırma Metrikleri

Aşağıda ikili sınıflandırma problemi için örnek bir konfigürasyon kurulumu bulunmaktadır. Desteklenen olası ek ölçümler için tf.keras.metrics.* ve tfma.metrics.* modüllerine bakın.

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

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 kurulumun tfma.metrics.default_binary_classification_specs çağrılarak da yapılabileceğini unutmayın.

Ç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 konfigürasyon kurulumu bulunmaktadır. Desteklenen olası ek ölçümler için tf.keras.metrics.* ve tfma.metrics.* modüllerine bakın.

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

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 kurulumun tfma.metrics.default_multi_class_classification_specs çağrılarak da yapılabileceğini unutmayın.

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

Çok sınıflı/çok etiketli ölçümler, tfma.BinarizationOptions kullanılarak sınıf başına, top_k vb. başına ölçümler üretmek için ikili hale getirilebilir. Ö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

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 Toplu Metrikler

Çok sınıflı/çok etiketli ölçümler, tfma.AggregationOptions kullanılarak ikili sınıflandırma ölçümü için tek bir toplanmış değer üretmek üzere toplanabilir.

Toplama ayarlarının ikilileştirme ayarlarından bağımsız olduğunu ve böylece hem tfma.AggregationOptions hem de tfma.BinarizationOptions aynı anda kullanabileceğinizi unutmayın.

Mikro Ortalama

Mikro ortalama, tfma.AggregationOptions içindeki micro_average seçeneği kullanılarak gerçekleştirilebilir. Ö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

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 alma aynı zamanda hesaplamada yalnızca en üst k değerlerinin kullanıldığı top_k ayarını da destekler. Ö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

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 Ortalama

Makro ortalaması, tfma.AggregationOptions içindeki macro_average veya weighted_macro_average seçenekleri kullanılarak gerçekleştirilebilir. top_k ayarları kullanılmadığı sürece makro, ortalamanın hangi sınıflar için hesaplanacağını bilmek amacıyla class_weights ayarlanmasını gerektirir. Bir class_weight sağlanmazsa 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

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 ortalama gibi, makro ortalama da hesaplamada yalnızca en üst k değerlerinin kullanıldığı top_k ayarını destekler. Ö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

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ıralamaya Dayalı Metrikler

Sorgu/sıralama tabanlı metrikler, metrik özelliklerinde query_key seçeneği belirtilerek etkinleştirilir. Ö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

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

Çoklu Model 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

Bir model alt kümesi için metriklerin hesaplanması gerekiyorsa, metric_specs model_names ayarlayın. Ö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'si ayrıca model adlarının iletilmesini de destekler: 

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

Model Karşılaştırma Metrikleri

TFMA, bir aday modele ilişkin karşılaştırma metriklerinin temel bir modele göre değerlendirilmesini destekler. Aday ve temel model çiftini ayarlamanı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ılaştırılabilir 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 çıkışlı modeller, çıkış tahminlerini çıkış adına göre anahtarlanan bir dikte biçiminde saklar. Çoklu çıktı modelleri kullanıldığında, bir dizi metrikle ilişkili çıktıların adları, MetricsSpec'in output_names bölümünde belirtilmelidir. Ö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 çıktı adlarının iletilmesini de 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 olanak tanır. Örneğin adı değiştirmek, eşikleri ayarlamak vb. isteyebilirsiniz. Bu, metrik yapılandırmaya bir config bölümü eklenerek yapılır. Yapılandırma, metrik __init__ yöntemine aktarılacak parametrelerin JSON dize sürümü kullanılarak belirtilir (kullanım kolaylığı için baştaki ve sondaki '{' ve '}' parantezleri çıkarılabilir). Ö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)

Çıkışlar

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

Metrik Anahtarlar

MetricKey'ler yapılandırılmış bir anahtar türü kullanılarak tanımlanır. Bu anahtar, bir metriğin aşağıdaki yönlerinin her birini benzersiz şekilde tanımlar:

  • Metrik adı ( auc , mean_label vb.)
  • Model adı (yalnızca çoklu model değerlendirmesi durumunda kullanılır)
  • Çıkış adı (yalnızca çok çıkış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ğer

MetricValues , farklı ölçümler tarafından desteklenen farklı değer türlerini kapsayan bir protokol kullanılarak tanımlanır (örn. double , ConfusionMatrixAtThresholds , vb.).

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

  • double_value - Double türü için bir sarmalayıcı.
  • bytes_value - Bayt değeri.
  • bounded_value - İsteğe bağlı olarak bir tür yaklaşık sınırlarla noktasal bir tahmin olabilecek gerçek bir değeri temsil eder. value , lower_bound ve upper_bound özelliklerine sahiptir.
  • value_at_cutoffs - Kesim noktalarındaki değer (örneğin, Precision@K, Recall@K). Her biri özellik cutoff ve value sahip olan özellik values sahiptir.
  • confusion_matrix_at_thresholds - Eşiklerdeki karışıklık matrisi. Her biri threshold , precision , recall ve false_negatives gibi karışıklık matrisi değerlerine yönelik özelliklere sahip olan özellik matrices sahiptir.
  • array_value - Bir değer dizisi döndüren ölçümler için.

Çizim Anahtarları

Çizim Anahtarları metrik anahtarlara benzer, ancak tarihsel nedenlerden ötürü tüm grafik değerleri tek bir protokolde saklanır, dolayısıyla çizim anahtarının bir adı yoktur.

Grafik Değerleri

Desteklenen tüm grafikler PlotData adı verilen tek bir protokolde saklanır.

DeğerlendirmeSonucu

Bir değerlendirme çalıştırmasının dönüşü bir tfma.EvalResult . Bu kayıt, seviyelerin sırasıyla çıkış adı, sınıf kimliği, metrik adı ve metrik değerine karşılık geldiği çok düzeyli bir dict olarak metrik anahtarını kodlayan slicing_metrics içerir. Bunun bir Jüpiter dizüstü bilgisayarda kullanıcı arayüzü ekranı için kullanılması amaçlanmıştır. Temel verilere erişim gerekiyorsa bunun yerine metrics sonuç dosyası kullanılmalıdır (bkz. metrics_for_slice.proto ).

Özelleştirme

Kaydedilmiş kerasların (veya eski EvalSavedModel) parçası olarak eklenen özel ölçümlere 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 ilgili 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 bir keras metriği oluşturmak için kullanıcıların tf.keras.metrics.Metric uygulamalarıyla genişletmeleri ve ardından metriğin modülünün değerlendirme sırasında kullanılabilir olduğundan emin olmaları gerekir.

Model kaydı sonrasında eklenen metrikler için TFMA'nın, update_state yöntemine parametre olarak yalnızca etiket (yani y_true), tahmin (y_pred) ve örnek ağırlığı (sample_weight) alan metrikleri desteklediğini unutmayın.

Keras Metrik Örneği

Aşağıda özel keras metriğinin bir ö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

Özel bir TFMA metriği oluşturmak için kullanıcıların tfma.metrics.Metric uygulamalarıyla birlikte genişletmeleri ve ardından metriğin modülünün değerlendirme sırasında kullanılabilir olduğundan emin olmaları gerekir.

Metrik

Bir tfma.metrics.Metric uygulaması, metrik yapılandırmasını tanımlayan bir dizi kwarg'dan ve metrik değerini hesaplamak için gereken hesaplamaları (muhtemelen birden fazla) oluşturmaya yönelik bir işlevden oluşur. Kullanılabilecek iki ana hesaplama türü vardır: aşağıdaki bölümlerde açıklanan tfma.metrics.MetricComputation ve tfma.metrics.DerivedMetricComputation . Bu hesaplamaları oluşturan fonksiyona aşağıdaki parametreler girdi olarak iletilecektir:

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

Bir metrik bu ayarlardan bir veya daha fazlasıyla ilişkilendirilmemişse bu parametreleri imza tanımının dışında bırakabilir.

Bir ölçüm her model, çıktı ve alt anahtar için aynı şekilde hesaplanırsa, bu girdilerin her biri için aynı hesaplamaları ayrı ayrı gerçekleştirmek üzere tfma.metrics.merge_per_key_computations yardımcı programı kullanılabilir.

MetrikHesaplama

MetricComputation preprocessors ve combiner birleşiminden oluşur. preprocessors , girdi olarak özütleri alan ve birleştirici tarafından kullanılacak başlangıç ​​durumunu çıktı olarak veren bir beam.DoFn olan preprocessor bir listesidir (özetlerin ne olduğu hakkında daha fazla bilgi için mimariye bakın). Tüm ön işlemciler liste sırasına göre sırayla yürütülecektir. preprocessors boşsa birleştiriciye StandardMetricInputs (standart metrik girişler etiketleri, tahminleri ve example_weights'ı içerir) aktarılır. combiner , girdi olarak bir (dilim anahtarı, önişlemci çıkışı) demetini alan ve sonuç olarak bir (slice_key, metrik results dict) demetini çıkaran bir beam.CombineFn .

Dilimlemenin preprocessors ve combiner arasında gerçekleştiğini unutmayın.

Bir metrik hesaplamanın her iki standart metrik girdiyi de kullanmak, ancak bunu features özütlerindeki birkaç özellik ile genişletmek istemesi durumunda, birden fazla birleştiriciden istenen özellikleri tek bir öğede birleştirecek özel ÖzellikÖnişlemcisinin kullanılabileceğini unutmayın. tüm birleştiricilere aktarılan paylaşılan StandardMetricsInputs değeri (birleştiriciler ilgilendikleri özellikleri okumak ve geri kalanını göz ardı etmekten sorumludur).

Örnek

Aşağıda, SampleCount'un hesaplanmasına yönelik ç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],
          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üretilmişMetrikHesaplama

DerivedMetricComputation diğer metrik hesaplamaların çıktısına dayalı olarak metrik değerleri hesaplamak için kullanılan bir sonuç işlevinden oluşur. Sonuç işlevi, girdi olarak hesaplanan değerlerin bir diktesini alır ve ek metrik sonuçların bir diktesini çıktı olarak verir.

Türetilmiş bir hesaplamanın bağlı olduğu hesaplamaların, bir metrik tarafından oluşturulan hesaplamalar listesine dahil edilmesinin kabul edilebilir (önerilen) olduğunu unutmayın. Bu, birden fazla ölçüm arasında paylaşılan hesaplamaları önceden oluşturma ve aktarma zorunluluğunu ortadan kaldırır. Değerlendirici, aynı tanıma sahip hesaplamaların tekrarlarını otomatik olarak kaldıracak ve böylece yalnızca bir hesaplama gerçekten çalıştırılacaktır.

Örnek

TJUR metrikleri türetilmiş metriklere iyi bir örnek sağlar.