GSP631

Visão geral

O TensorFlow é uma biblioteca de machine learning (ML) portátil, potente e de código aberto, desenvolvida pelo Google para trabalhar com grandes conjuntos de dados. Neste laboratório, você vai criar e treinar um modelo de visão computacional que reconhece itens de vestuário usando o Vertex AI Workbench do TensorFlow.

Introdução ao TensorFlow

O TensorFlow oferece um framework computacional para criar modelos de ML. O TensorFlow inclui uma série de kits de ferramentas que servem para criar modelos com o nível de abstração que você quiser. Neste laboratório, você vai usar o tf.keras, uma API de alto nível, para criar e treinar uma rede neural que classifica imagens no TensorFlow.

Redes neurais

Uma rede neural é um modelo inspirado no cérebro. Ele é composto por camadas (sendo pelo menos uma oculta) formadas por unidades de conexão simples, ou neurônios, seguidas por não linearidades.

Um nó em uma rede neural costuma receber diversos valores de entrada e gera um valor de saída. O neurônio aplica a função de ativação (transformação não linear) a uma soma ponderada de valores de entrada para calcular o valor de saída.

Para mais informações sobre redes neurais, consulte Redes neurais: estrutura.

Objetivos

Neste laboratório, você vai aprender a:

• Elaborar, compilar, treinar e avaliar um modelo do TensorFlow
• Salvar e carregar modelos
• Escrever seus próprios callbacks para personalizar o comportamento durante o treinamento
• Completar uma série de exercícios para guiar seus experimentos com diferentes camadas da rede

Configuração e requisitos

Antes de clicar no botão Começar o Laboratório

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é ativado quando você clica em Iniciar laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, e não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima (recomendado) ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório: não se esqueça que, depois de começar, não será possível pausar o laboratório.

Observação: use apenas a conta de estudante neste laboratório. Se usar outra conta do Google Cloud, você poderá receber cobranças nela.

Tarefa 1: abrir o notebook no Vertex AI Workbench

1. No menu de navegação () do console do Google Cloud, clique em Vertex AI > Workbench.

2. Ache a instância e clique no botão Abrir o JupyterLab.

A interface do JupyterLab para sua instância do Workbench é aberta em uma nova guia do navegador.

Observação: se você não encontrar notebooks no JupyterLab, siga estas etapas para redefinir a instância:

1. Feche a guia do JupyterLab no navegador e volte à página inicial do Workbench.

2. Marque a caixa de seleção ao lado do nome da instância e clique em Redefinir.

3. Depois que o botão Abrir o JupyterLab for ativado novamente, aguarde um minuto e clique em Abrir o JupyterLab.

Instalar o TensorFlow e pacotes extras

1. No menu do Launcher, em Outro, selecione Terminal.

2. Verifique se o ambiente Python já está configurado. Copie e cole o seguinte comando no terminal.

python --version

Exemplo de saída:

Python 3.10.14

3. Execute o seguinte comando para instalar o pacote do TensorFlow.

pip3 install tensorflow

4. Para fazer upgrade do pip3, execute o seguinte comando no terminal.

pip3 install --upgrade pip

O Pylint é uma ferramenta que verifica erros no código Python e destaca problemas sintáticos e estilísticos no código-fonte Python.

5. Execute o seguinte comando para instalar o pacote do pylint.

pip install -U pylint --user

6. Instale os pacotes necessários para o laboratório no arquivo requirements.txt:

pip install -r requirements.txt

Agora o ambiente está configurado.

Tarefa 2: criar um novo notebook e importar bibliotecas

1. Clique no ícone + no lado esquerdo do Workbench para abrir um novo Launcher.

2. No menu do Launcher, em Notebook, selecione Python3.

Será mostrado um novo notebook do Jupyter. Para saber como usar os notebooks do Jupyter, confira a documentação do Jupyter Notebook.

3. Importe e configure logging e google-cloud-logging para o Cloud Logging. Na primeira célula, adicione o seguinte código:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging cloud_logger = logging.getLogger('cloudLogger') cloud_logger.setLevel(logging.INFO) cloud_logger.addHandler(CloudLoggingHandler(cloud_logging.Client())) cloud_logger.addHandler(logging.StreamHandler())

4. Importe tensorflow para treinar e avaliar o modelo. Chame de tf para facilitar. Adicione o seguinte código à primeira célula.

# Import TensorFlow import tensorflow as tf

5. Importe numpy para analisar os dados na depuração. Chame de np para facilitar. Adicione o seguinte código à primeira célula.

# Import numpy import numpy as np

6. Adicione o seguinte código à primeira célula para importar tensorflow_datasets e integrar ao conjunto de dados. O TensorFlow Datasets é uma coletânea de conjuntos de dados prontos para serem usados com o TensorFlow.

Para saber como usar, consulte o guia e a lista de conjuntos de dados. # Import tensorflow_datasets import tensorflow_datasets as tfds

7. Para executar a célula, clique no botão Executar ou pressione Shift + Enter.

8. Salve o notebook. Clique em File > Save. Dê o nome model.ipynb ao arquivo e clique em OK.

Tarefa 3: carregar e pré-processar o conjunto de dados

Sobre o conjunto de dados

Você vai treinar uma rede neural para classificar imagens de itens de vestuário de um conjunto de dados chamado Fashion MNIST (em inglês).

Esse conjunto de dados inclui 70 mil itens de vestuário de 10 categorias diferentes. As imagens são de peças de vestuário individuais em baixa resolução (28 por 28 pixels), conforme mostrado aqui:

Neste laboratório, 60 mil imagens serão usadas para treinar a rede e outras 10 mil serão usadas para avaliar se ela aprendeu a classificar as imagens com acurácia.

Os dados Fashion MNIST estão disponíveis no tensorflow datasets(tfds).

Como carregar o conjunto de dados

Para carregar os dados Fashion MNIST, você vai usar a função tfds.load().

1. Adicione o seguinte código à segunda célula do notebook:

# Definir, carregar e configurar dados (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True)

No código acima, você definiu o argumento split para especificar quais divisões do conjunto de dados devem ser carregadas. Você definiu as_supervised como True para garantir que o tf.data.Dataset carregado terá uma estrutura com 2 tuplas (input, label).

ds_train e ds_test são do tipo tf.data.Dataset. ds_train tem 60 mil imagens que serão usadas no treinamento. ds_test tem 10 mil imagens que vão servir para avaliar o modelo.

Para ler mais sobre tfds.load() e os argumentos dele, consulte o guia.

Como são esses valores?

2. A seguir, adicione as instruções de impressão para conferir os valores mínimos e máximos das imagens de treinamento do item 0. Adicione o seguinte código à segunda célula:

# Valores antes da normalização image_batch, labels_batch = next(iter(ds_train)) print("Before normalization ->", np.min(image_batch[0]), np.max(image_batch[0]))

Pré-processamento de dados

1. O tamanho do lote é o termo usado em machine learning para se referir ao número de exemplos de treinamento usados em uma iteração. Você vai definir esse valor como 32.

Especifique o tamanho do lote adicionando o seguinte ao model.ipynb:

# Definir o tamanho do lote BATCH_SIZE = 32

2. Ao treinar uma rede neural, por diversos motivos é mais fácil ajustar os valores dos pixels para uma intervalo entre 0 e 1. Esse processo é chamado de "normalização". Como os valores dos pixels para o conjunto de dados FashionMNIST estão no intervalo [0, 255], você vai dividir os valores dos pixels por 255.0 para normalizar as imagens.

O código abaixo usa a função map() de tf.data.Dataset para normalizar as imagens em ds_train e ds_test. Como os valores dos pixels são do tipo tf.uint8, usamos a função tf.cast para convertê-los para tf.float32 e depois dividimos por 255.0. O conjunto de dados também é convertido em lotes chamando o método batch() com BATCH_SIZE como argumento.

Leia mais sobre todos os métodos disponíveis para tf.data.Dataset aqui.

Adicione o seguinte código ao final do arquivo:

# Normalizar e fazer o processamento em lote do conjunto de dados ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE)

3. Imprima novamente os valores mínimos e máximos de uma imagem no conjunto de dados de treinamento:

Adicione o seguinte código ao final do arquivo:

# Examine os valores mín. e máx. do lote após a normalização image_batch, labels_batch = next(iter(ds_train)) print("After normalization ->", np.min(image_batch[0]), np.max(image_batch[0]))

Tarefa 4: elaborar, compilar e treinar o modelo

Nesta seção, você vai elaborar seu modelo usando o TensorFlow.

1. Adicione o seguinte código ao arquivo:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

Confira os diferentes tipos de camadas e parâmetros usados na arquitetura do modelo:

• Sequential: define uma SEQUÊNCIA de camadas na rede neural.

• Flatten: nossas imagens estão no formato (28, 28), ou seja, os valores estão na forma de uma matriz quadrada. O tipo Flatten transforma essa matriz em um vetor unidimensional.

• Dense: adiciona uma camada de neurônios.

Cada camada de neurônios precisa de uma função de ativação para decidir se precisa ser ativado ou não. Há muitas opções, mas este laboratório usa as seguintes.

• Relu significa que, se X > 0, deve retornar X, caso contrário, retorna 0. Passa os valores 0 e maiores para a próxima camada da rede.
• Softmax pega um conjunto de valores e seleciona o mais alto para que você não precise encontrar. Por exemplo, se a saída da última camada for [0.1, 0.1, 0.05, 0.1, 9.5, 0.1, 0.05, 0.05, 0.05], ela vai retornar [0,0,0,0,1,0,0,0,0].

Compilar e treinar o modelo

Nesta seção, você vai compilar o modelo com uma função otimizadora e outra de perda. Depois, você vai treinar o modelo usando os rótulos e dados de treinamento.

A meta é que o modelo descubra a relação entre os rótulos e os dados de treinamento. Quando o treinamento terminar, o ideal é que seu modelo analise imagens novas de itens semelhantes aos dados de treinamento e faça previsões sobre a categoria de vestuário de cada um deles.

Uma função otimizadora é um dos dois argumentos necessários para compilar um modelo tf.keras. Uma função otimizadora é um algoritmo que modifica os atributos da rede neural, como pesos e taxa de aprendizado. Isso ajuda a reduzir a perda e melhora a acurácia.

Leia mais sobre diferentes tipos de funções otimizadoras disponíveis no tf.keras aqui.

A função de perda apresenta um número que indica o desempenho do modelo. Se o modelo estiver com um desempenho melhor, a perda será um número menor. Se não, a perda será um número maior.

Leia mais sobre os diferentes tipos de funções de perda disponíveis no tf.keras aqui.

Observe o parâmetro metrics=. Com ele, o TensorFlow consegue sinalizar a acurácia do treinamento após cada época comparando os resultados previstos com as respostas conhecidas (rótulos). Isso indica como a eficiência do treinamento está progredindo.

Clique aqui para saber mais sobre os diferentes tipos de métricas disponíveis no "tf.keras".

Model.fit vai treinar o modelo por um número fixo de épocas.

1. Adicione o seguinte código ao arquivo:

# Compile o modelo model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5)

Clique em Verificar meu progresso para conferir o objetivo. Criar modelos de machine learning

Executar o código

1. Execute a segunda célula clicando no botão Executar ou pressionando Shift + Enter.

Quando a célula do notebook for executada, você vai ver a perda e a acurácia informadas após cada época (ou passagem) de treinamento. Após cada época (ou passagem), a acurácia aumenta:

Exemplo de saída (seus valores podem ser um pouco diferentes, ignore as mensagens de aviso):

Before normalization -> 0 227 After normalization -> 0.0 1.0 Epoch 1/5 1875/1875 [==============================] - 12s 6ms/step - loss: 0.5264 - sparse_categorical_accuracy: 0.8175 Epoch 2/5 1875/1875 [==============================] - 6s 3ms/step - loss: 0.3977 - sparse_categorical_accuracy: 0.8580 Epoch 3/5 1875/1875 [==============================] - 5s 3ms/step - loss: 0.3585 - sparse_categorical_accuracy: 0.8701 Epoch 4/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3329 - sparse_categorical_accuracy: 0.8784 Epoch 5/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3151 - sparse_categorical_accuracy: 0.8846

Para a saída # Values before normalization, você vai notar que os valores mínimos e máximos estão no intervalo [0, 255]. Depois da normalização, todos os valores ficam no intervalo [0, 1].

Conforme o treinamento segue, a perda diminui e a acurácia aumenta.

Depois que o treinamento do modelo terminar, o valor da acurácia será mostrado no final da última época. Ele pode ser próximo de 0.8846, como acima (sua acurácia pode ser diferente).

Isso indica que a rede neural tem uma acurácia de aproximadamente 89% ao classificar os dados de treinamento. Em outras palavras, ela descobriu um padrão de correspondência entre a imagem e os rótulos que funcionou 89% das vezes. Não é o ideal, mas não é ruim considerando que o treinamento durou apenas cinco épocas em uma rede neural pequena.

Tarefa 5: avaliar o desempenho do modelo com dados desconhecidos

Mas como o modelo se sairia com dados desconhecidos?

O conjunto de teste pode ajudar a responder a essa pergunta. Você chama model.evaluate, passa nos dois conjuntos e relata a perda para cada um.

Avalie o conjunto de teste:

1. Adicione o seguinte código à terceira célula do notebook:

cloud_logger.info(model.evaluate(ds_test))

2. Execute a terceira célula clicando no botão Executar ou pressionando Shift + Enter.

Se você rolar a saída para baixo, vai encontrar o resultado da avaliação na última linha.

Before normalization -> 0 227 After normalization -> 0.0 1.0 Epoch 1/5 1875/1875 [==============================] - 12s 6ms/step - loss: 0.5264 - sparse_categorical_accuracy: 0.8175 Epoch 2/5 1875/1875 [==============================] - 6s 3ms/step - loss: 0.3977 - sparse_categorical_accuracy: 0.8580 Epoch 3/5 1875/1875 [==============================] - 5s 3ms/step - loss: 0.3585 - sparse_categorical_accuracy: 0.8701 Epoch 4/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3329 - sparse_categorical_accuracy: 0.8784 Epoch 5/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3151 - sparse_categorical_accuracy: 0.8846 313/313 [==============================] - 1s 4ms/step - loss: 0.3653 - sparse_categorical_accuracy: 0.8708 INFO:cloudLogger:[0.36530008912086487, 0.8708000183105469]

O modelo relata uma acurácia de 0.8708 com o conjunto de teste (ds_test), ou seja, ele é preciso 87% das vezes. Lembrete: seus valores podem ser um pouco diferentes.

Como esperado, o modelo é menos acurado com dados desconhecidos do que com os dados do treinamento!

Aprendendo mais sobre o TensorFlow, você vai descobrir como melhorar isso.

Clique em Verificar meu progresso para conferir o objetivo. Usar o modelo

Tarefa 6: salvar e carregar o modelo

O progresso do modelo pode ser salvo durante e após o treinamento. Isso significa que um modelo pode voltar de onde parou e evitar tempos longos de treinamento. Também é possível salvar para compartilhar seu modelo. Assim, outras pessoas podem recriar seu trabalho. Neste exercício, você vai adicionar o código necessário para salvar e carregar seu modelo.

É possível salvar um modelo inteiro em dois formatos de arquivo (SavedModel e Keras). O formato TensorFlow SavedModel é o padrão no TF2.x. No entanto, os modelos podem ser salvos no formato Keras. Você vai saber como salvar modelos nos dois formatos de arquivo.

1. Adicione o seguinte código à quarta célula do notebook:

# Salve o modelo inteiro como um modelo do Keras usando o formato .keras model.save('saved_model.keras') # Carregue o modelo usando custom_objects para processar a função de ativação personalizada new_model = tf.keras.models.load_model('saved_model.keras', custom_objects={'softmax_v2': tf.keras.activations.softmax}) # Resumo do SavedModel carregado new_model.summary() # Salve o modelo inteiro em um arquivo keras. model.save('my_model.keras') # Recrie o mesmo modelo, incluindo os pesos e o otimizador new_model_keras = tf.keras.models.load_model('my_model.keras', custom_objects={'softmax_v2': tf.keras.activations.softmax}) # Resumo do modelo keras carregado new_model_keras.summary()

O código acima mostra como salvar o modelo em dois formatos diferentes e carregar o modelo salvo de volta. É possível escolher qualquer formato de acordo com o caso de uso. Leia mais sobre essa funcionalidade na documentação do TensorFlow: Salvar e carregar modelos.

2. Execute a terceira célula clicando no botão Executar ou pressionando Shift + Enter.

Os resumos dos dois conjuntos de modelos estão no final da saída. O primeiro é o resumo do modelo após ser salvo no formato SavedModel. O segundo representa o modelo após salvar no formato h5.

Os dois resumos são idênticos porque salvamos o mesmo modelo em dois formatos diferentes.

Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= flatten (Flatten) (None, 784) 0 dense (Dense) (None, 64) 50240 dense_1 (Dense) (None, 10) 650 ================================================================= Total params: 50,890 Trainable params: 50,890 Non-trainable params: 0 _________________________________________________________________ Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= flatten (Flatten) (None, 784) 0 dense (Dense) (None, 64) 50240 dense_1 (Dense) (None, 10) 650 ================================================================= Total params: 50,890 Trainable params: 50,890 Non-trainable params: 0 _________________________________________________________________

Clique em Verificar meu progresso para conferir o objetivo. Salvar e carregar modelos

Tarefa 7: usar callbacks

Mais cedo, ao treinar o modelo, você teria notado que, conforme o treinamento progredia, a perda diminuía e a acurácia aumentava. Depois de atingir a acurácia e a perda desejadas no treinamento, pode ser que ainda seja necessário esperar um pouco antes de concluir o treinamento.

Não seria incrível interromper o treinamento quando o modelo alcançasse um valor específico de acurácia?

Por exemplo, se uma acurácia de 95% for boa o suficiente e o modelo alcançar esse valor depois de três épocas, por que esperar mais épocas?

Resposta: callbacks!

Um callback é um ferramenta eficiente para personalizar o comportamento de um modelo Keras durante o treinamento, a avaliação ou a inferência. É possível definir um callback para interromper o treinamento assim que o modelo alcançar uma acurácia específica com o conjunto de treinamento.

Teste o seguinte código para conferir o que acontece ao definir um callback para interromper o treinamento quando a acurácia chegar a 84%:

1. Abra a tela de início e selecione Python3 para criar um novo notebook do Jupiter.

2. Salve o arquivo como callback_model.ipynb.

3. Cole o seguinte código na primeira célula de callback_model.ipynb:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging exp_logger = logging.getLogger('expLogger') exp_logger.setLevel(logging.INFO) exp_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="callback")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define Callback class myCallback(tf.keras.callbacks.Callback): def on_epoch_end(self, epoch, logs={}): if(logs.get('sparse_categorical_accuracy')>0.84): exp_logger.info("\nReached 84% accuracy so cancelling training!") self.model.stop_training = True callbacks = myCallback() # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5, callbacks=[callbacks])

4. Pressione Ctrl + S ou acesse Arquivo > Salvar notebook para salvar as mudanças.

5. Execute o código clicando no botão Executar ou pressionando Shift + Enter.

Note que o treinamento foi cancelado depois de algumas épocas.

Clique em Verificar meu progresso para conferir o objetivo. Usar callbacks

Tarefa 8: fazer experimentos com o modelo

Nesta seção, você vai fazer experimentos com as diferentes camadas da rede.

Exercício 1

Neste exercício, você vai conhecer as camadas do modelo. O que vai acontecer se você mudar o número de neurônios?

1. Abra a tela de início e selecione Python3 para criar um novo notebook do Jupiter.

2. Salve o arquivo como updated_model.ipynb.

3. Cole o seguinte código na primeira célula de updated_model.ipynb:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging up_logger = logging.getLogger('upLogger') up_logger.setLevel(logging.INFO) up_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="updated")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5) # Logs model summary model.summary(print_fn=up_logger.info)

4. Teste diferentes valores para a camada densa.

Vá até a seção # Define the model e mude de 64 para 128 neurônios:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

4. Pressione Ctrl + S ou acesse Arquivo > Salvar notebook para salvar as mudanças.

5. Execute o código clicando no botão Executar ou pressionando Shift + Enter.

Quais são os diferentes resultados de perda, tempo de treinamento etc.? Por quê?

Ao aumentar para 128 neurônios, é necessário fazer mais cálculos. Isso reduz a velocidade do processo de treinamento. Neste caso, o aumento teve um impacto positivo porque o modelo está mais acurado. Mas nem sempre "mais é melhor". É possível que os benefícios diminuam muito rapidamente.

Clique em Verificar meu progresso para conferir o objetivo. Exercício 1

Exercício 2

Considere os efeitos das camadas extras na rede. O que vai acontecer se você adicionar outra camada entre duas camadas densas?

1. Em updated_model.ipynb, adicione uma camada na seção # Define the model.

Substitua a definição do modelo pelo seguinte:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Pressione Ctrl + S ou acesse Arquivo > Salvar notebook para salvar as mudanças.

3. Execute o código clicando no botão Executar ou pressionando Shift + Enter.

Resposta: nenhum impacto significativo, porque os dados são relativamente simples. Para dados muito mais complexos, costumam ser necessárias camadas extras.

Clique em Verificar meu progresso para conferir o objetivo. Exercício 2

Exercício 3

Antes de treinar o modelo, você normalizou os valores dos pixels para o intervalo [0, 1]. Qual seria o impacto de remover a normalização de modo que os valores estivessem no intervalo [0, 255], como estavam no conjunto de dados originalmente?

1. Faça um teste! Em # Define, load and configure data, remova a função de mapeamento aplicada aos conjuntos de dados de treinamento e teste.

# Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.batch(BATCH_SIZE) ds_test = ds_test.batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Adicione esse código ao final da célula para imprimir o valor máximo da primeira imagem no lote 0. Sem a normalização, o valor máximo vai estar no intervalo [0, 255].

# Print out max value to see the changes image_batch, labels_batch = next(iter(ds_train)) t_image_batch, t_labels_batch = next(iter(ds_test)) up_logger.info("training images max " + str(np.max(image_batch[0]))) up_logger.info("test images max " + str(np.max(t_image_batch[0])))

3. O updated_model.ipynb final vai ficar assim:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging up_logger = logging.getLogger('upLogger') up_logger.setLevel(logging.INFO) up_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="updated")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.batch(BATCH_SIZE) ds_test = ds_test.batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5) # Logs model summary model.summary(print_fn=up_logger.info) # Print out max value to see the changes image_batch, labels_batch = next(iter(ds_train)) t_image_batch, t_labels_batch = next(iter(ds_test)) up_logger.info("training images max " + str(np.max(image_batch[0]))) up_logger.info("test images max " + str(np.max(t_image_batch[0])))

4. Pressione Ctrl + S ou acesse Arquivo > Salvar notebook para salvar as mudanças.

5. Execute o código clicando no botão Executar ou pressionando Shift + Enter.

Saída esperada para # Print out max value to see the changes

INFO:upLogger:training images max 255 INFO:upLogger:test images max 255

Depois de completar as épocas, é possível conferir como a acurácia muda sem a normalização.

Por que isso acontece?

Há uma resposta ótima aqui no Stack Overflow (em inglês).

Clique em Verificar meu progresso para conferir o objetivo. Exercício 3

Exercício 4

O que vai acontecer se você remover a camada Flatten()? Por quê?

Vá em frente, teste:

1. Na seção # Define the model, remova tf.keras.layers.Flatten():

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Salve e execute a célula em updated_model.ipynb.

Você vai receber um erro relacionado à forma dos dados. Isso já é esperado.

Os detalhes do erro podem parecer vagos agora, mas isso reforça a regra de que a primeira camada da rede deve ter a mesma forma que os dados. Agora, as imagens de entrada estão na forma 28 x 28, e não seria viável ter 28 camadas de 28 neurônios. Por isso, faz mais sentido nivelar 28,28 para 784x1.

Em vez de escrever todo o código para fazer isso, basta adicionar a camada Flatten() no início. Quando as matrizes forem adicionadas ao modelo mais tarde, elas serão niveladas automaticamente para você.

Exercício 5

Observe a última camada (da saída). Por que há 10 neurônios na camada final? O que aconteceria se você tivesse um número diferente de 10?

Para descobrir, treine a rede com 5.

1. Substitua a seção # Define the model pelo seguinte código para desfazer a mudança que você fez na seção anterior:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Mude o número de neurônios da última camada de 10 para 5:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(5, activation=tf.nn.softmax)])

3. Salve e execute a célula em updated_model.ipynb.

O que acontece: você recebe um erro assim que um valor inesperado é encontrado.

Outra regra: o número de neurônios da última camada deve corresponder ao número de classes usadas. Neste caso, as classes são os dígitos de 0 a 9, então há 10, por isso você deve ter 10 neurônios na última camada.

Parabéns!

Muito bem! Neste laboratório, você aprendeu a elaborar, compilar, treinar e avaliar um modelo do TensorFlow. Você também aprendeu a salvar e carregar modelos, além de escrever seus próprios callbacks para personalizar o comportamento durante o treinamento. Além disso, fez uma série de exercícios para guiar seus experimentos com as diferentes camadas da rede.

Próximas etapas / Saiba mais

• Confira tudo que você precisa saber no Curso intensivo de machine learning.
• Divirta-se testando para entender o que é possível fazer com a visão computacional.
• Confira a documentação da Vertex AI para saber como o machine learning está integrado a essa plataforma.
• A IA abre um mundo de diversão! Confira os Experimentos com o Google.
• Saiba mais sobre o TensorFlow.

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 12 de setembro de 2024

Laboratório testado em 12 de setembro de 2024

Copyright 2025 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.