Bu sayfa, Cloud Translation API ile çevrilmiştir.

Tensorflow Modeli Analiz Metrikleri ve Çizimleri

genel bakış

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

Standart keras ölçümleri ( 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 ışında 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ştiriciler veya diğer metriklerden türetilen metrikler kullanılarak özel TFMA metrikleri ( tfma.metrics.Metric türetilen metrikler).

TFMA ayrıca, çoklu sınıf/çoklu etiket problemlerinde kullanılmak üzere ikili sınıflandırma ölçümlerini 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 metrikler.

TFMA ayrıca, örneklerin ardışık düzende otomatik olarak bir sorgu anahtarına göre gruplandırıldığı sorgu/sıralama tabanlı metrikler için yerleşik destek 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'da ölçümleri yapılandırmanın iki yolu vardır: (1) tfma.MetricsSpec kullanarak veya (2) tf.keras.metrics.* ve/veya tfma.metrics.* sınıflarının örneklerini oluşturarak ve tfma.metrics'i kullanarak tfma.metrics.specs_from_metrics onları bir tfma.MetricsSpec listesine dönüştürmek için.

Aşağıdaki bölümlerde, farklı makine öğrenimi sorunları türleri 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. Desteklenen olası ek ölçümler için tf.keras.metrics.* ve tfma.metrics.* modüllerine başvurun.

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

İkili Sınıflandırma Metrikleri

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

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 kurulumun tfma.metrics.default_binary_classification_specs çağrılarak da kullanı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 yapılandırma kurulumu yer almaktadır. Desteklenen olası ek ölçümler için tf.keras.metrics.* ve tfma.metrics.* modüllerine başvurun.

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 kurulumun tfma.metrics.default_multi_class_classification_specs çağrılarak da kullanılabilir olduğunu unutmayın.

Çok Sınıflı/Çok Etiketli İkilileştirilmiş Metrikler

Çok sınıflı/çok etiketli ölçümler, tfma.BinarizationOptions kullanılarak sınıf başına, tfma.BinarizationOptions vb. başına ölçüm ü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

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

Çok sınıflı/çok etiketli metrikler, tfma.AggregationOptions kullanılarak bir ikili sınıflandırma metriği için tek bir toplu değer üretmek üzere toplanabilir.

Toplama ayarlarının ikili hale getirme ayarlarından bağımsız olduğunu ve bu nedenle 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

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, hesaplamada yalnızca en yüksek 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

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 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, hangi sınıfların ortalamasını hesaplayacağını bilmek için class_weights ayarlanmasını gerektirir. Bir class_weight sağlanmazsa, 0.0 olduğu 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 ortalama gibi, makro ortalama da hesaplamada yalnızca en yüksek 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

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

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

Çoklu Model Değerlendirme Metrikleri

TFMA, aynı anda birden çok modeli değerlendirmeyi 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, 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'si ayrıca model adlarını iletmeyi de 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 göre 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 geçirmektir:


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 diffable metrikler için otomatik olarak hesaplanır (şu anda sadece 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, çıktı tahminlerini çıktı adıyla anahtarlanmış bir dikte biçiminde saklar. Çok çıktılı modeller kullanıldığında, bir dizi metrikle ilişkili çıktıların adları, 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 çıkış adlarını iletmeyi 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ü ekleyerek yapılır. Yapılandırma, metrics __init__ yöntemine iletilecek parametrelerin JSON dizesi sürümü kullanılarak belirtilir (kullanım kolaylığı için baştaki ve sondaki '{' ve '}' parantezleri 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 desteklenir:

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

çıktılar

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

Metrik Anahtarlar

Metrik Anahtarlar , 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 yapılırsa 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ı metrikler (örn. double , ConfusionMatrixAtThresholds , vb.) tarafından desteklenen farklı değer türlerini özetleyen bir protokol kullanılarak tanımlanır.

Desteklenen metrik değer türleri aşağıdadır:

double_value - Double tipi için bir sarıcı.
bytes_value - Bir bayt değeri.
bounded_value - İsteğe bağlı olarak bir tür yaklaşık sınırla, noktasal bir tahmin olabilecek gerçek bir değeri temsil eder. value , lower_bound ve upper_bound özelliklerine sahiptir.
value_at_cutoffs - Kesimlerdeki değer (örn. kesinlik@K, geri çağırma@K). Her biri özellik cutoff ve value sahip olan özellik values sahiptir.
confusion_matrix_at_thresholds - Eşiklerde kafa karışıklığı matrisi. Her biri threshold , precision , recall ve false_negatives gibi karışıklık matrisi değerleri için özelliklere sahip olan özellik matrices sahiptir .
array_value - Bir dizi değer döndüren metrikler için.

Arsa Anahtarları

PlotKey'ler , tarihsel nedenlerle tüm grafik değerlerinin tek bir protokolde saklanması ve böylece çizim anahtarının bir adı olmaması dışında metrik anahtarlara benzer.

Arsa Değerleri

Desteklenen tüm grafikler, PlotData adlı tek bir protokolde saklanır.

Değerlendirme Sonucu

Bir değerlendirme çalıştırmasının getirisi bir tfma.EvalResult . Bu kayıt, metrik anahtarını, seviyelerin sırasıyla çıktı adı, sınıf kimliği, metrik adı ve metrik değerine karşılık geldiği çok düzeyli bir dikte olarak kodlayan slicing_metrics içerir. Bu, bir Jupiter not defterinde UI ekranı için kullanılmak üzere tasarlanmıştır. Altta yatan verilere erişim gerekiyorsa, bunun yerine metrics sonuç dosyası kullanılmalıdır (bkz. metrics_for_slice.proto ).

özelleştirme

Kayıtlı keraları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 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 bir keras metriği oluşturmak için, kullanıcıların uygulamalarıyla birlikte tf.keras.metrics.Metric genişletmeleri ve ardından değerlendirme sırasında metrik modülünün kullanılabilir olduğundan emin olmaları gerekir.

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

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

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

Metrik

Bir tfma.metrics.Metric uygulaması, metrik değerini hesaplamak için gereken hesaplamaları (muhtemelen birden çok) oluşturmaya yönelik bir işlevle birlikte metrik yapılandırmasını tanımlayan bir dizi kwarg'dan 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 işlev, aşağıdaki parametreleri girdi olarak iletecektir:

eval_config: tfam.EvalConfig
- Değerlendiriciye iletilen değerlendirme yapılandırması (kullanılacak tahmin anahtarı vb. gibi model spesifikasyon ayarlarına bakmak için kullanışlıdır).
model_names: List[Text]
- Metrikleri hesaplanacak model adlarının listesi (Tek model ise hiçbiri)
output_names: List[Text] .
- Metrikleri hesaplanacak çıktı adlarının listesi (Tek model ise hiçbiri)
sub_keys: List[tfma.SubKey] .
- (veya Hiçbiri) için metrikleri hesaplamak üzere alt anahtarların (sınıf kimliği, üst K vb.) listesi
aggregation_type: tfma.AggregationType
- 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 biri veya daha fazlasıyla ilişkilendirilmemişse, bu parametreleri imza tanımının dışında bırakabilir.

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

Metrik Hesaplama

Bir MetricComputation , preprocessors işlemciler ve bir combiner kombinasyonundan oluşur. preprocessors , giriş olarak özetleri alan ve birleştirici tarafından kullanılacak ilk durumu çıkaran bir beam.DoFn olan preprocessor bir listesidir (ekstraktların 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ıralı olarak yürütülecektir. preprocessors boşsa, birleştiriciye StandardMetricInputs geçirilir (standart metrik girdiler etiketler, tahminler ve example_weights içerir). combiner , girişi olarak bir demet (dilim anahtarı, önişlemci çıktısı) alan ve sonuç olarak bir demet ( beam.CombineFn , metrik sonuçlar dict) çıkaran bir beam.CombineFn'dir.

Dilimlemenin preprocessors ve combiner arasında gerçekleştiğine dikkat edin.

Bir metrik hesaplama, her iki standart metrik girdiyi de kullanmak istiyorsa, ancak bunu features özetlerinden birkaç özellik ile zenginleştiriyorsa, birden fazla birleştiriciden istenen özellikleri tek bir birleştiricide birleştirecek olan özel FeaturePreprocessor kullanılabilir. tüm birleştiricilere iletilen paylaşılan StandardMetricsInputs değeri (birleştiriciler ilgilendikleri özellikleri okumaktan ve gerisini göz ardı etmekten sorumludur).

Misal

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],
          preprocessors=[_ExampleCountPreprocessor()],
          combiner=_ExampleCountCombiner(key))
  ]


class _ExampleCountPreprocessor(beam.DoFn):

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


class _ExampleCountCombiner(beam.CombineFn):

  def __init__(self, metric_key: tfma.metrics.MetricKey):
    self._metric_key = metric_key

  def create_accumulator(self) -> int:
    return 0

  def add_input(self, accumulator: int, state: int) -> int:
    return accumulator + state

  def merge_accumulators(self, accumulators: Iterable[int]) -> int:
    accumulators = iter(accumulators)
    result = next(accumulator)
    for accumulator in accumulators:
      result += accumulator
    return result

  def extract_output(self,
                     accumulator: int) -> Dict[tfma.metrics.MetricKey, int]:
    return {self._metric_key: accumulator}

TüretilmişMetrikHesaplama

Bir 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 çıkarır.

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

Misal

TJUR ölçümleri , türetilmiş ölçümlere iyi bir örnek sağlar.