מדדים ועלילות ניתוח מודל Tensorflow

סקירה כללית

TFMA תומך במדדים ובחלקים הבאים:

  • מדדי keras סטנדרטיים ( tf.keras.metrics.* )
    • שים לב שאינך צריך מודל של קרס כדי להשתמש במדדי קרס. מדדים מחושבים מחוץ לגרף בקרן באמצעות מחלקות המדדים ישירות.

  • מדדי TFMA וחלקות סטנדרטיות ( tfma.metrics.* )

  • מדדי קרס מותאמים אישית (מדדים שנגזרו מ- tf.keras.metrics.Metric )

  • מדדי TFMA מותאמים אישית (מדדים שנגזרו מ- tfma.metrics.Metric ) תוך שימוש בשילובי אלומה מותאמים אישית או מדדים שנגזרו ממדדים אחרים).

TFMA מספקת גם תמיכה מובנית להמרת מדדי סיווג בינאריים לשימוש עם בעיות מרובות מחלקות/ריבוי תוויות:

  • בינאריזציה מבוססת על מזהה מחלקה, K העליון וכו'.
  • מדדים מצטברים המבוססים על מיצוע מיקרו, מיצוע מאקרו וכו'.

TFMA מספקת גם תמיכה מובנית עבור מדדים מבוססי שאילתות/דירוג, כאשר הדוגמאות מקובצות על ידי מפתח שאילתה באופן אוטומטי בצנרת.

בשילוב יש למעלה מ-50 מדדים סטנדרטיים וחלקים זמינים עבור מגוון בעיות כולל רגרסיה, סיווג בינארי, סיווג מרובה מחלקות/רב-תוויות, דירוג וכו'.

תְצוּרָה

ישנן שתי דרכים להגדיר מדדים ב-TFMA: (1) באמצעות tfma.MetricsSpec או (2) על ידי יצירת מופעים של מחלקות tf.keras.metrics.* ו/או tfma.metrics.* ב-python ושימוש ב- 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 וכו' באמצעות 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 בו-זמנית.

מיקרו ממוצע

ניתן לבצע מיקרו-ממוצע באמצעות האפשרות 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 שבה רק ערכי 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 שבה רק ערכי 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

ה-API specs_from_metrics תומך גם בהעברת שמות מודלים: 

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

מדדי השוואת מודלים

TFMA תומך בהערכת מדדי השוואה עבור מודל מועמד מול מודל בסיסי. דרך פשוטה להגדיר את צמד המודלים המועמדים והבסיסיים היא להעביר לאורך eval_shared_model עם שמות המודלים הנכונים (tfma.BASELINE_KEY ו-tfma.CANDIDATE_KEY):


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 תומך בהערכת מדדים במודלים בעלי תפוקות שונות. מודלים מרובי פלט מאחסנים את תחזיות הפלט שלהם בצורה של dict המבוסס על שם הפלט. כאשר נעשה שימוש במודלים מרובי פלטים, יש לציין את שמות הפלטים המשויכים לקבוצה של מדדים בקטע output_names של MetricsSpec. לְדוּגמָה:

from google.protobuf import text_format

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

ה-API specs_from_metrics תומך גם בהעברת שמות פלט: 

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 , וכו')
  • שם הדגם (בשימוש רק אם מדובר בהערכה מרובת מודלים)
  • שם פלט (בשימוש רק אם מוערכים מודלים מרובי פלט)
  • מפתח משנה (למשל מזהה מחלקה אם המודל הרב-מחלקות הוא בינארי)

ערך מטרי

MetricValues ​​מוגדרים באמצעות פרוטו שמכיל את סוגי הערכים השונים הנתמכים על ידי המדדים השונים (למשל 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 - עבור מדדים שמחזירים מערך של ערכים.

מפתחות העלילה

PlotKeys דומים למפתחות מטריים, אלא שמסיבות היסטוריות כל ערכי העלילה מאוחסנים בפרוטו בודד כך שלמפתח העלילה אין שם.

ערכי עלילה

כל החלקות הנתמכות מאוחסנות בפרוטו יחיד בשם PlotData .

EvalResult

ההחזר מהפעלת הערכה היא tfma.EvalResult . רשומה זו מכילה slicing_metrics המקודדות את המפתח המטרי ככתב רב-רמות שבו הרמות מתאימות לשם הפלט, מזהה המחלקה, שם המדד והערך המטרי בהתאמה. זה מיועד לשמש לתצוגת ממשק משתמש במחברת יופיטר. אם יש צורך בגישה לנתונים הבסיסיים, יש להשתמש בקובץ תוצאות metrics במקום זאת (ראה metrics_for_slice.proto ).

התאמה אישית

בנוסף למדדים מותאמים אישית שמתווספים כחלק מ-keras שנשמר (או EvalSavedModel מדור קודם). ישנן שתי דרכים להתאים אישית מדדים בשמירה לאחר TFMA: (1) על ידי הגדרת מחלקה מדדית מותאמת אישית של keras ו-(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

מדדי Keras מותאמים אישית

כדי ליצור מדד 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 מותאם אישית, המשתמשים צריכים להרחיב 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

MetricComputation מורכב משילוב של preprocessors combiner . preprocessors הם רשימה של preprocessor , שהוא beam.DoFn שלוקח תמציות כקלט שלו ומוציא את המצב ההתחלתי שישמש את המשלב (ראה ארכיטקטורה למידע נוסף על מה הם תמציות). כל המעבדים המקדימים יבוצעו ברצף לפי סדר הרשימה. אם preprocessors הפרה-מעבדים ריקים, המשלב יעבור StandardMetricInputs (כניסות מטריות סטנדרטיות מכילות תוויות, חיזויים ומשקלים לדוגמה). combiner הוא beam.CombineFn שלוקח tuple of (מפתח פרוסה, פלט קדם-מעבד) כקלט שלו ומוציא כתוצאה של (slice_key, metric results dict).

שימו לב שחיתוך מתרחש בין preprocessors combiner .

שימו לב שאם חישוב מטרי רוצה לעשות שימוש בשני הכניסות המטריות הסטנדרטיות, אך להגדיל אותו עם כמה מהתכונות ממיצוי features , ניתן להשתמש ב- FeaturePreprocessor המיוחד שימזג את התכונות המבוקשות משילובים מרובים לאחד ערך StandardMetricsInputs משותף שמועבר לכל המשלבים (הקומבינרים אחראים לקרוא את התכונות שהם מעוניינים בהן ולהתעלם מהשאר).

דוּגמָה

להלן דוגמה פשוטה מאוד להגדרת מדד TFMA לחישוב ה-ExampleCount: 

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

DerivedMetricComputation מורכב מפונקציית תוצאה המשמשת לחישוב ערכי מדדים המבוססים על הפלט של חישובים מדדים אחרים. פונקציית התוצאה לוקחת הכתבה של ערכים מחושבים כקלט שלה ומוציאה גזרה של תוצאות מטריות נוספות.

שימו לב שמקובל (מומלץ) לכלול את החישובים שחישוב נגזר תלוי בהם ברשימת החישובים שנוצרו על ידי מדד. כך נמנע צורך ליצור מראש ולהעביר חישובים המשותפים בין מספר מדדים. המעריך יבטל אוטומטית חישובים בעלי אותה הגדרה כך שרק חישוב אחד מופעל בפועל.

דוּגמָה

מדדי TJUR מספקים דוגמה טובה למדדים נגזרים.