Ajuda a proteger a Grande Barreira de Corais com TensorFlow em Kaggle Junte Desafio

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 outros frameworks 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 -q --upgrade pip==20.2
pip install -q 'model-card-toolkit>=0.1.1,<0.2'
pip install -q '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, deverá reiniciar o tempo de execução (Tempo de execução> Reiniciar tempo de execução ...). Isso se deve à maneira como o Colab carrega os pacotes.

Importações

import tensorflow as tf
import numpy as np
from model_card_toolkit import ModelCardToolkit
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)

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
accuracy = compute_accuracy(examples['combined'])
cat_accuracy = compute_accuracy(examples['cat'])
dog_accuracy = compute_accuracy(examples['dog'])
10/10 [==============================] - 2s 163ms/step - loss: 0.0794 - binary_accuracy: 0.9812
5/5 [==============================] - 1s 132ms/step - loss: 0.0608 - binary_accuracy: 0.9933
6/6 [==============================] - 1s 135ms/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 = 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 = [
  {'name': 'Model Cards Team', 'contact': 'model-cards@google.com'}
]
model_card.model_details.version = {'name': 'v1.0', 'date': '08/28/2020'}
model_card.model_details.references = [
    'https://www.tensorflow.org/guide/keras/transfer_learning',
    'https://arxiv.org/abs/1801.04381',
]
model_card.model_details.license = 'Apache-2.0'
model_card.model_details.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 = [
  {'type': 'accuracy', 'value': accuracy},
  {'type': 'accuracy', 'value': cat_accuracy, 'slice': 'cat'},
  {'type': 'accuracy', 'value': 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 = [
    'This model classifies images of cats and dogs.'
]
model_card.considerations.limitations = [
    'This model is not able to classify images of other classes.'
]
model_card.considerations.ethical_considerations = [{
    '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.eval.graphics.collection = [
  {'name': 'Validation Set Size', 'image': validation_set_size_barchart},
]
model_card.quantitative_analysis.graphics.collection = [
  {'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_json(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(md_path, '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ça

Apache-2.0

Referências

Citação

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

Eval Set

Tamanho do conjunto de validação

Análise quantitativa

Precisão

Métricas

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