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.2pip 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)
# 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)
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
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 |