# ---
# jupyter:
#   jupytext:
#     text_representation:
#       extension: .py
#       format_name: light
#       format_version: '1.5'
#       jupytext_version: 1.14.4
#   kernelspec:
#     display_name: Python 3
#     name: python3
# ---

# + [markdown] colab_type="text" id="MhoQ0WE77laV"
# ##### Copyright 2018 The TensorFlow Authors.

# + cellView="form" colab_type="code" id="_ckMIh7O7s6D" colab={}
#@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.

# + cellView="form" colab_type="code" id="vasWnqRgy1H4" colab={}
#@title MIT License
#
# Copyright (c) 2017 <NAME>
#
# Permission is hereby granted, free of charge, to any person obtaining a
# # copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.

# + [markdown] colab_type="text" id="jYysdyb-CaWM"
# # Treine sua primeira rede neural: classificação básica

# + [markdown] colab_type="text" id="S5Uhzt6vVIB2"
# <table class="tfo-notebook-buttons" align="left">
#   <td>
#     <a target="_blank" href="https://www.tensorflow.org/beta/tutorials/keras/basic_classification"><img src="https://www.tensorflow.org/images/tf_logo_32px.png" />Veja em TensorFlow.org</a>
#   </td>
#   <td>
#     <a target="_blank" href="https://colab.research.google.com/github/tensorflow/docs/blob/master/site/pt/beta/tutorials/keras/basic_classification.ipynb"><img src="https://www.tensorflow.org/images/colab_logo_32px.png" />Execute em Google Colab</a>
#   </td>
#   <td>
#     <a target="_blank" href="https://github.com/tensorflow/docs/blob/master/site/pt/beta/tutorials/keras/basic_classification.ipynb"><img src="https://www.tensorflow.org/images/GitHub-Mark-32px.png" />Veja código fonte em GitHub</a>
#   </td>
#   <td>
#     <a href="https://storage.googleapis.com/tensorflow_docs/docs/site/pt/beta/tutorials/keras/basic_classification.ipynb"><img src="https://www.tensorflow.org/images/download_logo_32px.png" />Baixe o notebook</a>
#   </td>
# </table>

# + [markdown] id="v10Paf9CKcHZ" colab_type="text"
# Note: A nossa comunidade TensorFlow traduziu estes documentos. Como as traduções da comunidade são *o melhor esforço*, não há garantias de que sejam uma reflexão exata e atualizada da [documentação oficial em Inglês](https://www.tensorflow.org/?hl=en). Se tem alguma sugestão para melhorar esta tradução, por favor envie um pull request para o repositório do GitHub [tensorflow/docs](https://github.com/tensorflow/docs). Para se voluntariar para escrever ou rever as traduções da comunidade, contacte a [lista <EMAIL>](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs).

# + [markdown] colab_type="text" id="FbVhjPpzn6BM"
# Este tutorial treina um modelo de rede neural para classificação de imagens de roupas, como tênis e camisetas. Tudo bem se você não entender todos os detalhes; este é um visão geral de um programa do TensorFlow com detalhes explicados enquanto progredimos.
#
# O guia usa [tf.keras](https://www.tensorflow.org/guide/keras), uma API alto-nível para construir e treinar modelos no TensorFlow.

# + colab_type="code" id="jL3OqFKZ9dFg" colab={}
# !pip install tensorflow==2.0.0-beta1

# + colab_type="code" id="dzLKpmZICaWN" colab={}
from __future__ import absolute_import, division, print_function, unicode_literals

# TensorFlow e tf.keras
import tensorflow as tf
from tensorflow import keras

# Librariesauxiliares
import numpy as np
import matplotlib.pyplot as plt

print(tf.__version__)

# + [markdown] colab_type="text" id="yR0EdgrLCaWR"
# ## Importe a base de dados Fashion MNIST

# + [markdown] colab_type="text" id="DLdCchMdCaWQ"
# Esse tutorial usa a base de dados [Fashion MNIST](https://github.com/zalandoresearch/fashion-mnist) que contém 70,000 imagens em tons de cinza em 10 categorias. As imagens mostram artigos individuais de roupas com baixa resolução (28 por 28 pixels), como vemos aqui:
#
# <table>
#   <tr><td>
#     <img src="https://tensorflow.org/images/fashion-mnist-sprite.png"
#          alt="Fashion MNIST sprite"  width="600">
#   </td></tr>
#   <tr><td align="center">
#     <b>Figure 1.</b> <a href="https://github.com/zalandoresearch/fashion-mnist">Amostras de Fashion-MNIST</a> (por Zalando, MIT License).<br/>&nbsp;
#   </td></tr>
# </table>
#
# Fashion MNIST tem como intenção substituir a clássica base de dados [MNIST](http://yann.lecun.com/exdb/mnist/ )— frequentemente usada como "Hello, World" de programas de aprendizado de máquina (*machine learning*) para visão computacional. A base de dados MNIST contém imagens de dígitos escritos à mão (0, 1, 2, etc.) em um formato idêntico ao dos artigos de roupas que usaremos aqui.
#
# Esse tutorial usa a Fashion MNIST para variar, e porque é um problema um pouco mais desafiador que o regular MNIST. Ambas bases são relativamente pequenas e são usadas para verificar se um algoritmo funciona como esperado. Elas são bons pontos de partida para testar e debugar código.
#
# Usaremos 60,000 imagens para treinar nossa rede e 10,000 imagens para avaliar quão precisamente nossa rede aprendeu a classificar as imagens. Você pode acessar a Fashion MNIST directly diretamente do TensorFlow. Importe e carregue a base Fashion MNIST diretamente do TensorFlow:

# + colab_type="code" id="7MqDQO0KCaWS" colab={}
fashion_mnist = keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

# + [markdown] colab_type="text" id="t9FDsUlxCaWW"
# Carregando a base de dados que retorna quatro NumPy arrays:
#
# * Os *arrays* `train_images` e `train_labels`  são o *conjunto de treinamento*— os dados do modelo usados para aprender.
# * O modelo é testado com o *conjunto de teste*, os *arrays* `test_images` e `test_labels`.
#
# As imagens são arrays  NumPy de 28x28, com os valores des pixels entre 0 to 255. As *labels* (alvo da classificação) são um  array  de inteiros, no intervalo de  0 a 9. Esse corresponde com a classe de roupa que cada imagem representa:
#
# <table>
#   <tr>
#     <th>Label</th>
#     <th>Classe</th>
#   </tr>
#   <tr>
#     <td>0</td>
#     <td>Camisetas/Top (T-shirt/top)</td>
#   </tr>
#   <tr>
#     <td>1</td>
#     <td>Calça (Trouser)</td>
#   </tr>
#     <tr>
#     <td>2</td>
#     <td>Suéter (Pullover)</td>
#   </tr>
#     <tr>
#     <td>3</td>
#     <td>Vestidos (Dress)</td>
#   </tr>
#     <tr>
#     <td>4</td>
#     <td>Casaco (Coat)</td>
#   </tr>
#     <tr>
#     <td>5</td>
#     <td>Sandálias (Sandal)</td>
#   </tr>
#     <tr>
#     <td>6</td>
#     <td>Camisas (Shirt)</td>
#   </tr>
#     <tr>
#     <td>7</td>
#     <td>Tênis (Sneaker)</td>
#   </tr>
#     <tr>
#     <td>8</td>
#     <td>Bolsa (Bag)</td>
#   </tr>
#     <tr>
#     <td>9</td>
#     <td>Botas (Ankle boot)</td>
#   </tr>
# </table>
#
# Cada imagem é mapeada com um só label. Já que o *nome das classes* não são incluídas na base de dados, armazene os dados aqui para usá-los mais tarde quando plotarmos as imagens:

# + colab_type="code" id="IjnLH5S2CaWx" colab={}
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

# + [markdown] colab_type="text" id="Brm0b_KACaWX"
# ## Explore os dados
#
# Vamos explorar o formato da base de dados antes de treinar o modelo. O próximo comando mostra que existem 60000 imagens no conjunto de treinamento, e cada imagem é representada em 28 x 28 pixels:

# + colab_type="code" id="zW5k_xz1CaWX" colab={}
train_images.shape

# + [markdown] colab_type="text" id="cIAcvQqMCaWf"
# Do mesmo modo, existem 60000 labels no conjunto de treinamento:

# + colab_type="code" id="TRFYHB2mCaWb" colab={}
len(train_labels)

# + [markdown] colab_type="text" id="YSlYxFuRCaWk"
# Cada label é um inteiro entre 0 e 9:

# + colab_type="code" id="XKnCTHz4CaWg" colab={}
train_labels

# + [markdown] colab_type="text" id="TMPI88iZpO2T"
# Existem 10000 imagens no conjnto de teste. Novamente, cada imagem é representada por 28 x 28 pixels:

# + colab_type="code" id="2KFnYlcwCaWl" colab={}
test_images.shape

# + [markdown] colab_type="text" id="rd0A0Iu0CaWq"
# E um conjunto de teste contendo 10000 labels das imagens :

# + colab_type="code" id="iJmPr5-ACaWn" colab={}
len(test_labels)

# + [markdown] colab_type="text" id="ES6uQoLKCaWr"
# ## Pré-processe os dados
#
# Os dados precisam ser pré-processados antes de treinar a rede. Se você inspecionar a primeira imagem do conjunto de treinamento, você verá que os valores dos pixels estão entre 0 e 255:

# + colab_type="code" id="m4VEw8Ud9Quh" colab={}
plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

# + [markdown] colab_type="text" id="Wz7l27Lz9S1P"
# Escalaremos esses valores no intervalo de 0 e 1 antes antes de alimentar o modelo da rede neural. Para fazer isso, dividimos os valores por 255. É importante que o *conjunto de treinamento* e o *conjunto de teste* podem ser pré-processados do mesmo modo:

# + colab_type="code" id="bW5WzIPlCaWv" colab={}
train_images = train_images / 255.0

test_images = test_images / 255.0

# + [markdown] colab_type="text" id="Ee638AlnCaWz"
# Para verificar que os dados estão no formato correto e que estamos prontos para construir e treinar a rede, vamos mostrar as primeiras 25 imagens do *conjunto de treinamento* e mostrar o nome das classes de cada imagem abaixo.

# + colab_type="code" id="oZTImqg_CaW1" colab={}
plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

# + [markdown] colab_type="text" id="59veuiEZCaW4"
# ## Construindo o modelo
#
# Construir a rede neural requer configurar as camadas do modelo, e depois, compilar o modelo.

# + [markdown] colab_type="text" id="Gxg1XGm0eOBy"
# ### Montar as camadas
#
# O principal bloco de construção da rede neural é a camada (*layer*). As camadas (*layers*) extraem representações dos dados inseridos na rede. Com sorte, essas representações são significativas para o problema à mão.
#
# Muito do *deep learning* consiste encadear simples camadas. Muitas camadas, como `tf.keras.layers.Dense`, tem paramêtros que são aprendidos durante o treinamento.

# + colab_type="code" id="9ODch-OFCaW4" colab={}
model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

# + [markdown] colab_type="text" id="gut8A_7rCaW6"
# A primeira camada da rede, `tf.keras.layers.Flatten`, transforma o formato da imagem de um array de imagens de duas dimensões (of 28 by 28 pixels) para um array de uma dimensão (de 28 * 28 = 784 pixels). Pense nessa camada como camadas não empilhadas de pixels de uma imagem e os emfilere. Essa camada não tem paramêtros para aprender; ela só reformata os dados.
#
# Depois dos pixels serem achatados, a rede consite de uma sequência de duas camadas `tf.keras.layers.Dense`. Essa são camadas neurais *densely connected*, ou *fully connected*. A primeira camada `Dense` tem 128 nós (ou neurônios). A segunda (e última) camda é uma *softmax*  de 10 nós que retorna um array de 10 probabilidades, cuja soma resulta em 1. Cada nó contem um valor que indica a probabilidade de que aquela imagem pertence a uma das 10 classes.
#
# ### Compile o modelo
#
# Antes do modelo estar pronto para o treinamento, é necessário algumas configurações a mais. Essas serão adicionadas no passo de *compilação*:
#
# * *Função Loss* —Essa mede quão precisa o modelo é durante o treinamento. Queremos minimizar a função para *guiar* o modelo para direção certa.
# * *Optimizer* —Isso é como o modelo se atualiza com base no dado que ele vê e sua função *loss*.
# * *Métricas* —usadas para monitorar os passos de treinamento e teste. O exemplo abaixo usa a *acurácia*, a fração das imagens que foram classificadas corretamente.

# + colab_type="code" id="Lhan11blCaW7" colab={}
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# + [markdown] colab_type="text" id="qKF6uW-BCaW-"
# ## Treine o modelo
#
# Treinar a rede neural requer os seguintes passos:
#
# 1. Alimente com os dados de treinamento, o modelo. Neste exemplo, os dados de treinamento são os arrays `train_images` e `train_labels`.
# 2. O modelo aprende como associar as imagens as *labels*.
# 3. Perguntamos ao modelo para fazer previsões sobre o conjunto de teste — nesse exemplo, o array `test_images`. Verificamos se as previsões combinaram com as *labels*  do array `test_labels`.
#
# Para começar a treinar, chame o método `model.fit`— assim chamado, porque ele "encaixa" o modelo no conjunto de treinamento:

# + colab_type="code" id="xvwvpA64CaW_" colab={}
model.fit(train_images, train_labels, epochs=10)

# + [markdown] colab_type="text" id="W3ZVOhugCaXA"
# À medida que o modelo treina, as métricas loss e acurácia são mostradas. O modelo atinge uma acurácia de 0.88 (ou 88%) com o conjunto de treinamento.

# + [markdown] colab_type="text" id="oEw4bZgGCaXB"
# ## Avalie a acurácia
#
# Depois, compare como o modelo performou com o conjunto de teste:

# + colab_type="code" id="VflXLEeECaXC" colab={}
test_loss, test_acc = model.evaluate(test_images, test_labels)

print('\nTest accuracy:', test_acc)

# + [markdown] colab_type="text" id="yWfgsmVXCaXG"
# Acabou que o a acurácia com o conjunto de teste é um pouco menor do que a acurácia de treinamento. Essa diferença entre as duas acurácias representa um *overfitting*. Overfitting é modelo de aprendizado de máquina performou de maneira pior em um conjunto de entradas novas, e não usadas anteriormente, que usando o conjunto de treinamento.

# + [markdown] colab_type="text" id="xsoS7CPDCaXH"
# ## Faça predições
#
# Com o modelo treinado, o usaremos para predições de algumas imagens.

# + colab_type="code" id="Gl91RPhdCaXI" colab={}
predictions = model.predict(test_images)

# + [markdown] colab_type="text" id="x9Kk1voUCaXJ"
# Aqui, o modelo previu que a *label*  de cada imagem no conjunto de treinamento. Vamos olhar na primeira predição:

# + colab_type="code" id="3DmJEUinCaXK" colab={}
predictions[0]

# + [markdown] colab_type="text" id="-hw1hgeSCaXN"
# A predição é um array de 10 números. Eles representam um a *confiança* do modelo que a imagem corresponde a cada um dos diferentes artigos de roupa. Podemos ver cada *label*  tem um maior valor de confiança:

# + colab_type="code" id="qsqenuPnCaXO" colab={}
np.argmax(predictions[0])

# + [markdown] colab_type="text" id="E51yS7iCCaXO"
# Então, o modelo é confiante de que esse imagem é uma bota (ankle boot) ou `class_names[9]`. Examinando a label do teste, vemos que essa classificação é correta:

# + colab_type="code" id="Sd7Pgsu6CaXP" colab={}
test_labels[0]


# + [markdown] colab_type="text" id="ygh2yYC972ne"
# Podemos mostrar graficamente como se parece em um conjunto total de previsão de 10 classes.

# + colab_type="code" id="DvYmmrpIy6Y1" colab={}
def plot_image(i, predictions_array, true_label, img):
  predictions_array, true_label, img = predictions_array[i], true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])

  plt.imshow(img, cmap=plt.cm.binary)

  predicted_label = np.argmax(predictions_array)
  if predicted_label == true_label:
    color = 'blue'
  else:
    color = 'red'

  plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[true_label]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  predictions_array, true_label = predictions_array[i], true_label[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1])
  predicted_label = np.argmax(predictions_array)

  thisplot[predicted_label].set_color('red')
  thisplot[true_label].set_color('blue')


# + [markdown] colab_type="text" id="d4Ov9OFDMmOD"
# Vamos olhar a previsão imagem na posição 0, do array de predição.

# + colab_type="code" id="HV5jw-5HwSmO" colab={}
i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions,  test_labels)
plt.show()

# + colab_type="code" id="Ko-uzOufSCSe" colab={}
i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions,  test_labels)
plt.show()

# + [markdown] colab_type="text" id="kgdvGD52CaXR"
# Vamos plotar algumas da previsão do modelo. Labels preditas corretamente são azuis e as predições erradas são vermelhas. O número dá a porcentagem (de 100) das labels preditas. Note que o modelo pode errar mesmo estão confiante.

# + colab_type="code" id="hQlnbqaw2Qu_" colab={}
# Plota o primeiro X test images, e as labels preditas, e as labels verdadeiras.
# Colore as predições corretas de azul e as incorretas de vermelho.
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions, test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions, test_labels)
plt.show()

# + [markdown] colab_type="text" id="R32zteKHCaXT"
# Finamente, use  o modelo treinado para fazer a predição de uma única imagem.

# + colab_type="code" id="yRJ7JU7JCaXT" colab={}
# Grab an image from the test dataset.
img = test_images[0]

print(img.shape)

# + [markdown] colab_type="text" id="vz3bVp21CaXV"
# Modelos `tf.keras` são otimizados para fazer predições em um *batch*, ou coleções, de exemplos de uma vez. De acordo, mesmo que usemos uma única imagem, precisamos adicionar em uma lista:

# + colab_type="code" id="lDFh5yF_CaXW" colab={}
# Adiciona a imagem em um batch que possui um só membro.
img = (np.expand_dims(img,0))

print(img.shape)

# + [markdown] colab_type="text" id="EQ5wLTkcCaXY"
# Agora prediremos a label correta para essa imagem:

# + colab_type="code" id="o_rzNSdrCaXY" colab={}
predictions_single = model.predict(img)

print(predictions_single)

# + colab_type="code" id="6Ai-cpLjO-3A" colab={}
plot_value_array(0, predictions_single, test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)

# + [markdown] colab_type="text" id="cU1Y2OAMCaXb"
# `model.predict` retorna a lista de listas — uma lista para cada imagem em um *batch* de dados. Pegue a predição de nossa (única) imagem no *batch*:

# + colab_type="code" id="2tRmdq_8CaXb" colab={}
np.argmax(predictions_single[0])

# + [markdown] colab_type="text" id="YFc2HbEVCaXd"
# E, como antes, o modelo previu a label como 9.

StarcoderdataJupyterScriptsDedupFiltered