Se usó la API de Cloud Translation para traducir esta página.

Demostración del kit de herramientas de tarjeta modelo independiente

Este cuaderno "independiente" demuestra el uso del kit de herramientas de tarjetas modelo sin el contexto TFX / MLMD. Para aprender a utilizar la tarjeta Modelo Toolkit con TFX / MLMD, compruebe MLMD modelo de tarjeta de juego de herramientas de demostración .

Ver en TensorFlow.org

Ejecutar en Google Colab

Ver en GitHub

Descargar cuaderno

Objetivo

Este cuaderno muestra cómo generar una tarjeta modelo utilizando el kit de herramientas de tarjeta modelo en un entorno de Jupyter / Colab. Usted puede aprender más sobre las tarjetas modelo en https://modelcards.withgoogle.com/about

Estamos usando un modelo de Keras en esta demostración. Pero la lógica siguiente también se aplica a otros marcos de ML en general.

Configuración

Primero necesitamos a) instalar e importar los paquetes necesarios, yb) descargar los datos.

Actualice a Pip 20.2 e instale Model Card Toolkit

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

¿Reinició el tiempo de ejecución?

Si está utilizando Google Colab, la primera vez que ejecuta la celda anterior, debe reiniciar el tiempo de ejecución (Tiempo de ejecución> Reiniciar tiempo de ejecución ...). Esto se debe a la forma en que Colab carga los paquetes.

Importaciones

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

Modelo

Vamos a utilizar un modelo pretrained con arquitectura basada fuera MobileNetV2 , un 16 capas populares modelo de clasificación de imágenes. Nuestro modelo ha sido entrenado para distinguir entre Betweens gatos y perros usando los Gatos vs Perros conjunto de datos. El modelo de formación se basa en el tutorial de aprendizaje transferencia 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.

Conjunto de datos

En el conjunto de datos de perros y gatos, la etiqueta = 0 corresponde a los gatos, mientras que la etiqueta = 1 corresponde a los perros.

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

Utilice el kit de herramientas de la tarjeta modelo

Inicializar el kit de herramientas de la tarjeta modelo

El primer paso es inicializar un ModelCardToolkit objeto, que mantiene activos incluyendo un archivo JSON modelo de tarjeta y el documento de modelo de tarjeta . Call ModelCardToolkit.scaffold_assets() para generar estos activos y devuelven un ModelCard objeto.

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

Anotar la tarjeta modelo

El ModelCard objeto devuelto por scaffold_assets() tiene muchos campos que se pueden modificar directamente. Estos campos se representan en el documento de tarjeta modelo generado final. Para una lista completa, consulte model_card.py . Ver la documentación para más detalles.

Campos de texto

Detalles del modelo

model_card.model_details contiene muchos campos de metadatos básicos como name , owners , y version . Puede proporcionar una descripción para su modelo en la overview de 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')]

Análisis cuantitativo

model_card.quantitative_analysis contiene información acerca de las métricas de rendimiento de un modelo.

A continuación, creamos algunos valores de métrica de rendimiento sintéticos para un modelo hipotético construido a partir de nuestro conjunto de datos.

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

Consideraciones

model_card.considerations contiene información contrastada acerca de su modelo - ¿Cuáles son los casos de uso adecuadas, ¿cuáles son las limitaciones que los usuarios deben tener en cuenta, ¿cuáles son las consideraciones éticas de la aplicación, 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.'
)]

Campos de gráfico

A menudo, es una buena práctica que un informe proporcione información sobre los datos de entrenamiento de un modelo y su rendimiento en los datos de evaluación. El kit de herramientas de la tarjeta modelo permite a los usuarios codificar esta información en visualizaciones, renderizadas en la tarjeta modelo.

model_card tiene tres secciones para gráficos - model_card.model_parameters.data.train.graphics para la formación de conjuntos de datos estadísticas, model_card.model_parameters.data.eval.graphics para las estadísticas de la evaluación de conjunto de datos, y model_card.quantitative_analysis.graphics de análisis cuantitativos de desempeño del modelo.

Los gráficos se almacenan como cadenas base64 . Si usted tiene un matplotlib figura, se puede convertir en una cadena de base 64 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)

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

Ahora podemos añadir a nuestra 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),
]

Generar la tarjeta modelo

Generemos el documento de la tarjeta modelo. Los formatos disponibles son almacenados a model_card_toolkit / plantilla . Aquí, demostraremos los formatos HTML y Markdown.

En primer lugar, tenemos que actualizar el ModelCardToolkit con la última ModelCard .

mct.update_model_card(model_card)

Ahora, el ModelCardToolkit puede generar un documento modelo de tarjeta 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))

También puede generar una tarjeta modelo en otros formatos, como 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))

Tarjeta modelo para el modelo MobileNetV2 ajustado para perros y gatos

Detalles del modelo

Descripción general

Este modelo distingue imágenes de perros y gatos. Se utiliza la arquitectura MobileNetV2 ( https://arxiv.org/abs/1801.04381 ) y está capacitado en los Gatos vs Perros conjunto de datos ( https://www.tensorflow.org/datasets/catalog/cats_vs_dogs ). Este modelo funcionó con alta precisión en imágenes de perros y gatos.

Versión

nombre: v1.0

fecha: 28/08/2020

Propietarios

Equipo de Model Cards, model-cards@google.com

Licencias

Apache-2.0

Referencias

Citas

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

Consideraciones

Casos de uso

Este modelo clasifica imágenes de perros y gatos.

Limitaciones

Este modelo no puede clasificar imágenes de otras clases.

Consideraciones éticas

Riesgo: aunque generalmente se acepta que distinguir entre gatos y perros es una aplicación benigna del aprendizaje automático, pueden producirse resultados dañinos cuando el modelo intenta clasificar imágenes que no contienen gatos o perros.
- Estrategia de mitigación: evite la aplicación en imágenes que no sean de perros ni de gatos.

Gráficos

Tamaño del conjunto de validación

Exactitud

Métrica

Nombre	Valor
exactitud	0.981249988079071
precisión, gato	0,9932885766029358
precisión, perro	0.9707602262496948