Tensorflow मॉडल विश्लेषण मेट्रिक्स और प्लॉट

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

अवलोकन

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

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

  • कस्टम केरस मेट्रिक्स ( tf.keras.metrics.Metric से प्राप्त मेट्रिक्स)

  • कस्टम बीम कॉम्बिनर्स या अन्य मेट्रिक्स से प्राप्त मेट्रिक्स का उपयोग करके कस्टम TFMA मेट्रिक्स ( tfma.metrics.Metric से प्राप्त मेट्रिक्स)।

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

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

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

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

विन्यास

TFMA में मेट्रिक्स को कॉन्फ़िगर करने के दो तरीके हैं: (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 का उपयोग करके प्रति वर्ग, प्रति top_k, आदि मेट्रिक्स का उत्पादन करने के लिए 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 सेटिंग का समर्थन करता है जहां गणना में केवल शीर्ष 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 सेटिंग का समर्थन करता है जहां गणना में केवल शीर्ष के मूल्यों का उपयोग किया जाता है। उदाहरण के लिए:

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

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

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

from google.protobuf import text_format

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

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

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

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

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

TFMA अलग-अलग आउटपुट वाले मॉडल पर मेट्रिक्स के मूल्यांकन का समर्थन करता है। बहु-आउटपुट मॉडल अपने आउटपुट भविष्यवाणियों को आउटपुट नाम द्वारा की गई एक तानाशाही के रूप में संग्रहीत करते हैं। जब बहु-आउटपुट मॉडल का उपयोग किया जाता है, तो मेट्रिक्स के एक सेट से जुड़े आउटपुट के नाम मेट्रिक्सस्पेक के 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'])

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

TFMA विभिन्न मेट्रिक्स के साथ उपयोग की जाने वाली सेटिंग्स को अनुकूलित करने की अनुमति देता है। उदाहरण के लिए, हो सकता है कि आप नाम बदलना, थ्रेसहोल्ड सेट करना आदि चाहें। यह मेट्रिक कॉन्फिग में एक 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 , आदि)
  • मॉडल का नाम (केवल बहु-मॉडल मूल्यांकन होने पर उपयोग किया जाता है)
  • आउटपुट नाम (केवल तभी उपयोग किया जाता है जब बहु-आउटपुट मॉडल का मूल्यांकन किया जाता है)
  • उप कुंजी (उदाहरण के लिए कक्षा आईडी यदि बहु-श्रेणी मॉडल बिनाराइज्ड है)

मीट्रिक मूल्य

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

प्लॉट कीज़

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

प्लॉट मान

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

EvalResult

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

अनुकूलन

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

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

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 का विस्तार करना होगा और फिर सुनिश्चित करना होगा कि मीट्रिक का मॉड्यूल मूल्यांकन के समय उपलब्ध है।

ध्यान दें कि मॉडल सेव करने के बाद जोड़े गए मेट्रिक्स के लिए, TFMA केवल उन मेट्रिक्स का समर्थन करता है जो 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 मीट्रिक बनाने के लिए, उपयोगकर्ताओं को 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]
    • (या कोई नहीं) के लिए मेट्रिक्स की गणना करने के लिए उप कुंजी (वर्ग आईडी, शीर्ष के, आदि) की सूची
  • aggregation_type: tfma.AggregationType
    • एकत्रीकरण मीट्रिक की गणना करते समय एकत्रीकरण का प्रकार।
  • class_weights: Dict[int, float]
    • एकत्रीकरण मीट्रिक की गणना करते समय उपयोग किए जाने वाले वर्ग भार।
  • query_key: Text
    • क्वेरी/रैंकिंग आधारित मीट्रिक की गणना करते समय क्वेरी कुंजी का उपयोग किया जाता है।

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

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

मीट्रिक संगणना

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

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

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

उदाहरण

उदाहरण गणना की गणना के लिए 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 _ExampleCountPreprocessor(beam.DoFn):

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


class _ExampleCountCombiner(beam.CombineFn):

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

  def create_accumulator(self) -> int:
    return 0

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

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

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

व्युत्पन्न मीट्रिक संगणना

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

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

उदाहरण

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