La journée communautaire ML est le 9 novembre ! Rejoignez - nous pour les mises à jour de tensorflow, JAX et plus En savoir plus

Démo de la boîte à outils de la carte modèle autonome

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 -q --upgrade pip==20.2
pip install -q 'model-card-toolkit>=0.1.1,<0.2'
pip install -q '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
from model_card_toolkit import ModelCardToolkit
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)

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
accuracy = compute_accuracy(examples['combined'])
cat_accuracy = compute_accuracy(examples['cat'])
dog_accuracy = compute_accuracy(examples['dog'])
10/10 [==============================] - 2s 163ms/step - loss: 0.0794 - binary_accuracy: 0.9812
5/5 [==============================] - 1s 132ms/step - loss: 0.0608 - binary_accuracy: 0.9933
6/6 [==============================] - 1s 135ms/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 = 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 = [
  {'name': 'Model Cards Team', 'contact': 'model-cards@google.com'}
]
model_card.model_details.version = {'name': 'v1.0', 'date': '08/28/2020'}
model_card.model_details.references = [
    'https://www.tensorflow.org/guide/keras/transfer_learning',
    'https://arxiv.org/abs/1801.04381',
]
model_card.model_details.license = 'Apache-2.0'
model_card.model_details.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 = [
  {'type': 'accuracy', 'value': accuracy},
  {'type': 'accuracy', 'value': cat_accuracy, 'slice': 'cat'},
  {'type': 'accuracy', 'value': 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 = [
    'This model classifies images of cats and dogs.'
]
model_card.considerations.limitations = [
    'This model is not able to classify images of other classes.'
]
model_card.considerations.ethical_considerations = [{
    '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)

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

Maintenant , nous pouvons les ajouter à notre ModelCard en ModelCard .

model_card.model_parameters.data.eval.graphics.collection = [
  {'name': 'Validation Set Size', 'image': validation_set_size_barchart},
]
model_card.quantitative_analysis.graphics.collection = [
  {'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_json(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(md_path, '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

Licence

Apache-2.0

Les références

Citation

https://github.com/tensorflow/model-card-toolkit/blob/master/model_card_toolkit/documentation/examples/Standalone_Model_Card_Toolkit_Demo.ipynb

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

Ensemble d'évaluation

Taille de l'ensemble de validation

Analyse quantitative

Précision

Métrique

Nom Valeur
précision 0.981249988079071
précision, chat 0.9932885766029358
précision, Chien 0.9707602262496948