keras_example.ipynb

Kernel: Python 3

Treinando uma rede neural no MNIST com Keras

Este exemplo simples demonstra como conectar datasets do TensorFlow (TFDS) a um modelo Keras.

Copyright 2020 Autores do TensorFlow Datasets, licenciado sob Apache License, versão 2.0

Ver em TensorFlow.org

Executar no Google Colab

Ver fonte no GitHub

Baixar notebook

import tensorflow as tf
import tensorflow_datasets as tfds

Passo 1: crie seu pipeline de entrada

Comece construindo um pipeline de entrada eficiente usando recomendações dos documentos a seguir:

• Guia de Dicas de desempenho

• O guia Desempenho melhor com a API tf.data

Carregue um dataset

Carregue o dataset MNIST com os seguintes argumentos:

• shuffle_files=True: os dados MNIST são apenas armazenados num único arquivo, mas para datasets maiores com vários arquivos no disco, é uma boa prática embaralhá-los durante o treinamento.

• as_supervised=True: Retorna uma tupla (img, label) em vez de um dicionário {'image': img, 'label': label}.

(ds_train, ds_test), ds_info = tfds.load(
    'mnist',
    split=['train', 'test'],
    shuffle_files=True,
    as_supervised=True,
    with_info=True,
)

Construa um pipeline de treinamento

Aplique as seguintes transformações:

• tf.data.Dataset.map: o TFDS fornece imagens do tipo tf.uint8, enquanto o modelo espera tf.float32. Portanto, você precisa normalizar as imagens.

• tf.data.Dataset.cache à medida que você ajusta o dataset na memória, armazene-o em cache antes de embaralhá-lo para obter um melhor desempenho.
  Observação: transformações aleatórias devem ser aplicadas após o armazenamento em cache.

• tf.data.Dataset.shuffle: para obter aleatoriedade verdadeira, defina o buffer de embaralhamento para que tenha o tamanho total do dataset.
  Observação: para datasets grandes que não cabem na memória, use buffer_size=1000 se o seu sistema permitir.

• tf.data.Dataset.batch : organize os elementos do dataset em lote depois de embaralhar para obter lotes exclusivos para cada época.

• tf.data.Dataset.prefetch: é uma boa prática finalizar o pipeline fazendo uma pré-busca por questões de desempenho.

def normalize_img(image, label):
  """Normalizes images: `uint8` -> `float32`."""
  return tf.cast(image, tf.float32) / 255., label

ds_train = ds_train.map(
    normalize_img, num_parallel_calls=tf.data.AUTOTUNE)
ds_train = ds_train.cache()
ds_train = ds_train.shuffle(ds_info.splits['train'].num_examples)
ds_train = ds_train.batch(128)
ds_train = ds_train.prefetch(tf.data.AUTOTUNE)

Construa um pipeline de avaliação

Seu pipeline de teste é semelhante ao pipeline de treinamento, com pequenas diferenças:

• Você não precisa chamar tf.data.Dataset.shuffle.

• O cache é feito depois da criação do lote porque os lotes podem ser iguais entre épocas.

ds_test = ds_test.map(
    normalize_img, num_parallel_calls=tf.data.AUTOTUNE)
ds_test = ds_test.batch(128)
ds_test = ds_test.cache()
ds_test = ds_test.prefetch(tf.data.AUTOTUNE)

Passo 2: crie e treine o modelo

Conecte o pipeline de entrada do TFDS a um modelo Keras simples, compile o modelo e treine-o.

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dense(10)
])
model.compile(
    optimizer=tf.keras.optimizers.Adam(0.001),
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=[tf.keras.metrics.SparseCategoricalAccuracy()],
)

model.fit(
    ds_train,
    epochs=6,
    validation_data=ds_test,
)