Aprenda o que há de mais recente em aprendizado de máquina, IA generativa e muito mais no WiML Symposium 2023 Registre-se

Esta página foi traduzida pela API Cloud Translation.

Demonstração do kit de ferramentas de cartão modelo autônomo

Este bloco de notas "autônomo" demonstra o uso do Model Card Toolkit sem o contexto TFX / MLMD. Para aprender a usar o Modelo Cartão Toolkit com TFX / MLMD, verifique MLMD Modelo Cartão Toolkit de demonstração .

Ver no TensorFlow.org

Executar no Google Colab

Ver no GitHub

Baixar caderno

Objetivo

Este bloco de notas demonstra como gerar um Model Card usando o Model Card Toolkit em um ambiente Jupyter / Colab. Você pode aprender mais sobre modelos de cartões em https://modelcards.withgoogle.com/about

Estamos usando um modelo Keras nesta demonstração. Mas a lógica abaixo também se aplica a outras estruturas de ML em geral.

Configurar

Primeiro precisamos a) instalar e importar os pacotes necessários eb) baixar os dados.

Faça upgrade para o Pip 20.2 e instale o 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'

Você reiniciou o tempo de execução?

Se você estiver usando o Google Colab, na primeira vez que executar a célula acima, será necessário reiniciar o tempo de execução (Tempo de execução> Reiniciar tempo de execução ...). Isso ocorre devido à maneira como o Colab carrega os pacotes.

Importações

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

Usaremos um modelo pré-treinado com arquitetura baseada off MobileNetV2 , um popular 16-camada modelo de classificação de imagem. Nosso modelo foi treinado para distinguir entre betweens cães e gatos usando os gatos vs Dogs conjunto de dados. O treinamento do modelo foi baseado no tutorial aprendizagem transferência 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 dados

No conjunto de dados gatos vs cães, rótulo = 0 corresponde a gatos, enquanto rótulo = 1 corresponde a cães.

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

Use o Model Card Toolkit

Inicialize o Model Card Toolkit

O primeiro passo é inicializar um ModelCardToolkit objeto, que mantém ativos, incluindo um arquivo JSON cartão de modelo e documento cartão modelo . Chamada ModelCardToolkit.scaffold_assets() para gerar esses ativos e retornar um 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()

Faça anotações no cartão do modelo

O ModelCard objecto devolvido por scaffold_assets() tem muitos campos que podem ser modificados directamente. Esses campos são renderizados no documento final do Cartão de Modelo gerado. Para uma lista completa, consulte model_card.py . Veja a documentação para mais detalhes.

Campos de Texto

Detalhes do modelo

model_card.model_details contém muitos campos de metadados básicos, como name , owners , e version . Você pode fornecer uma descrição para o seu modelo na 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álise quantitativa

model_card.quantitative_analysis contém informações sobre métricas de desempenho de um modelo.

Abaixo, criamos alguns valores de métrica de desempenho sintéticos para um modelo hipotético construído em nosso conjunto de dados.

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

Considerações

model_card.considerations contém qualificando informações sobre o seu modelo - quais são os casos de uso apropriados, quais são as limitações que os usuários devem ter em mente, quais são as considerações éticas de aplicação, 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 do gráfico

Geralmente, é uma prática recomendada que um relatório forneça informações sobre os dados de treinamento de um modelo e seu desempenho nos dados de avaliação. O Model Card Toolkit permite que os usuários codifiquem essas informações em visualizações, renderizadas no Model Card.

model_card tem três seções para gráficos - model_card.model_parameters.data.train.graphics para a formação de conjuntos de dados estatísticas, model_card.model_parameters.data.eval.graphics para as estatísticas do conjunto de dados de avaliação e model_card.quantitative_analysis.graphics de análise quantitativa de desempenho do modelo.

Os gráficos são armazenados como base64 cordas . Se você tem um matplotlib figura, você pode convertê-lo para uma string base64 com 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

Agora podemos adicioná-los ao nosso 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),
]

Gere o cartão de modelo

Vamos gerar o documento Model Card. Os formatos disponíveis são armazenados em model_card_toolkit / template . Aqui, vamos demonstrar os formatos HTML e Markdown.

Em primeiro lugar, é preciso atualizar o ModelCardToolkit com a mais recente ModelCard .

mct.update_model_card(model_card)

Agora, a ModelCardToolkit pode gerar um documento Modelo Cartão com 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))

Você também pode gerar um cartão de modelo em outros 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))

Cartão de modelo para modelo MobileNetV2 ajustado para gatos e cães

Detalhes do modelo

Visão geral

Este modelo distingue imagens de cães e gatos. Ele usa a arquitetura MobileNetV2 ( https://arxiv.org/abs/1801.04381 ) e é treinado sobre os gatos contra cães conjunto de dados ( https://www.tensorflow.org/datasets/catalog/cats_vs_dogs ). Este modelo foi executado com alta precisão em imagens de gatos e cachorros.

Versão

nome: v1.0

data: 28/08/2020

os Proprietários

Equipe de cartões de modelo, model-cards@google.com

Licenças

Apache-2.0

Referências

Citações

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

Considerações

Casos de Uso

Este modelo classifica imagens de cães e gatos.

Limitações

Este modelo não consegue classificar imagens de outras classes.

Considerações éticas

Risco: embora a distinção entre cães e gatos seja geralmente considerada uma aplicação benigna do aprendizado de máquina, podem ocorrer resultados prejudiciais quando o modelo tenta classificar imagens que não contêm cães ou gatos.
- Estratégia de atenuação: evite a aplicação em imagens que não sejam de cães e gatos.

Gráficos

Tamanho do conjunto de validação

Precisão

Métricas

Nome	Valor
precisão	0,981249988079071
precisão gato	0,9932885766029358
precisão, cão	0,9707602262496948