beginner.ipynb

Kernel: Python 3

Copyright 2019 The TensorFlow Authors.

#@title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

Primeiros passos do TensorFlow 2 para iniciantes

Ver em TensorFlow.org

Executar no Google Colab

Ver fonte no GitHub

Baixar notebook

Esta breve introdução usa o Keras para:

1. Carregar um dataset pré-criado.

2. Criar um modelo de aprendizado de máquina de rede neural que classifica imagens.

3. Treinar essa rede neural.

4. Avaliar a exatidão do modelo.

Este é um notebook do Google Colaboratory. Os programas em Python são executados diretamente no navegador — uma ótima maneira de aprender e usar o TensorFlow. Para seguir este tutorial, execute o notebook no Google Colab clicando no botão no topo desta página.

1. No Colab, conecte a um runtime do Python: no canto superior direito da barra de menu, selecione CONNECT (CONECTAR).

2. Para executar todo o código no notebook, selecione Runtime > Run all (Executar tudo). Para executar uma célula de código de cada vez, passe o cursor sobre cada célula e selecione o ícone Run cell (Executar célula).

Configure o TensorFlow

Para começar, importe o TensorFlow para seu programa:

import tensorflow as tf
print("TensorFlow version:", tf.__version__)

Se você estiver acompanhando no seu próprio ambiente de desenvolvimento em vez do Colab, veja o guia de instalação para configurar o TensorFlow para desenvolvimento.

Observação: confira se você atualizou para o pip mais recente antes de instalar o pacote do TensorFlow 2 caso esteja usando seu próprio ambiente de desenvolvimento. Confira mais detalhes no guia de instalação.

Carregue um dataset

Carregue e prepare o dataset MNIST. Os valores de pixel das imagens vão de 0 a 255. Ajuste esses valores para um intervalo de 0 a 1 ao dividir os valores por 255.0. Isso também converte os dados de amostra de números inteiros para números em ponto flutuante:

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

Crie um modelo de aprendizado de máquina

Crie um modelo tf.keras.Sequential:

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10)
])

Sequential é útil para empilhar camadas quando cada uma tem um tensor de entrada e um tensor de saída. As camadas são funções com uma estrutura matemática conhecida que podem ser reutilizadas e têm variáveis que podem ser treinadas. A maioria dos modelos do TensorFlow são compostos de camadas. Esse modelo usa as camadas Flatten, Dense e Dropout.

Para cada exemplo, o modelo retorna um vetor de logits ou pontuações log-odds, uma para cada classe.

predictions = model(x_train[:1]).numpy()
predictions

A função tf.nn.softmax converte esses logits em probabilidades para cada classe:

tf.nn.softmax(predictions).numpy()

Observação: é possível fazer o bake da função tf.nn.softmax na função de ativação para a última camada da rede. Isso pode fazer com que a saída do modelo seja mais diretamente interpretável, mas essa abordagem não é recomendada, já que é impossível fornecer um cálculo de perda numericamente estável e exato para todos os modelos ao usar uma saída de softmax.

Defina uma função de perda para treinamento usando losses.SparseCategoricalCrossentropy:

loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

A função de perda obtém um vetor de valores verdadeiros e um vetor de logits e retorna uma perda escalar para cada exemplo. Essa perda é igual à probabilidade log negativa da classe verdadeira: a perda é zero se o modelo tem certeza da classe correta.

Esse modelo não treinado fornece probabilidades perto de serem aleatórias (1/10 para cada classe), então a perda inicial deve ser próxima de -tf.math.log(1/10) ~= 2.3.

loss_fn(y_train[:1], predictions).numpy()

Antes de começar a treinar, configure e compile o modelo usando o Model.compile do Keras. Defina a classe optimizer (otimizador) como adam, defina o loss (perda) como a função loss_fn definida antes e especifique uma métrica para ser avaliada para o modelo ao configurar o parâmetro metrics (métricas) como accuracy (exatidão).

model.compile(optimizer='adam',
              loss=loss_fn,
              metrics=['accuracy'])

Treine e avalie seu modelo

Use o método Model.fit para ajustar os parâmetros do seu modelo e reduzir a perda:

model.fit(x_train, y_train, epochs=5)

O método Model.evaluate verifica o desempenho de um modelo, geralmente em um dataset de validação ou de teste.

model.evaluate(x_test,  y_test, verbose=2)

O classificador de imagens já está treinado com cerca de 98% de exatidão nesse dataset. Para saber mais, leia os tutoriais do TensorFlow.

Se você quiser que seu modelo retorne uma probabilidade, empacote o modelo treinado e anexe o softmax a ele:

probability_model = tf.keras.Sequential([
  model,
  tf.keras.layers.Softmax()
])

probability_model(x_test[:5])

Conclusão

Parabéns! Você treinou um modelo de aprendizado de máquina usando um dataset pré-criado com a API Keras.

Para obter mais exemplos de uso do Keras, confira os tutoriais. Para saber mais sobre como criar modelos com o Keras, leia os guias. Se quiser saber mais sobre como carregar e preparar dados, consulte os tutoriais sobre carregamento de dados de imagem ou carregamento de dados CSV.