এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

টেনসরফ্লো মডেল বিশ্লেষণ মেট্রিক্স এবং প্লট

ওভারভিউ

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, ইত্যাদি মেট্রিক্স তৈরি করতে বাইনারি করা যেতে পারে। যেমন:

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 সেটিং সমর্থন করে যেখানে গণনায় শুধুমাত্র টপ 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

যদি মডেলগুলির একটি উপসেটের জন্য মেট্রিক্স গণনা করার প্রয়োজন হয়, 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 একটি বেসলাইন মডেলের বিপরীতে প্রার্থী মডেলের তুলনা মেট্রিক্স মূল্যায়ন সমর্থন করে। প্রার্থী এবং বেসলাইন মডেল পেয়ার সেটআপ করার একটি সহজ উপায় হল সঠিক মডেল নাম (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 বিভিন্ন আউটপুট আছে এমন মডেলের মেট্রিক্স মূল্যায়ন সমর্থন করে। মাল্টি-আউটপুট মডেলগুলি তাদের আউটপুট ভবিষ্যদ্বাণীগুলিকে আউটপুট নামের দ্বারা চাবিযুক্ত ডিক্ট আকারে সংরক্ষণ করে। যখন মাল্টি-আউটপুট মডেলগুলি ব্যবহার করা হয়, তখন মেট্রিক্সের সেটের সাথে যুক্ত আউটপুটগুলির নাম অবশ্যই MetricsSpec-এর 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)

আউটপুট

একটি মেট্রিক মূল্যায়নের আউটপুট হল মেট্রিক কী/মান এবং/অথবা ব্যবহৃত কনফিগারেশনের উপর ভিত্তি করে প্লট কী/মানগুলির একটি সিরিজ।

মেট্রিক কী

MetricKeys একটি কাঠামোগত কী প্রকার ব্যবহার করে সংজ্ঞায়িত করা হয়। এই কী অনন্যভাবে একটি মেট্রিকের নিম্নলিখিত দিকগুলির প্রতিটিকে চিহ্নিত করে:

মেট্রিক নাম ( auc , mean_label , ইত্যাদি)
মডেলের নাম (মাল্টি-মডেল মূল্যায়ন হলেই ব্যবহার করা হয়)
আউটপুট নাম (কেবলমাত্র ব্যবহার করা হয় যদি মাল্টি-আউটপুট মডেল মূল্যায়ন করা হয়)
সাব কী (যেমন ক্লাস আইডি যদি মাল্টি-ক্লাস মডেল বাইনারি করা হয়)

মেট্রিক মান

মেট্রিক ভ্যালুগুলিকে একটি প্রোটো ব্যবহার করে সংজ্ঞায়িত করা হয় যা বিভিন্ন মেট্রিক্স দ্বারা সমর্থিত বিভিন্ন মানের প্রকারগুলিকে এনক্যাপুলেট করে (যেমন double , ConfusionMatrixAtThresholds ইত্যাদি)।

নীচে সমর্থিত মেট্রিক মান প্রকারগুলি রয়েছে:

double_value - একটি ডবল টাইপের জন্য একটি মোড়ক।
bytes_value - একটি বাইট মান।
bounded_value - একটি বাস্তব মানের প্রতিনিধিত্ব করে যা একটি পয়েন্টওয়াইজ অনুমান হতে পারে, ঐচ্ছিকভাবে কিছু ধরণের আনুমানিক সীমার সাথে। বৈশিষ্ট্য value আছে, lower_bound , এবং upper_bound ।
value_at_cutoffs - কাটঅফের মান (যেমন precision@K, recall@K)। প্রপার্টি values আছে, যার প্রতিটিরই প্রপার্টি cutoff এবং value আছে।
confusion_matrix_at_thresholds - থ্রেশহোল্ডে বিভ্রান্তি ম্যাট্রিক্স। প্রপার্টি matrices আছে, যার প্রতিটিতে threshold , precision , recall এবং কনফিউশন ম্যাট্রিক্স মান যেমন false_negatives এর বৈশিষ্ট্য রয়েছে।
array_value - মেট্রিক্সের জন্য যা মানগুলির একটি অ্যারে প্রদান করে।

প্লট কী

প্লটকীগুলি মেট্রিক কীগুলির মতোই, ঐতিহাসিক কারণে সমস্ত প্লটের মান একটি একক প্রোটোতে সংরক্ষণ করা হয় তাই প্লট কীটির একটি নাম নেই৷

প্লট মান

সমস্ত সমর্থিত প্লট প্লটডাটা নামে একটি একক প্রোটোতে সংরক্ষণ করা হয়।

ইভাল রেজাল্ট

একটি মূল্যায়ন রান থেকে প্রত্যাবর্তন একটি tfma.EvalResult . এই রেকর্ডে slicing_metrics রয়েছে যা মেট্রিক কীটিকে একটি মাল্টি-লেভেল ডিক্ট হিসাবে এনকোড করে যেখানে স্তরগুলি যথাক্রমে আউটপুট নাম, ক্লাস আইডি, মেট্রিক নাম এবং মেট্রিক মানের সাথে মিলে যায়। এটি একটি জুপিটার নোটবুকে 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 শুধুমাত্র সেই মেট্রিকগুলিকে সমর্থন করে যেগুলি লেবেল (যেমন y_true), ভবিষ্যদ্বাণী (y_pred), এবং উদাহরণ ওজন (নমুনা_ওজন) 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 মেট্রিক তৈরি করতে, ব্যবহারকারীদের তাদের বাস্তবায়নের সাথে tfma.metrics.Metric প্রসারিত করতে হবে এবং তারপর নিশ্চিত করুন যে মেট্রিকের মডিউলটি মূল্যায়নের সময় উপলব্ধ রয়েছে।

মেট্রিক

একটি tfma.metrics.Metric বাস্তবায়ন কোয়ার্গের একটি সেট দ্বারা গঠিত যা মেট্রিক্স মান গণনা করার জন্য প্রয়োজনীয় গণনা (সম্ভবত একাধিক) তৈরি করার জন্য একটি ফাংশন সহ মেট্রিক্স কনফিগারেশনকে সংজ্ঞায়িত করে। দুটি প্রধান গণনার ধরন রয়েছে যা ব্যবহার করা যেতে পারে: 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}

DerivedMetric Computation

একটি DerivedMetricComputation একটি ফলাফল ফাংশন দ্বারা গঠিত যা অন্যান্য মেট্রিক গণনার আউটপুটের উপর ভিত্তি করে মেট্রিক মান গণনা করতে ব্যবহৃত হয়। ফলাফল ফাংশন তার ইনপুট হিসাবে গণনা করা মানগুলির একটি ডিক্ট নেয় এবং অতিরিক্ত মেট্রিক ফলাফলের একটি ডিক্ট আউটপুট করে।

মনে রাখবেন যে গণনাগুলি অন্তর্ভুক্ত করা গ্রহণযোগ্য (প্রস্তাবিত) যা একটি প্রাপ্ত গণনা একটি মেট্রিক দ্বারা তৈরি গণনার তালিকায় নির্ভর করে। এটি একাধিক মেট্রিক্সের মধ্যে ভাগ করা গণনাগুলিকে প্রাক-তৈরি এবং পাস করতে হবে না। মূল্যায়নকারী স্বয়ংক্রিয়ভাবে কম্পিউটেশনগুলিকে ডি-ডুপ করবে যেগুলির একই সংজ্ঞা রয়েছে তাই একটি কম্পিউটেশন আসলে চালানো হয়।

উদাহরণ

TJUR মেট্রিক্স প্রাপ্ত মেট্রিক্সের একটি ভালো উদাহরণ প্রদান করে।