इस पेज का अनुवाद Cloud Translation API से किया गया है.

टेन्सरफ़्लो मॉडल विश्लेषण मेट्रिक्स और प्लॉट

सिंहावलोकन

टीएफएमए निम्नलिखित मेट्रिक्स और प्लॉट का समर्थन करता है:

मानक केरस मेट्रिक्स ( tf.keras.metrics.* )
- ध्यान दें कि केरस मेट्रिक्स का उपयोग करने के लिए आपको केरस मॉडल की आवश्यकता नहीं है। मेट्रिक्स की गणना सीधे मेट्रिक्स वर्गों का उपयोग करके बीम में ग्राफ़ के बाहर की जाती है।
मानक टीएफएमए मेट्रिक्स और प्लॉट ( tfma.metrics.* )
कस्टम केरस मेट्रिक्स ( tf.keras.metrics.Metric से प्राप्त मेट्रिक्स)
कस्टम टीएफएमए मेट्रिक्स ( tfma.metrics.Metric से प्राप्त मेट्रिक्स) कस्टम बीम कंबाइनर्स या अन्य मेट्रिक्स से प्राप्त मेट्रिक्स का उपयोग करके)।

टीएफएमए मल्टी-क्लास/मल्टी-लेबल समस्याओं के उपयोग के लिए बाइनरी वर्गीकरण मेट्रिक्स को परिवर्तित करने के लिए अंतर्निहित समर्थन भी प्रदान करता है:

वर्ग आईडी, शीर्ष K, आदि के आधार पर बिनरीकरण।
माइक्रो एवरेजिंग, मैक्रो एवरेजिंग आदि के आधार पर एकत्रित मेट्रिक्स।

टीएफएमए क्वेरी/रैंकिंग आधारित मेट्रिक्स के लिए अंतर्निहित समर्थन भी प्रदान करता है जहां उदाहरणों को पाइपलाइन में स्वचालित रूप से क्वेरी कुंजी द्वारा समूहीकृत किया जाता है।

संयुक्त रूप से प्रतिगमन, बाइनरी वर्गीकरण, मल्टी-क्लास/मल्टी-लेबल वर्गीकरण, रैंकिंग इत्यादि सहित विभिन्न समस्याओं के लिए 50+ से अधिक मानक मेट्रिक्स और प्लॉट उपलब्ध हैं।

विन्यास

टीएफएमए में मेट्रिक्स को कॉन्फ़िगर करने के दो तरीके हैं: (1) tfma.MetricsSpec का उपयोग करके या (2) tf.keras.metrics.* और/या tfma.metrics.* कक्षाओं के उदाहरण पायथन में बनाकर और tfma.metrics.specs_from_metrics उन्हें tfma.MetricsSpec की सूची में बदलने के लिए।

निम्नलिखित अनुभाग विभिन्न प्रकार की मशीन सीखने की समस्याओं के लिए उदाहरण कॉन्फ़िगरेशन का वर्णन करते हैं।

प्रतिगमन मेट्रिक्स

प्रतिगमन समस्या के लिए निम्नलिखित एक उदाहरण कॉन्फ़िगरेशन सेटअप है। समर्थित संभावित अतिरिक्त मेट्रिक्स के लिए tf.keras.metrics.* और tfma.metrics.* मॉड्यूल से परामर्श लें।

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

यह समान सेटअप निम्नलिखित पायथन कोड का उपयोग करके बनाया जा सकता है:

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)

ध्यान दें कि यह सेटअप tfma.metrics.default_regression_specs पर कॉल करके भी उपलब्ध है।

बाइनरी वर्गीकरण मेट्रिक्स

बाइनरी वर्गीकरण समस्या के लिए निम्नलिखित एक उदाहरण कॉन्फ़िगरेशन सेटअप है। समर्थित संभावित अतिरिक्त मेट्रिक्स के लिए tf.keras.metrics.* और tfma.metrics.* मॉड्यूल से परामर्श लें।

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

यह समान सेटअप निम्नलिखित पायथन कोड का उपयोग करके बनाया जा सकता है:

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)

ध्यान दें कि यह सेटअप tfma.metrics.default_binary_classification_specs पर कॉल करके भी उपलब्ध है।

मल्टी-क्लास/मल्टी-लेबल वर्गीकरण मेट्रिक्स

निम्नलिखित बहु-वर्ग वर्गीकरण समस्या के लिए एक उदाहरण कॉन्फ़िगरेशन सेटअप है। समर्थित संभावित अतिरिक्त मेट्रिक्स के लिए tf.keras.metrics.* और tfma.metrics.* मॉड्यूल से परामर्श लें।

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

यह समान सेटअप निम्नलिखित पायथन कोड का उपयोग करके बनाया जा सकता है:

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)

ध्यान दें कि यह सेटअप tfma.metrics.default_multi_class_classification_specs पर कॉल करके भी उपलब्ध है।

मल्टी-क्लास/मल्टी-लेबल बाइनराइज्ड मेट्रिक्स

मल्टी-क्लास/मल्टी-लेबल मेट्रिक्स को tfma.BinarizationOptions का उपयोग करके प्रति क्लास, प्रति टॉप_के आदि मेट्रिक्स तैयार करने के लिए बिनराइज़ किया जा सकता है। उदाहरण के लिए:

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

यह समान सेटअप निम्नलिखित पायथन कोड का उपयोग करके बनाया जा सकता है:

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

मल्टी-क्लास/मल्टी-लेबल एग्रीगेट मेट्रिक्स

tfma.AggregationOptions का उपयोग करके बाइनरी वर्गीकरण मीट्रिक के लिए एकल एकत्रित मान उत्पन्न करने के लिए मल्टी-क्लास/मल्टी-लेबल मेट्रिक्स को एकत्रित किया जा सकता है।

ध्यान दें कि एकत्रीकरण सेटिंग्स बाइनराइजेशन सेटिंग्स से स्वतंत्र हैं इसलिए आप एक ही समय में tfma.AggregationOptions और tfma.BinarizationOptions दोनों का उपयोग कर सकते हैं।

सूक्ष्म औसत

माइक्रो एवरेजिंग tfma.AggregationOptions के भीतर micro_average विकल्प का उपयोग करके किया जा सकता है। उदाहरण के लिए:

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

यह समान सेटअप निम्नलिखित पायथन कोड का उपयोग करके बनाया जा सकता है:

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 सेटिंग का भी समर्थन करता है जहां गणना में केवल शीर्ष के मान का उपयोग किया जाता है। उदाहरण के लिए:

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

यह समान सेटअप निम्नलिखित पायथन कोड का उपयोग करके बनाया जा सकता है:

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

मैक्रो/भारित मैक्रो औसत

मैक्रो औसतिंग को tfma.AggregationOptions के भीतर macro_average या weighted_macro_average विकल्पों का उपयोग करके किया जा सकता है। जब तक top_k सेटिंग्स का उपयोग नहीं किया जाता है, मैक्रो को यह जानने के लिए class_weights सेट करने की आवश्यकता होती है कि किन कक्षाओं के लिए औसत की गणना की जाए। यदि class_weight प्रदान नहीं किया गया है तो 0.0 मान लिया गया है। उदाहरण के लिए:

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

यह समान सेटअप निम्नलिखित पायथन कोड का उपयोग करके बनाया जा सकता है:

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

माइक्रो एवरेजिंग की तरह, मैक्रो एवरेजिंग भी top_k सेट करने का समर्थन करती है जहां गणना में केवल शीर्ष k मानों का उपयोग किया जाता है। उदाहरण के लिए:

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

यह समान सेटअप निम्नलिखित पायथन कोड का उपयोग करके बनाया जा सकता है:

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

क्वेरी/रैंकिंग आधारित मेट्रिक्स

क्वेरी/रैंकिंग आधारित मेट्रिक्स को मेट्रिक्स विनिर्देशों में query_key विकल्प निर्दिष्ट करके सक्षम किया जाता है। उदाहरण के लिए:

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

यह समान सेटअप निम्नलिखित पायथन कोड का उपयोग करके बनाया जा सकता है:

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

मल्टी-मॉडल मूल्यांकन मेट्रिक्स

टीएफएमए एक ही समय में कई मॉडलों के मूल्यांकन का समर्थन करता है। जब बहु-मॉडल मूल्यांकन किया जाता है, तो प्रत्येक मॉडल के लिए मैट्रिक्स की गणना की जाएगी। उदाहरण के लिए:

from google.protobuf import text_format

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

यदि मॉडलों के उपसमूह के लिए मैट्रिक्स की गणना करने की आवश्यकता है, तो metric_specs में model_names सेट करें। उदाहरण के लिए:

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 पासिंग मॉडल नामों का भी समर्थन करता है:

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

मॉडल तुलना मेट्रिक्स

टीएफएमए बेसलाइन मॉडल के मुकाबले उम्मीदवार मॉडल के लिए तुलना मेट्रिक्स का मूल्यांकन करने का समर्थन करता है। उम्मीदवार और बेसलाइन मॉडल जोड़ी को स्थापित करने का एक आसान तरीका उचित मॉडल नाम (tfma.BASELINE_KEY और tfma.CANDIDATE_KEY) के साथ एक eval_shared_model पास करना है:


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

तुलना मेट्रिक्स की गणना सभी भिन्न-योग्य मेट्रिक्स (वर्तमान में केवल स्केलर मान मेट्रिक्स जैसे सटीकता और एयूसी) के लिए स्वचालित रूप से की जाती है।

मल्टी-आउटपुट मॉडल मेट्रिक्स

टीएफएमए विभिन्न आउटपुट वाले मॉडलों पर मेट्रिक्स का मूल्यांकन करने का समर्थन करता है। मल्टी-आउटपुट मॉडल अपने आउटपुट पूर्वानुमानों को आउटपुट नाम से कुंजीबद्ध एक निर्देश के रूप में संग्रहीत करते हैं। जब मल्टी-आउटपुट मॉडल का उपयोग किया जाता है, तो मेट्रिक्स के सेट से जुड़े आउटपुट के नाम मेट्रिक्सस्पेक के output_names अनुभाग में निर्दिष्ट किए जाने चाहिए। उदाहरण के लिए:

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 पासिंग आउटपुट नामों का भी समर्थन करता है:

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

मीट्रिक सेटिंग्स को अनुकूलित करना

टीएफएमए विभिन्न मेट्रिक्स के साथ उपयोग की जाने वाली सेटिंग्स को अनुकूलित करने की अनुमति देता है। उदाहरण के लिए, आप नाम बदलना, थ्रेशोल्ड सेट करना आदि चाह सकते हैं। यह मीट्रिक कॉन्फिगरेशन में एक config सेक्शन जोड़कर किया जाता है। कॉन्फ़िगरेशन को पैरामीटर के JSON स्ट्रिंग संस्करण का उपयोग करके निर्दिष्ट किया जाता है जिसे मेट्रिक्स __init__ विधि में पारित किया जाएगा (उपयोग में आसानी के लिए अग्रणी और अनुगामी '{' और '}' ब्रैकेट को छोड़ा जा सकता है)। उदाहरण के लिए:

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

यह अनुकूलन निश्चित रूप से सीधे समर्थित भी है:

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

आउटपुट

मीट्रिक मूल्यांकन का आउटपुट उपयोग किए गए कॉन्फ़िगरेशन के आधार पर मीट्रिक कुंजियों/मानों और/या प्लॉट कुंजियों/मानों की एक श्रृंखला है।

मीट्रिक कुंजियाँ

मेट्रिककीज़ को एक संरचित कुंजी प्रकार का उपयोग करके परिभाषित किया गया है। यह कुंजी मीट्रिक के निम्नलिखित प्रत्येक पहलू की विशिष्ट रूप से पहचान करती है:

मीट्रिक नाम ( auc , mean_label , आदि)
मॉडल का नाम (केवल बहु-मॉडल मूल्यांकन के लिए उपयोग किया जाता है)
आउटपुट नाम (केवल तभी उपयोग किया जाता है जब मल्टी-आउटपुट मॉडल का मूल्यांकन किया जाता है)
उप कुंजी (उदाहरण के लिए क्लास आईडी यदि मल्टी-क्लास मॉडल बाइनराइज़्ड है)

मीट्रिक मान

मेट्रिकवैल्यूज़ को एक प्रोटो का उपयोग करके परिभाषित किया जाता है जो विभिन्न मेट्रिक्स (उदाहरण के लिए double , ConfusionMatrixAtThresholds , आदि) द्वारा समर्थित विभिन्न मूल्य प्रकारों को समाहित करता है।

नीचे समर्थित मीट्रिक मान प्रकार हैं:

double_value - डबल प्रकार के लिए एक आवरण।
bytes_value - एक बाइट्स मान।
bounded_value - एक वास्तविक मूल्य का प्रतिनिधित्व करता है जो एक बिंदुवार अनुमान हो सकता है, वैकल्पिक रूप से किसी प्रकार की अनुमानित सीमा के साथ। इसमें गुण value , lower_bound , और upper_bound हैं।
value_at_cutoffs - कटऑफ़ पर मान (जैसे प्रिसिजन@के, रिकॉल@के)। इसमें संपत्ति values हैं, जिनमें से प्रत्येक में गुण cutoff और value हैं।
confusion_matrix_at_thresholds - थ्रेशोल्ड पर कन्फ्यूजन मैट्रिक्स। इसमें संपत्ति matrices हैं, जिनमें से प्रत्येक में threshold , precision , recall और भ्रम मैट्रिक्स मान जैसे कि false_negatives के गुण हैं।
array_value - मेट्रिक्स के लिए जो मानों की एक सरणी लौटाते हैं।

प्लॉट कुंजियाँ

प्लॉटकीज़ मीट्रिक कुंजियों के समान हैं, सिवाय इसके कि ऐतिहासिक कारणों से सभी प्लॉट मान एक ही प्रोटो में संग्रहीत होते हैं, इसलिए प्लॉट कुंजी का कोई नाम नहीं होता है।

प्लॉट मान

सभी समर्थित प्लॉट प्लॉटडेटा नामक एक एकल प्रोटो में संग्रहीत हैं।

EvalResult

मूल्यांकन रन से रिटर्न एक tfma.EvalResult है। इस रिकॉर्ड में slicing_metrics शामिल है जो मीट्रिक कुंजी को एक बहु-स्तरीय निर्देश के रूप में एन्कोड करता है जहां स्तर क्रमशः आउटपुट नाम, क्लास आईडी, मीट्रिक नाम और मीट्रिक मान से मेल खाते हैं। इसका उद्देश्य ज्यूपिटर नोटबुक में यूआई डिस्प्ले के लिए उपयोग करना है। यदि अंतर्निहित डेटा तक पहुंच की आवश्यकता है तो इसके बजाय metrics परिणाम फ़ाइल का उपयोग किया जाना चाहिए ( metrics_for_slice.proto देखें)।

अनुकूलन

कस्टम मेट्रिक्स के अलावा जो सहेजे गए केरस (या लीगेसी इवलसेव्डमॉडल) के हिस्से के रूप में जोड़े जाते हैं। बचत के बाद टीएफएमए में मेट्रिक्स को अनुकूलित करने के दो तरीके हैं: (1) एक कस्टम केरस मीट्रिक वर्ग को परिभाषित करके और (2) एक बीम कॉम्बिनर द्वारा समर्थित एक कस्टम टीएफएमए मेट्रिक्स वर्ग को परिभाषित करके।

दोनों ही मामलों में, मेट्रिक्स को मेट्रिक वर्ग और संबंधित मॉड्यूल के नाम को निर्दिष्ट करके कॉन्फ़िगर किया जाता है। उदाहरण के लिए:

from google.protobuf import text_format

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

कस्टम केरस मेट्रिक्स

एक कस्टम केरस मीट्रिक बनाने के लिए, उपयोगकर्ताओं को अपने कार्यान्वयन के साथ tf.keras.metrics.Metric विस्तार करना होगा और फिर सुनिश्चित करना होगा कि मूल्यांकन के समय मीट्रिक का मॉड्यूल उपलब्ध है।

ध्यान दें कि पोस्ट मॉडल सेव के लिए जोड़े गए मेट्रिक्स के लिए, टीएफएमए केवल उन मेट्रिक्स का समर्थन करता है जो update_state विधि के पैरामीटर के रूप में लेबल (यानी y_true), भविष्यवाणी (y_pred), और उदाहरण वजन (नमूना_वेट) लेते हैं।

केरस मीट्रिक उदाहरण

निम्नलिखित कस्टम केरस मीट्रिक का एक उदाहरण है:

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)

कस्टम टीएफएमए मेट्रिक्स

एक कस्टम टीएफएमए मीट्रिक बनाने के लिए, उपयोगकर्ताओं को अपने कार्यान्वयन के साथ tfma.metrics.Metric विस्तार करना होगा और फिर सुनिश्चित करना होगा कि मीट्रिक का मॉड्यूल मूल्यांकन के समय उपलब्ध है।

मीट्रिक

एक tfma.metrics.Metric कार्यान्वयन kwargs के एक सेट से बना है जो मेट्रिक्स मान की गणना करने के लिए आवश्यक गणना (संभवतः एकाधिक) बनाने के लिए एक फ़ंक्शन के साथ-साथ मेट्रिक्स कॉन्फ़िगरेशन को परिभाषित करता है। दो मुख्य गणना प्रकार हैं जिनका उपयोग किया जा सकता है: tfma.metrics.MetricComputation और tfma.metrics.DerivedMetricComputation जिनका वर्णन नीचे दिए गए अनुभागों में किया गया है। जो फ़ंक्शन इन गणनाओं को बनाता है, उसे इनपुट के रूप में निम्नलिखित पैरामीटर पारित किए जाएंगे:

eval_config: tfam.EvalConfig
- eval कॉन्फिगरेशन मूल्यांकनकर्ता को भेज दिया गया (मॉडल विशिष्ट सेटिंग्स जैसे उपयोग करने के लिए भविष्यवाणी कुंजी आदि को देखने के लिए उपयोगी)।
model_names: List[Text]
- मेट्रिक्स की गणना करने के लिए मॉडल नामों की सूची (यदि एकल मॉडल है तो कोई नहीं)
output_names: List[Text] ।
- मेट्रिक्स की गणना करने के लिए आउटपुट नामों की सूची (यदि एकल मॉडल है तो कोई नहीं)
sub_keys: List[tfma.SubKey] ।
- (या कोई नहीं) के लिए मेट्रिक्स की गणना करने के लिए उप कुंजियों (वर्ग आईडी, शीर्ष K, आदि) की सूची
aggregation_type: tfma.AggregationType
- एकत्रीकरण मीट्रिक की गणना करते समय एकत्रीकरण का प्रकार।
class_weights: Dict[int, float] ।
- एकत्रीकरण मीट्रिक की गणना करते समय उपयोग किए जाने वाले वर्ग भार।
query_key: Text
- क्वेरी/रैंकिंग आधारित मीट्रिक की गणना करते समय क्वेरी कुंजी का उपयोग किया जाता है।

यदि कोई मीट्रिक इनमें से एक या अधिक सेटिंग्स से संबद्ध नहीं है तो यह उन मापदंडों को अपनी हस्ताक्षर परिभाषा से बाहर कर सकता है।

यदि प्रत्येक मॉडल, आउटपुट और उप कुंजी के लिए एक मीट्रिक की गणना समान तरीके से की जाती है, तो उपयोगिता tfma.metrics.merge_per_key_computations उपयोग इनमें से प्रत्येक इनपुट के लिए अलग से समान गणना करने के लिए किया जा सकता है।

मीट्रिकगणना

एक MetricComputation preprocessors और एक combiner के संयोजन से बना है। preprocessors preprocessor की एक सूची है, जो एक beam.DoFn DoFn है जो अर्क को अपने इनपुट के रूप में लेता है और प्रारंभिक स्थिति को आउटपुट करता है जिसका उपयोग कॉम्बिनर द्वारा किया जाएगा (अर्क क्या हैं इसके बारे में अधिक जानकारी के लिए आर्किटेक्चर देखें)। सभी प्रीप्रोसेसरों को सूची के क्रम में क्रमिक रूप से निष्पादित किया जाएगा। यदि preprocessors खाली है, तो कंबाइनर को स्टैंडर्डमेट्रिक इनपुट्स पास किया जाएगा (मानक मीट्रिक इनपुट में लेबल, पूर्वानुमान और उदाहरण_वेट शामिल हैं)। combiner एक beam.CombineFn है जो अपने इनपुट के रूप में (स्लाइस कुंजी, प्रीप्रोसेसर आउटपुट) का एक टुपल लेता है और इसके परिणाम के रूप में (स्लाइस_की, मीट्रिक परिणाम डिक्ट) का एक टुपल आउटपुट करता है।

ध्यान दें कि स्लाइसिंग preprocessors और combiner के बीच होती है।

ध्यान दें कि यदि कोई मीट्रिक गणना दोनों मानक मीट्रिक इनपुट का उपयोग करना चाहती है, लेकिन इसे features अर्क से कुछ सुविधाओं के साथ बढ़ाना चाहती है, तो विशेष फ़ीचरप्रीप्रोसेसर का उपयोग किया जा सकता है जो एकाधिक कॉम्बिनर्स से अनुरोधित सुविधाओं को एक में मर्ज कर देगा। साझा मानक मेट्रिक्स इनपुट मान जो सभी कॉम्बिनर्स को दिया जाता है (कॉम्बिनर्स उन सुविधाओं को पढ़ने के लिए जिम्मेदार होते हैं जिनमें वे रुचि रखते हैं और बाकी को अनदेखा करते हैं)।

उदाहरण

exampleCount की गणना के लिए TFMA मीट्रिक परिभाषा का एक बहुत ही सरल उदाहरण निम्नलिखित है:

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}

व्युत्पन्नमैट्रिकगणना

DerivedMetricComputation एक परिणाम फ़ंक्शन से बना होता है जिसका उपयोग अन्य मीट्रिक संगणनाओं के आउटपुट के आधार पर मीट्रिक मानों की गणना करने के लिए किया जाता है। परिणाम फ़ंक्शन अपने इनपुट के रूप में गणना किए गए मानों का एक निर्देश लेता है और अतिरिक्त मीट्रिक परिणामों का एक निर्देश आउटपुट करता है।

ध्यान दें कि मीट्रिक द्वारा बनाई गई गणनाओं की सूची में उन गणनाओं को शामिल करना स्वीकार्य (अनुशंसित) है जिन पर व्युत्पन्न गणना निर्भर करती है। इससे एकाधिक मेट्रिक्स के बीच साझा की जाने वाली गणनाओं को पहले से बनाने और पास करने की आवश्यकता से बचा जा सकता है। मूल्यांकनकर्ता स्वचालित रूप से समान परिभाषा वाली गणनाओं को डी-डुप कर देगा ताकि केवल एक ही गणना वास्तव में चल सके।

उदाहरण

TJUR मेट्रिक्स व्युत्पन्न मेट्रिक्स का एक अच्छा उदाहरण प्रदान करता है।