מדדים ועלילות של מודלים של Tensorflow

סקירה כללית

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

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

  • מדדי keras Custom (מדדים נגזרים 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 .

מדדים בינאריים מרובי-מעמדים/רב-תוויות

Multi-הכיתה / ערכי-label רב ניתן binarized לייצר מדדים לכל הכיתה, לכל 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]}))

מדדי מצטבר מרובי-מעמדות/רב-תוויות

Multi-הכיתה / ערכי-label רב ניתן לצבור לייצר ערך מצטבר יחיד עבור סיווג בינארי מטרי באמצעות 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))

מיצוע Micro תומך גם הגדרת 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

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

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

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

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

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

TFMA מאפשר התאמה אישית של ההגדרות המשמשות עם מדדים שונים. לדוגמה ייתכן שתרצה לשנות את השם, ספי להגדיר, וכו 'הדבר נעשה על ידי הוספת 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 - a בתי ערך.
  • bounded_value - מייצג ערך אמיתי שיכול להיות אומדן pointwise, אופציונלי עם גבולות משוערים כלשהו. בעל תכונות value , lower_bound , ו upper_bound .
  • value_at_cutoffs - Value at הפסקות (דיוק למשל @ K, נזכיר @ K). יש רכוש values , שלכל אחד מהם יש תכונות cutoff ואת value .
  • confusion_matrix_at_thresholds - מטריקס Confusion על סף. יש רכוש matrices , שלכל אחד מהם יש מאפיינים עבור threshold , precision , recall , ואת ערכי המטריצה בלבול כגון false_negatives .
  • array_value - לקבלת ערכים אשר להחזיר מערך של ערכים.

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

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

ערכי עלילה

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

EvalResult

התשואה מן הריצה הערכה היא tfma.EvalResult . שיא זה מכיל slicing_metrics המקודד את המפתח מטרי בתור dict מרובות רמות שבו הרמות מתאימות שם פלט, מעמד ID, שם מטרי, וערך מטרי בהתאמה. זה נועד לשמש עבור תצוגת ממשק משתמש במחברת Jupiter. אם גישה לנתונים שבבסיס הוא זקוקים 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 שמגדירה את התצורה מדדה יחד עם פונקציה ליצירת החישובים (ואולי מרובים) צריך 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] .
    • רשימת מפתחות משנה (מזהה מחלקה, K העליון וכו') לחישוב מדדים עבור (או ללא)
  • aggregation_type: tfma.AggregationType
    • סוג הצבירה אם מחשבים מדד צבירה.
  • class_weights: Dict[int, float] .
    • משקלי מחלקה לשימוש בעת חישוב מדד צבירה.
  • query_key: Text
    • מפתח שאילתה המשמש בעת חישוב מדד מבוסס שאילתה/דירוג.

אם מדד אינו משויך לאחת או יותר מההגדרות הללו, הוא עלול להשאיר את הפרמטרים הללו מחוץ להגדרת החתימה שלו.

אם מדד מחושב באותו אופן עבור כל דגם, פלט, ומפתח המשנה, אזי השירות tfma.metrics.merge_per_key_computations ניתן להשתמש כדי לבצע את אותה חישובים עבור כל תשומות אלה בנפרד.

MetricComputation

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

שים לב חיתוך קורה בין preprocessor ו combiner .

הערה שאם חישוב מטרי רוצה לעשות שימוש הוא תשומות מדד הסטנדרטיות, אבל להגדיל אותו עם כמה מן התכונות של features תמציות, אזי המיוחד FeaturePreprocessor ניתן להשתמש בו יתמזג התכונות בקשו מן combiners המרובה לתוך אחת ערך 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],
          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

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

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

דוגמא

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