Eine Frage haben? Verbinden Sie sich mit der Community im TensorFlow Forum Visit Forum

Standalone Model Card Toolkit Demo

Dieses "eigenständige" Notizbuch demonstriert die Verwendung des Model Card Toolkit ohne den TFX / MLMD-Kontext. Informationen zur Verwendung des Model Card Toolkit mit TFX / MLMD finden Sie in der Demo zum MLMD Model Card Toolkit .

Ansicht auf TensorFlow.org In Google Colab ausführen Ansicht auf GitHub Notizbuch herunterladen

Zielsetzung

Dieses Notizbuch zeigt, wie Sie mit dem Model Card Toolkit in einer Jupyter / Colab-Umgebung eine Modellkarte erstellen. Weitere Informationen zu Modellkarten finden Sie unter https://modelcards.withgoogle.com/about

In dieser Demo verwenden wir ein Keras-Modell. Die folgende Logik gilt jedoch auch für andere ML-Frameworks im Allgemeinen.

Einrichten

Wir müssen zuerst a) die erforderlichen Pakete installieren und importieren und b) die Daten herunterladen.

Aktualisieren Sie auf Pip 20.2 und installieren Sie das Model Card Toolkit

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'

Haben Sie die Laufzeit neu gestartet?

Wenn Sie Google Colab verwenden und die obige Zelle zum ersten Mal ausführen, müssen Sie die Laufzeit neu starten (Laufzeit> Laufzeit neu starten ...). Dies liegt an der Art und Weise, wie Colab Pakete lädt.

Importe

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

Modell

Wir werden ein vorab trainiertes Modell mit einer Architektur verwenden, die auf MobileNetV2 basiert, einem beliebten 16-Schicht- Bildklassifizierungsmodell . Unser Modell wurde trainiert, um zwischen Katzen und Hunden anhand des Datensatzes Katzen gegen Hunde zu unterscheiden . Das Modelltraining basierte auf dem TensorFlow-Transfer-Lernprogramm .

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)

Datensatz

Im Katzen-gegen-Hunde-Datensatz entspricht label = 0 Katzen, während label = 1 Hunden entspricht.

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

Verwenden Sie das Model Card Toolkit

Initialisieren Sie das Model Card Toolkit

Der erste Schritt besteht darin, ein ModelCardToolkit Objekt zu initialisieren, das Assets verwaltet, einschließlich einer Modellkarten-JSON-Datei und eines Modellkartendokuments . Rufen Sie ModelCardToolkit.scaffold_assets() auf, um diese Assets zu generieren und ein ModelCard Objekt zurückzugeben.

# 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()

Kommentieren Sie die Modellkarte

Das von scaffold_assets() ModelCard Objekt enthält viele Felder, die direkt geändert werden können. Diese Felder werden im endgültig generierten Modellkartendokument gerendert. Eine umfassende Liste finden Sie unter model_card.py . Weitere Informationen finden Sie in der Dokumentation .

Textfelder

Modelldetails

model_card.model_details enthält viele grundlegende Metadatenfelder wie name , owners und version . Im overview können Sie eine Beschreibung für Ihr Modell 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 = [
  {'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'
Quantitative Analyse

model_card.quantitative_analysis enthält Informationen zu den Leistungsmetriken eines Modells.

Im Folgenden erstellen wir einige synthetische Leistungsmetrikwerte für ein hypothetisches Modell, das auf unserem Datensatz basiert.

model_card.quantitative_analysis.performance_metrics = [
  {'type': 'accuracy', 'value': accuracy},
  {'type': 'accuracy', 'value': cat_accuracy, 'slice': 'cat'},
  {'type': 'accuracy', 'value': dog_accuracy, 'slice': 'Dog'},
]
Überlegungen

model_card.considerations enthält qualifizierende Informationen zu Ihrem Modell - welche Anwendungsfälle sind angemessen, welche Einschränkungen sollten Benutzer beachten, welche ethischen Überlegungen gelten für die Anwendung usw.

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.'
}]

Diagrammfelder

Es ist häufig eine bewährte Methode für einen Bericht, Informationen zu den Trainingsdaten eines Modells und seiner Leistung über die Bewertungsdaten hinweg bereitzustellen. Mit dem Model Card Toolkit können Benutzer diese Informationen in Visualisierungen codieren, die auf der Model Card gerendert werden.

model_card besteht aus drei Abschnitten für Diagramme: model_card.model_parameters.data.train.graphics für die Statistik von Trainingsdatensätzen, model_card.model_parameters.data.eval.graphics für die Statistik von Bewertungsdatensätzen und model_card.quantitative_analysis.graphics für die quantitative Analyse der Modellleistung.

Diagramme werden als base64-Zeichenfolgen gespeichert. Wenn Sie eine matplotlib- Figur haben, können Sie sie mit model_card_toolkit.utils.graphics.figure_to_base64str() in eine base64-Zeichenfolge 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

Jetzt können wir sie unserer 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},
]

Generieren Sie die Modellkarte

Lassen Sie uns das Modellkartendokument generieren. Verfügbare Formate werden unter model_card_toolkit / template gespeichert. Hier werden die HTML- und Markdown-Formate demonstriert.

Zuerst müssen wir das ModelCardToolkit mit der neuesten ModelCard .

mct.update_model_card_json(model_card)

Jetzt kann das ModelCardToolkit mit ModelCardToolkit.export_format() ein Model Card-Dokument 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))

Sie können eine Modellkarte auch in anderen Formaten wie Markdown ausgeben.

# 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))

Modellkarte für fein abgestimmtes MobileNetV2-Modell für Katzen gegen Hunde

Modelldetails

Überblick

Dieses Modell unterscheidet Katzen- und Hundebilder. Es verwendet die MobileNetV2-Architektur ( https://arxiv.org/abs/1801.04381 ) und ist im Datensatz Cats vs Dogs ( https://www.tensorflow.org/datasets/catalog/cats_vs_dogs ) geschult. Dieses Modell wurde sowohl bei Katzen- als auch bei Hundebildern mit hoher Genauigkeit ausgeführt.

Ausführung

Name: v1.0

Datum: 28.08.2020

Besitzer

  • Model Cards Team, model-cards@google.com

Lizenz

Apache-2.0

Verweise

Zitat

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

Überlegungen

Anwendungsfälle

  • Dieses Modell klassifiziert Bilder von Katzen und Hunden.

Einschränkungen

  • Dieses Modell kann keine Bilder anderer Klassen klassifizieren.

Ethische Überlegungen

  • Risiko: Während die Unterscheidung zwischen Katzen und Hunden im Allgemeinen als harmlose Anwendung des maschinellen Lernens angesehen wird, können schädliche Ergebnisse auftreten, wenn das Modell versucht, Bilder zu klassifizieren, die keine Katzen oder Hunde enthalten.
    • Schadensbegrenzungsstrategie: Vermeiden Sie die Anwendung auf Nicht-Hunde- und Nicht-Katzen-Bildern.

Grafik

Eval Set

Größe des Validierungssatzes

Quantitative Analyse

Richtigkeit

Metriken

Name Wert
Richtigkeit 0,981249988079071
Genauigkeit, Kat 0,9932885766029358
Genauigkeit, Hund 0,9707602262496948