Questo notebook "autonomo" dimostra l'utilizzo del Model Card Toolkit senza il contesto TFX/MLMD. Per imparare a utilizzare modello di scheda Toolkit con TFX / MLMD, si prega di controllare MLMD modello di scheda Toolkit Demo .
 Visualizza su TensorFlow.org |  Esegui in Google Colab |  Visualizza su GitHub |  Scarica taccuino |
Obbiettivo
Questo notebook mostra come generare una Model Card utilizzando il Model Card Toolkit in un ambiente Jupyter/Colab. È possibile saperne di più su modelli di tessere a https://modelcards.withgoogle.com/about
In questa demo utilizziamo un modello Keras. Ma la logica seguente si applica anche ad altri framework ML in generale.
Impostare
Per prima cosa dobbiamo a) installare e importare i pacchetti necessari e b) scaricare i dati.
Aggiorna a Pip 20.2 e installa il Model Card Toolkit
pip install --upgrade pip==20.2pip install 'model-card-toolkit>=1.0.0,<1.1'pip install 'tensorflow>=2.3.1'
Hai riavviato il runtime?
Se stai utilizzando Google Colab, la prima volta che esegui la cella sopra, devi riavviare il runtime (Runtime > Riavvia runtime...). Ciò è dovuto al modo in cui Colab carica i pacchetti.
Importazioni
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
Modello
Useremo un modello preaddestrato con l'architettura in base al largo MobileNetV2 , un 16-strato popolare modello di classificazione delle immagini. Il nostro modello è stato addestrato per distinguere tra Betweens cani e gatti utilizzando i gatti contro i cani insieme di dati. La formazione modello era basato sul trasferimento tensorflow apprendimento esercitazione .
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.
set di dati
Nel set di dati gatti contro cani, label=0 corrisponde ai gatti mentre label=1 corrisponde ai cani.
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
Usa il kit di strumenti per schede modello
Inizializzare il Model Card Toolkit
Il primo passo è quello di inizializzare un ModelCardToolkit oggetto, che mantiene le attività tra cui un file di JSON carta modello e documento carta modello . Chiamata ModelCardToolkit.scaffold_assets() per generare tali attività e restituiscono un ModelCard oggetto.
# 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()
Annota la scheda modello
La ModelCard oggetto restituito da scaffold_assets() ha molti campi che possono essere modificati direttamente. Questi campi vengono resi nel documento finale della Model Card generato. Per un elenco completo, vedere model_card.py . Vedere la documentazione per maggiori dettagli.
Campi di testo
Dettagli del modello
model_card.model_details contiene molti campi di metadati di base come name , owners , e version . È possibile fornire una descrizione del modello nella overview campo.
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')]
Analisi quantitativa
model_card.quantitative_analysis contiene informazioni sulle metriche di performance del modello.
Di seguito, creiamo alcuni valori sintetici delle metriche delle prestazioni per un modello ipotetico costruito sul nostro set di dati.
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'),
]
Considerazioni
model_card.considerations contiene qualificanti informazioni sul modello - quali sono i casi di utilizzo appropriati, quali sono le limitazioni che gli utenti dovrebbero tenere a mente, quali sono le considerazioni etiche di applicazione, 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.'
)]
Campi del grafico
Spesso è consigliabile che un report fornisca informazioni sui dati di training di un modello e sulle sue prestazioni attraverso i dati di valutazione. Model Card Toolkit consente agli utenti di codificare queste informazioni nelle visualizzazioni, rese nella Model Card.
model_card ha tre sezioni per i grafici - model_card.model_parameters.data.train.graphics per la formazione di dataset statistiche, model_card.model_parameters.data.eval.graphics per le statistiche di valutazione DataSet e model_card.quantitative_analysis.graphics per l'analisi quantitativa delle prestazioni del modello.
I grafici sono memorizzati come base64 stringhe . Se si dispone di un matplotlib figura, è possibile convertire in una stringa base64 con 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)
Ora possiamo aggiungere alla nostra 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),
]
Genera la scheda modello
Generiamo il documento Model Card. I formati disponibili sono conservati a model_card_toolkit / template . Qui dimostreremo i formati HTML e Markdown.
In primo luogo, abbiamo bisogno di aggiornare il ModelCardToolkit con l'ultima ModelCard .
mct.update_model_card(model_card)
Ora, il ModelCardToolkit in grado di generare un documento modello di scheda con 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))
Puoi anche produrre una scheda modello in altri formati, come 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))
Scheda modello per il modello MobileNetV2 ottimizzato per gatti contro cani
Dettagli del modello
Panoramica
Questo modello distingue le immagini di cani e gatti. Esso utilizza l'architettura MobileNetV2 ( https://arxiv.org/abs/1801.04381 ) ed è addestrato sui gatti contro i cani dataset ( https://www.tensorflow.org/datasets/catalog/cats_vs_dogs ). Questo modello ha eseguito con elevata precisione sia le immagini di gatto che di cane.
Versione
nome: v1.0
data: 28/08/2020
Proprietari
- Model Cards Team, model-cards@google.com
Licenze
- Apache-2.0
Riferimenti
citazioni
Considerazioni
Casi d'uso
- Questo modello classifica le immagini di cani e gatti.
Limitazioni
- Questo modello non è in grado di classificare immagini di altre classi.
Considerazioni etiche
- Rischio: sebbene sia generalmente accettato che la distinzione tra cani e gatti sia un'applicazione benigna dell'apprendimento automatico, possono verificarsi risultati dannosi quando il modello tenta di classificare immagini che non contengono cani o gatti.
- Strategia di mitigazione: evitare l'applicazione su immagini senza cani e senza gatti.
Grafica
Dimensione set di convalida
Precisione
Metrica
| Nome | Valore |
|---|---|
| precisione | 0.981249988079071 |
| precisione, gatto | 0.9932885766029358 |
| precisione, cane | 0.9707602262496948 |