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

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

अवलोकन

TFMA निम्नलिखित मेट्रिक्स और भूखंडों का समर्थन करता है:

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

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

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

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

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

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

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

विन्यास

(1) का उपयोग करते हुए: वहाँ TFMA में कॉन्फ़िगर मैट्रिक्स के दो तरीके हैं 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

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

मल्टी वर्ग / बहु लेबल मेट्रिक्स, top_k प्रति, आदि का उपयोग प्रति कक्षा मैट्रिक्स उत्पादन करने के लिए किया जा सकता है binarized 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

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

सूक्ष्म औसत

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

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

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

मैक्रो औसत का उपयोग करके किया जा सकता है macro_average या weighted_macro_average भीतर विकल्प tfma.AggregationOptions । जब तक 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 एपीआई भी मॉडल नाम गुजर समर्थन करता है:

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

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

TFMA एक बेसलाइन मॉडल के विरुद्ध एक उम्मीदवार मॉडल के लिए तुलना मेट्रिक्स के मूल्यांकन का समर्थन करता है। उम्मीदवार और बेसलाइन मॉडल जोड़ी को सेटअप करने का एक आसान तरीका उचित मॉडल नामों (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")

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

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

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

from google.protobuf import text_format

metrics_specs = text_format.Parse("""
  metrics_specs {
    output_names: ["my-output"]
    ...
  }
""", tfma.EvalConfig()).metrics_specs

specs_from_metrics एपीआई भी उत्पादन के नाम से गुजर समर्थन करता है:

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

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

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

आउटपुट

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

मीट्रिक कुंजी

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

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

मीट्रिक मान

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

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

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

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

PlotKeys सिवाय इसके कि ऐतिहासिक कारणों से सभी भूखंडों मूल्यों एक भी आद्य में जमा हो जाती तो साजिश कुंजी एक नाम नहीं है मीट्रिक कुंजी के समान हैं।

प्लॉट मान

सभी समर्थित भूखंडों एक भी आद्य कहा जाता है में जमा हो जाती PlotData

EvalResult

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

अनुकूलन

सहेजे गए केरस (या लीगेसी EvalSavedModel) के हिस्से के रूप में जोड़े गए कस्टम मीट्रिक के अतिरिक्त। टीएफएमए पोस्ट सेविंग में मेट्रिक्स को कस्टमाइज़ करने के दो तरीके हैं: (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

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

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

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

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

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

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 कि संगणना (संभवतः कई) मीट्रिक मूल्य calcuate करने के लिए आवश्यक बनाने के लिए एक समारोह के साथ मैट्रिक्स विन्यास को परिभाषित का एक सेट से बना है। : दो मुख्य गणना प्रकार है कि इस्तेमाल किया जा सकता हैं 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 अलग से इन इनपुट से प्रत्येक के लिए एक ही संगणना प्रदर्शन करने के लिए इस्तेमाल किया जा सकता।

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

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

ध्यान दें कि टुकड़ा करने की क्रिया के बीच होता preprocessor और combiner

ध्यान दें कि एक मीट्रिक गणना दोनों मानक मैट्रिक आदानों का इस्तेमाल करते हैं, लेकिन से विशेषताओं में से कुछ के साथ इसे बढ़ाने के लिए चाहता है, तो features के अर्क, तो विशेष FeaturePreprocessor इस्तेमाल किया जा सकता है जो एक सिंगल में कई समेलक से अनुरोध सुविधाओं में मर्ज हो जाएगी साझा 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],
          preprocessor=_ExampleCountPreprocessor(),
          combiner=_ExampleCountCombiner(key))
  ]


class _ExampleCountPreprocessor(beam.DoFn):

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


class _ExampleCountCombiner(beam.CombineFn):

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

  def create_accumulator(self) -> int:
    return 0

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

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

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

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

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

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

उदाहरण

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