Ce bloc-notes "autonome" illustre l'utilisation de Model Card Toolkit sans le contexte TFX/MLMD. Pour savoir comment utiliser le modèle de carte Toolkit avec TFX / MLMD, s'il vous plaît vérifier MLMD Model Card Toolkit Demo .
Voir sur TensorFlow.org | Exécuter dans Google Colab | Voir sur GitHub | Télécharger le cahier |
Objectif
Ce bloc-notes montre comment générer une carte modèle à l'aide du kit d'outils de carte modèle dans un environnement Jupyter/Colab. Vous pouvez en savoir plus sur les cartes de modèle à https://modelcards.withgoogle.com/about
Nous utilisons un modèle Keras dans cette démo. Mais la logique ci-dessous s'applique également aux autres cadres de ML en général.
Installer
Nous devons d'abord a) installer et importer les packages nécessaires, et b) télécharger les données.
Mettez à niveau vers Pip 20.2 et installez la boîte à outils de la carte modèle
pip install --upgrade pip==20.2
pip install 'model-card-toolkit>=1.0.0,<1.1'
pip install 'tensorflow>=2.3.1'
As-tu redémarré le runtime ?
Si vous utilisez Google Colab, la première fois que vous exécutez la cellule ci-dessus, vous devez redémarrer le runtime (Runtime > Redémarrer le runtime...). Cela est dû à la façon dont Colab charge les packages.
Importations
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
Modèle
Nous utiliserons un modèle avec une architecture à base de pré - entraîné de MobileNetV2 , un modèle de classification d'image 16 couches populaires. Notre modèle a été formé pour distinguer entre les chats et les chiens Betweens en utilisant les chats contre les chiens ensemble de données. La formation du modèle a été basé sur le tutoriel d'apprentissage de transfert de 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.
Base de données
Dans l'ensemble de données cats-vs-dogs, label=0 correspond aux chats tandis que label=1 correspond aux chiens.
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
Utiliser la boîte à outils de la carte modèle
Initialiser la boîte à outils de la carte modèle
La première étape consiste à initialiser un ModelCardToolkit
objet, qui maintient des actifs , y compris un fichier JSON de carte de modèle et le document carte de modèle . Appel ModelCardToolkit.scaffold_assets()
pour générer ces actifs et renvoient un ModelCard
en ModelCard
objet.
# 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()
Annoter la carte modèle
Le ModelCard
en scaffold_assets()
ModelCard
objet retourné par scaffold_assets()
a de nombreux domaines qui peuvent être modifiés directement. Ces champs sont rendus dans le document de carte modèle généré final. Pour une liste complète, voir model_card.py . Voir la documentation pour plus de détails.
Champs de texte
Détails du modèle
model_card.model_details
contient de nombreux champs de métadonnées de base tels que le name
, les owners
et la version
. Vous pouvez fournir une description de votre modèle dans la overview
terrain.
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')]
Analyse quantitative
model_card.quantitative_analysis
contient des informations sur les mesures de performance d'un modèle.
Ci-dessous, nous créons des valeurs de métriques de performances synthétiques pour un modèle hypothétique construit sur notre ensemble de données.
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'),
]
Considérations
model_card.considerations
contient qualifiants informations sur votre modèle - quels sont les cas d'utilisation appropriés, quelles sont les limites que les utilisateurs doivent garder à l' esprit, quelles sont les considérations éthiques d'application, etc.
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.'
)]
Champs de graphique
Il est souvent recommandé qu'un rapport fournisse des informations sur les données d'entraînement d'un modèle et ses performances dans les données d'évaluation. Model Card Toolkit permet aux utilisateurs d'encoder ces informations dans des visualisations, rendues dans la carte modèle.
model_card
comporte trois sections pour les graphiques - model_card.model_parameters.data.train.graphics
pour la formation dataset statistiques, model_card.model_parameters.data.eval.graphics
pour les statistiques de l' ensemble de données d'évaluation et model_card.quantitative_analysis.graphics
pour l' analyse quantitative de la performance du modèle.
Les graphiques sont stockés sous forme de chaînes de base64 . Si vous avez un matplotlib figure, vous pouvez le convertir en une chaîne base64 avec 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)
# 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)
Maintenant , nous pouvons les ajouter à notre ModelCard
en 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),
]
Générer la carte modèle
Générons le document Model Card. Les formats disponibles sont stockés à model_card_toolkit / modèle . Ici, nous allons démontrer les formats HTML et Markdown.
Tout d' abord, nous devons mettre à jour le ModelCardToolkit
avec les dernières ModelCard
en ModelCard
.
mct.update_model_card(model_card)
Maintenant, le ModelCardToolkit
peut générer un document carte modèle avec 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))
Vous pouvez également sortir une carte modèle dans d'autres formats, comme 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))
Carte modèle pour le modèle MobileNetV2 affiné pour les chats et les chiens
Détails du modèle
Aperçu
Ce modèle distingue les images de chat et de chien. Il utilise l'architecture MobileNetV2 ( https://arxiv.org/abs/1801.04381 ) et est formé sur les chats contre les chiens ensemble de données ( https://www.tensorflow.org/datasets/catalog/cats_vs_dogs ). Ce modèle a fonctionné avec une grande précision sur les images de chat et de chien.
Version
nom : v1.0
date : 28/08/2020
Les propriétaires
- Équipe des cartes modèles, model-cards@google.com
Licences
- Apache-2.0
Les références
Citations
Considérations
Cas d'utilisation
- Ce modèle classe les images de chats et de chiens.
Limites
- Ce modèle n'est pas capable de classer les images d'autres classes.
Considérations éthiques
- Risque : Bien que la distinction entre les chats et les chiens soit généralement considérée comme une application bénigne de l'apprentissage automatique, des résultats néfastes peuvent se produire lorsque le modèle tente de classer des images qui ne contiennent ni chats ni chiens.
- Stratégie d'atténuation : évitez l'application sur des images autres que des chiens et des chats.
Graphique
Taille de l'ensemble de validation
Précision
Métrique
Nom | Valeur |
---|---|
précision | 0.981249988079071 |
précision, chat | 0.9932885766029358 |
précision, Chien | 0.9707602262496948 |