Google I/O הוא עטיפה! התעדכן בהפעלות של TensorFlow. צפה בהפעלות

הדגמה אישית של כרטיס דגם עצמאי

מחברת "עצמאית" זו מדגים שימוש בערכת הכלים של כרטיס דגם ללא הקשר TFX/MLMD. כדי ללמוד כיצד להשתמש בכלי דגם כרטיס עם TFX / MLMD, בבקשה לבדוק MLMD דגם כרטיס Toolkit הדגמה .

הצג באתר TensorFlow.org הפעל בגוגל קולאב הצג ב-GitHub הורד מחברת

מַטָרָה

מחברת זו מדגים כיצד ליצור כרטיס דגם באמצעות ערכת הכלים של כרטיס דגם בסביבת Jupyter/Colab. אתה יכול ללמוד יותר על כרטיסי מודל ב https://modelcards.withgoogle.com/about

אנו משתמשים במודל Keras בהדגמה זו. אבל ההיגיון שלהלן חל גם על מסגרות ML אחרות באופן כללי.

להכין

ראשית עלינו א) להתקין ולייבא את החבילות הדרושות, וב) להוריד את הנתונים.

שדרג ל-Pip 20.2 והתקן את ערכת הכלים לכרטיסי דגם

pip install --upgrade pip==20.2
pip install 'model-card-toolkit>=1.0.0,<1.1'
pip install 'tensorflow>=2.3.1'

הפעלת מחדש את זמן הריצה?

אם אתה משתמש ב-Google Colab, בפעם הראשונה שאתה מפעיל את התא שלמעלה, עליך להפעיל מחדש את זמן הריצה (Runtime > Restart runtime...). זה בגלל האופן שבו קולאב טוען חבילות.

יבוא

import tensorflow as tf
import numpy as np
import model_card_toolkit as mctlib
from model_card_toolkit.documentation.examples import cats_vs_dogs
from model_card_toolkit.utils.graphics import figure_to_base64str
import tempfile
import matplotlib.pyplot as plt
from IPython import display
import requests
import os
import zipfile

דֶגֶם

נשתמש במודל pretrained עם ארכיטקטורה מבוססת על הנחת MobileNetV2 , מודל סיווג תמונה 16-שכבה פופולרי. המודל שלנו הוכשר להבחין בין מתווכים חתולים וכלבים באמצעות חתולים לעומת כלבים במערך. הכשרת המודל התבססה על ההדרכה ולמידת העברת TensorFlow .

URL = 'https://storage.googleapis.com/cats_vs_dogs_model/cats_vs_dogs_model.zip'
BASE_PATH = tempfile.mkdtemp()
ZIP_PATH = os.path.join(BASE_PATH, 'cats_vs_dogs_model.zip')
MODEL_PATH = os.path.join(BASE_PATH,'cats_vs_dogs_model')

r = requests.get(URL, allow_redirects=True)
open(ZIP_PATH, 'wb').write(r.content)

with zipfile.ZipFile(ZIP_PATH, 'r') as zip_ref:
    zip_ref.extractall(BASE_PATH)

model = tf.keras.models.load_model(MODEL_PATH)
WARNING:tensorflow:SavedModel saved prior to TF 2.5 detected when loading Keras model. Please ensure that you are saving the model with model.save() or tf.keras.models.save_model(), *NOT* tf.saved_model.save(). To confirm, there should be a file named "keras_metadata.pb" in the SavedModel directory.
WARNING:tensorflow:SavedModel saved prior to TF 2.5 detected when loading Keras model. Please ensure that you are saving the model with model.save() or tf.keras.models.save_model(), *NOT* tf.saved_model.save(). To confirm, there should be a file named "keras_metadata.pb" in the SavedModel directory.

מערך נתונים

במערך הנתונים של cats-vs-dogs, label=0 מתאים לחתולים ואילו label=1 מתאים לכלבים.

def compute_accuracy(data):
  x = np.stack(data['examples'])
  y = np.asarray(data['labels'])
  _, metric = model.evaluate(x, y)
  return metric
examples = cats_vs_dogs.get_data()
print('num validation examples:', len(examples['combined']['examples']))
print('num cat examples:', len(examples['cat']['examples']))
print('num dog examples:', len(examples['dog']['examples']))
num validation examples: 320
num cat examples: 149
num dog examples: 171
2022-01-07 19:54:14.702877: W tensorflow/core/kernels/data/cache_dataset_ops.cc:768] The calling iterator did not fully read the dataset being cached. In order to avoid unexpected truncation of the dataset, the partially cached contents of the dataset  will be discarded. This can happen if you have an input pipeline similar to `dataset.cache().take(k).repeat()`. You should use `dataset.take(k).cache().repeat()` instead.
accuracy = compute_accuracy(examples['combined'])
cat_accuracy = compute_accuracy(examples['cat'])
dog_accuracy = compute_accuracy(examples['dog'])
10/10 [==============================] - 9s 12ms/step - loss: 0.0794 - binary_accuracy: 0.9812
5/5 [==============================] - 1s 41ms/step - loss: 0.0608 - binary_accuracy: 0.9933
6/6 [==============================] - 0s 34ms/step - loss: 0.0956 - binary_accuracy: 0.9708

השתמש בערכת הכלים של כרטיסי דגם

אתחל את ערכת הכלים של כרטיס הדגם

הצעד הראשון הוא לאתחל ModelCardToolkit אובייקט, אשר שומר על נכסים כוללים קובץ JSON כרטיס מודל ואת מסמך כרטיס מודל . שיחת ModelCardToolkit.scaffold_assets() כדי ליצור נכסים אלה ולהחזיר ModelCard אובייקט.

# https://github.com/tensorflow/model-card-toolkit/blob/master/model_card_toolkit/model_card_toolkit.py
model_card_dir = tempfile.mkdtemp()
mct = mctlib.ModelCardToolkit(model_card_dir)

# https://github.com/tensorflow/model-card-toolkit/blob/master/model_card_toolkit/model_card.py
model_card = mct.scaffold_assets()

רשום את כרטיס הדגם

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

שדות טקסט

פרטי דגם

model_card.model_details מכיל שדות metadata בסיסיים רבים כגון name , owners , וכן version . אתה יכול לספק תיאור עבור הדגם שלך overview השדה.

model_card.model_details.name = 'Fine-tuned MobileNetV2 Model for Cats vs. Dogs'
model_card.model_details.overview = (
    'This model distinguishes cat and dog images. It uses the MobileNetV2 '
    'architecture (https://arxiv.org/abs/1801.04381) and is trained on the '
    'Cats vs Dogs dataset '
    '(https://www.tensorflow.org/datasets/catalog/cats_vs_dogs). This model '
    'performed with high accuracy on both Cat and Dog images.'
)
model_card.model_details.owners = [
  mctlib.Owner(name='Model Cards Team', contact='model-cards@google.com')
]
model_card.model_details.version = mctlib.Version(name='v1.0', date='08/28/2020')
model_card.model_details.references = [
    mctlib.Reference(reference='https://www.tensorflow.org/guide/keras/transfer_learning'),
    mctlib.Reference(reference='https://arxiv.org/abs/1801.04381'),
]
model_card.model_details.licenses = [mctlib.License(identifier='Apache-2.0')]
model_card.model_details.citations = [mctlib.Citation(citation='https://github.com/tensorflow/model-card-toolkit/blob/master/model_card_toolkit/documentation/examples/Standalone_Model_Card_Toolkit_Demo.ipynb')]
ניתוח כמותי

model_card.quantitative_analysis מכיל מידע על מדדי הביצועים של מודל.

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

model_card.quantitative_analysis.performance_metrics = [
  mctlib.PerformanceMetric(type='accuracy', value=str(accuracy)),
  mctlib.PerformanceMetric(type='accuracy', value=str(cat_accuracy), slice='cat'),
  mctlib.PerformanceMetric(type='accuracy', value=str(dog_accuracy), slice='Dog'),
]
שיקולים

model_card.considerations מכיל לסייג מידע על המודל שלך - מה הם מקרי השימוש הנכונים, מה הם מגבלות שמשתמשות צריך לזכור, מה הם השיקולים האתיים של יישום, וכו '

model_card.considerations.use_cases = [
    mctlib.UseCase(description='This model classifies images of cats and dogs.')
]
model_card.considerations.limitations = [
    mctlib.Limitation(description='This model is not able to classify images of other classes.')
]
model_card.considerations.ethical_considerations = [mctlib.Risk(
    name=
        'While distinguishing between cats and dogs is generally agreed to be '
        'a benign application of machine learning, harmful results can occur '
        'when the model attempts to classify images that don’t contain cats or '
        'dogs.',
    mitigation_strategy=
        'Avoid application on non-dog and non-cat images.'
)]

שדות גרפים

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

model_card יש שלושה חלקים עבור גרפים - model_card.model_parameters.data.train.graphics להכשרת סטטיסטיקת נתון, model_card.model_parameters.data.eval.graphics עבור סטטיסטיקה במערך הערכה, ואת model_card.quantitative_analysis.graphics לניתוח כמותי של ביצועי מודל.

גרפים מאוחסנים מחרוזות בבסיס 64 . אם יש לך matplotlib דמות, אתה יכול להמיר אותו למחרוזת base64 עם model_card_toolkit.utils.graphics.figure_to_base64str() .

# Validation Set Size Bar Chart
fig, ax = plt.subplots()
width = 0.75
rects0 = ax.bar(0, len(examples['combined']['examples']), width, label='Overall')
rects1 = ax.bar(1, len(examples['cat']['examples']), width, label='Cat')
rects2 = ax.bar(2, len(examples['dog']['examples']), width, label='Dog')
ax.set_xticks(np.arange(3))
ax.set_xticklabels(['Overall', 'Cat', 'Dog'])
ax.set_ylabel('Validation Set Size')
ax.set_xlabel('Slices')
ax.set_title('Validation Set Size for Slices')
validation_set_size_barchart = figure_to_base64str(fig)

png

# Acuracy Bar Chart
fig, ax = plt.subplots()
width = 0.75
rects0 = ax.bar(0, accuracy, width, label='Overall')
rects1 = ax.bar(1, cat_accuracy, width, label='Cat')
rects2 = ax.bar(2, dog_accuracy, width, label='Dog')
ax.set_xticks(np.arange(3))
ax.set_xticklabels(['Overall', 'Cat', 'Dog'])
ax.set_ylabel('Accuracy')
ax.set_xlabel('Slices')
ax.set_title('Accuracy on Slices')
accuracy_barchart = figure_to_base64str(fig)

png

עכשיו אנחנו יכולים להוסיף אותם שלנו ModelCard .

model_card.model_parameters.data.append(mctlib.Dataset())
model_card.model_parameters.data[0].graphics.collection = [
  mctlib.Graphic(name='Validation Set Size', image=validation_set_size_barchart),
]
model_card.quantitative_analysis.graphics.collection = [
  mctlib.Graphic(name='Accuracy', image=accuracy_barchart),
]

צור את כרטיס הדגם

בואו ניצור את מסמך כרטיס הדגם. פורמטים זמינים מאוחסנים model_card_toolkit / תבנית . כאן, נדגים את הפורמטים HTML ו-Markdown.

ראשית, אנחנו צריכים לעדכן את ModelCardToolkit עם המילה האחרונה ModelCard .

mct.update_model_card(model_card)

עכשיו, ModelCardToolkit יכול ליצור מסמך כרטיס דגם עם ModelCardToolkit.export_format() .

# Generate a model card document in HTML (default)
html_doc = mct.export_format()

# Display the model card document in HTML
display.display(display.HTML(html_doc))

אתה יכול גם להוציא כרטיס דגם בפורמטים אחרים, כמו Markdown.

# Generate a model card document in Markdown
md_path = os.path.join(model_card_dir, 'template/md/default_template.md.jinja')
md_doc = mct.export_format(template_path=md_path, output_file='model_card.md')

# Display the model card document in Markdown
display.display(display.Markdown(md_doc))

כרטיס דגם לדגם MobileNetV2 מכוון לחתולים לעומת כלבים

פרטי דגם

סקירה כללית

דגם זה מבדיל בין תמונות של חתול וכלב. היא משתמשת בארכיטקטורת MobileNetV2 ( https://arxiv.org/abs/1801.04381 ) והוא מאומן על חתולים לעומת הנתונים כלבים ( https://www.tensorflow.org/datasets/catalog/cats_vs_dogs ). דגם זה ביצע בדיוק גבוה בתמונות של חתול וכלב.

גִרְסָה

שם: v1.0

תאריך: 28/08/2020

בעלים

  • צוות כרטיסי מודל, model-cards@google.com

רישיונות

  • Apache-2.0

הפניות

ציטוטים

שיקולים

מקרי שימוש

  • מודל זה מסווג תמונות של חתולים וכלבים.

מגבלות

  • מודל זה אינו מסוגל לסווג תמונות של מחלקות אחרות.

שיקולים אתיים

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

גרָפִיקָה

גודל סט אימות

דיוק

מדדים

שֵׁם ערך
דיוק 0.981249988079071
דיוק, חתול 0.9932885766029358
דיוק, כלב 0.9707602262496948