Wersja demonstracyjna samodzielnego zestawu kart modeli

Ten „samodzielny” notatnik demonstruje używanie Model Card Toolkit bez kontekstu TFX/MLMD. Aby dowiedzieć się, jak korzystać z modelu karty Toolkit TFX / MLMD, proszę sprawdzić MLMD model karty Toolkit Demo .

Zobacz na TensorFlow.org Uruchom w Google Colab Zobacz na GitHub Pobierz notatnik

Cel

Ten notatnik pokazuje, jak wygenerować kartę modelu za pomocą zestawu narzędzi kart modelu w środowisku Jupyter/Colab. Możesz dowiedzieć się więcej na temat modeli kart na https://modelcards.withgoogle.com/about

W tym demo używamy modelu Keras. Ale poniższa logika odnosi się również do innych frameworków ML.

Ustawiać

Najpierw musimy a) zainstalować i zaimportować niezbędne pakiety oraz b) pobrać dane.

Uaktualnij do wersji Pip 20.2 i zainstaluj zestaw narzędzi Model Card

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

Czy uruchomiłeś ponownie środowisko wykonawcze?

Jeśli używasz Google Colab, przy pierwszym uruchomieniu powyższej komórki musisz ponownie uruchomić środowisko wykonawcze (Runtime > Restart runtime ...). Wynika to ze sposobu, w jaki Colab ładuje paczki.

Import

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

Model

Użyjemy pretrained model z architekturą opartą off MobileNetV2 , popularnej 16-warstwowego modelu klasyfikacji obrazu. Nasz model został przeszkolony odróżnić pośredników kotów i psów z zastosowaniem Koty vs Dogs zbiorze. Model szkolenia został oparty na poradniku uczenia transferowego 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.

Zbiór danych

W zestawie danych cats-vs-dogs, label=0 odpowiada kotom, a label=1 odpowiada psom.

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

Użyj zestawu narzędzi do kart modeli

Zainicjuj zestaw narzędzi karty modelu

Pierwszym krokiem jest, aby zainicjować ModelCardToolkit obiekt, który utrzymuje aktywa w tym modelu karty pliku JSON i dokumentów model karty . Połączeń ModelCardToolkit.scaffold_assets() , aby wygenerować te aktywa i zwracają ModelCard obiekt.

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

Opisz kartę modelu

ModelCard obiekt zwrócony przez scaffold_assets() ma wiele pól, które mogą być bezpośrednio modyfikowane. Pola te są renderowane w końcowym wygenerowanym dokumencie karty modelu. Pełną listę można znaleźć model_card.py . Zobacz dokumentację po więcej szczegółów.

Pola tekstowe

Szczegóły modelu

model_card.model_details zawiera wiele podstawowych pól metadanych, takich jak name , owners i version . Można podać opis dla danego modelu w overview dziedzinie.

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')]
Analiza ilościowa

model_card.quantitative_analysis zawiera informacje na temat wskaźników wydajności danego modelu.

Poniżej tworzymy kilka syntetycznych wartości metryk wydajności dla hipotetycznego modelu zbudowanego na naszym zbiorze danych.

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'),
]
Rozważania

model_card.considerations zawiera objaśnieniami o modelu - jakie są odpowiednie przypadki użycia, jakie są ograniczenia, które użytkownicy powinni pamiętać, jakie są względy etyczne aplikacji itp

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

Pola wykresu

Często najlepszym rozwiązaniem jest, aby raport zawierał informacje o danych uczących modelu i jego wydajności w danych oceny. Model Card Toolkit umożliwia użytkownikom kodowanie tych informacji w wizualizacjach renderowanych na karcie modelu.

model_card ma trzy sekcje dla wykresów - model_card.model_parameters.data.train.graphics na szkolenie zestawu danych statystycznych, model_card.model_parameters.data.eval.graphics dla zestawu danych statystycznych i oceny model_card.quantitative_analysis.graphics analizy ilościowej wydajności modelu.

Wykresy są zapisywane jako base64 ciągi . Jeśli masz matplotlib rysunek, można przekonwertować go na ciąg base64 z 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

Teraz możemy dodać je do naszej 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),
]

Wygeneruj kartę modelu

Wygenerujmy dokument Model Card. Dostępne formaty są przechowywane w model_card_toolkit / szablonu . Tutaj zademonstrujemy formaty HTML i Markdown.

Po pierwsze, musimy zaktualizować ModelCardToolkit z najnowszych ModelCard .

mct.update_model_card(model_card)

Teraz ModelCardToolkit może wygenerować dokument modelu karty z 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))

Możesz także wyprowadzić kartę modelu w innych formatach, takich jak 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))

Karta modelu dla precyzyjnie dostrojonego modelu MobileNetV2 dla kotów i psów

Szczegóły modelu

Przegląd

Model ten wyróżnia wizerunki kotów i psów. Wykorzystuje architekturę MobileNetV2 ( https://arxiv.org/abs/1801.04381 ) i jest szkolony na zbiorze Koty vs Dogs ( https://www.tensorflow.org/datasets/catalog/cats_vs_dogs ). Ten model działał z dużą dokładnością zarówno na zdjęciach kota, jak i psa.

Wersja

nazwa: v1.0

data: 28.08.2020

Właściciele

  • Zespół ds. kart modelek, model-cards@google.com

Licencje

  • Apache-2,0

Bibliografia

Cytaty

Rozważania

Przypadków użycia

  • Model ten klasyfikuje wizerunki kotów i psów.

Ograniczenia

  • Model ten nie jest w stanie sklasyfikować zdjęć innych klas.

Względy etyczne

  • Ryzyko: Chociaż ogólnie uważa się, że rozróżnianie kotów i psów jest łagodnym zastosowaniem uczenia maszynowego, szkodliwe wyniki mogą wystąpić, gdy model próbuje sklasyfikować obrazy, które nie zawierają kotów ani psów.
    • Strategia łagodzenia: Unikaj aplikacji na zdjęciach innych niż pies i kot.

Grafika

Rozmiar zestawu walidacyjnego

Dokładność

Metryka

Nazwa Wartość
dokładność 0,981249988079071
dokładność, kot 0.9932885766029358
dokładność, Pies 0.9707602262496948