GSP637

Visão geral

Neste laboratório, você vai conhecer o modelo básico "Hello World" de machine learning. Em vez de programar regras explícitas em uma linguagem como Java ou C++, você cria um sistema treinado com dados que infere as regras que determinam a relação entre números.

Objetivos

Neste laboratório, você vai aprender a:

• Configurar o ambiente de desenvolvimento no notebook do Jupyter
• Elaborar um modelo de machine learning
• Treinar uma rede neural
• Testar um modelo

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.

Introdução

Considere o seguinte problema: você está criando um sistema que reconhece atividades para controle de condicionamento físico. Você tem acesso à velocidade em que uma pessoa se move e tenta inferir a atividade com base nesse dado usando uma fórmula condicional:

if(speed<4){ status=CAMINHADA; }

• Isso pode ser estendido para corrida usando outra condição:

if(speed<4){ status=CAMINHADA; } else { status=CORRIDA; }

• Da mesma forma, seria possível detectar se a pessoa está praticando ciclismo usando outra condição:

if(speed<4){ status=CAMINHADA; } else if(speed<12){ status=CORRIDA; } else { status=CICLISMO; }

• O que aconteceria se você quisesse incluir uma atividade como golfe? Não é tão simples criar uma regra para identificar essa atividade.

// E agora?

É muito difícil escrever um programa (em código) que ajude a identificar a atividade de golfe.

Então, o fazemos nesse caso? Usamos machine learning para resolver o problema!

O que é machine learning?

Na seção anterior, você encontrou um problema para identificar a atividade de condicionamento físico de um usuário. Você atingiu um limite do que seria possível fazer escrevendo mais código porque as condições precisam ser mais complexas para detectar uma atividade como golfe.

Considere o processo tradicional de criação de aplicativos representado no seguinte diagrama:

Você expressa regras em uma linguagem de programação. Elas atuam com os dados e seu programa fornece respostas. No caso da detecção de atividades, as regras (o código que você escreve para definir os tipos de atividades) atuam com base nos dados (a velocidade de movimento da pessoa) para encontrar uma resposta, ou seja, o valor retornado pela função que determina o status de atividade do usuário (caminhada, corrida, ciclismo etc.).

O processo de detecção de atividades com machine learning é muito similar, o que muda são os eixos:

Em vez de tentar definir as regras e expressá-las em uma linguagem de programação, você fornece as respostas (que costumam ser chamadas de rótulos) com os dados. Em seguida, a máquina infere as regras que determinam a relação entre as respostas e os dados. Por exemplo, em um contexto de machine learning, seu cenário de detecção de atividade poderia ser assim:

Você coleta vários dados e usa rótulos para indicar que "Uma caminhada é assim", "Uma corrida é assim" etc. Depois, com base nos dados, o computador pode inferir as regras que determinam os padrões distintos que correspondem a uma atividade específica.

Além de ser um método alternativo de programar o cenário, isso também permite abordar novos casos, como golfe, o que talvez não seria possível usando a programação tradicional baseada em regras.

Na programação tradicional, seu código é compilado em um binário que costuma ser chamado de programa. Em machine learning, o item criado com base nos dados e rótulos é chamado de modelo.

Então, se voltarmos para o diagrama:

Considere o resultado acima um modelo, que é usado assim no ambiente de execução:

Você passa alguns dados ao modelo, que usa as regras inferidas no treinamento para gerar uma previsão, ou seja, "Esses dados parecem caminhada", "Esses dados parecem ciclismo" etc.

Neste laboratório, você vai criar um modelo "Hello World" muito simples usando elementos básicos que servem para qualquer cenário de machine learning.

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 Other, 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 seu primeiro modelo de machine learning

Considere os conjuntos de números a seguir. Você consegue identificar alguma relação entre eles?

X:	-1	0	1	2	3	4
Y:	-2	1	4	7	10	13

Lendo da esquerda para a direita, você percebe que o valor de X aumenta em 1 e o valor correspondente de Y aumenta em 3. Então, a relação deve ser y=3x mais ou menos algum valor.

Depois, note que quando X é 0, o valor correspondente de Y é 1.

Com base nessas duas observações, é possível determinar que a relação é y=3x+1.

Isso é uma representação quase exata de como você usaria código para treinar um modelo, conhecido como uma rede neural, para identificar padrões nos dados.

Você usa dados para treinar a rede neural. Depois de ser alimentada com um conjunto de valores de X e Y, ela deve ser capaz de descobrir a relação entre eles.

Criar um 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 sobre notebooks do Jupyter.

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

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. Para executar a célula, clique no botão Run ou pressione Shift + Enter.

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

Observação: ignore os avisos que aparecerem na saída.

Preparar os dados

Em seguida, você vai preparar os dados que serão usados para treinar seu modelo. Neste laboratório, você está usando os seis Xs e os seis Ys de antes:

X:	-1	0	1	2	3	4
Y:	-2	1	4	7	10	13

A relação entre os Xs e os Ys é y=3x+1, de modo que X = 1, Y = 4 e assim por diante.

Uma biblioteca python chamada numpy oferece diversas estruturas de dados do tipo matriz que são o modo padrão de inserir os dados. Para usar essas estruturas, especifique os valores como uma matriz em numpy usando np.array([])

1. Na segunda célula, adicione o seguinte código:

xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float) ys = np.array([-2.0, 1.0, 4.0, 7.0, 10.0, 13.0], dtype=float)

Elaborar o modelo

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

Um algoritmo de machine learning chamado rede neural será usado para treinar seu modelo. Você vai criar a rede neural mais simples possível. Ela tem uma camada com um neurônio. A entrada da rede neural só pode ter um valor por vez. Assim, o formato de entrada precisa ser [1].

Observação: você vai saber mais sobre redes neurais nos próximos laboratórios desta Quest.

1. Na segunda célula, adicione o seguinte código:

model = tf.keras.Sequential([tf.keras.layers.Dense(units=1, input_shape=[1])])

Compilar o modelo

Em seguida, você vai escrever o código para compilar sua rede neural. Ao fazer isso, você precisa especificar duas funções: uma de perda e uma otimizadora.

Você já deve ter notado que há muita matemática no machine learning (e é aqui que ela costuma ser mais usada), mas o tf.keras coloca tudo em funções para você.

• Com base na investigação anterior, você sabe que a relação entre os números é y=3x+1.

• Quando o computador está aprendendo essa relação, ele faz uma tentativa, como y=10x+10. A função de perda mede as respostas testadas em comparação às corretas já conhecidas e mede se o modelo foi bem ou mal.

Observação: saiba mais sobre diferentes tipos de funções de perda disponíveis em tf.keras na documentação do módulo: tf.keras.losses.

• Depois, o modelo usa a função otimizadora para fazer outra tentativa. Com base no resultado da função de perda, ele tenta minimizar a perda. Nesse ponto, talvez ele chegue a algo como y=5x+5. Mesmo que ainda esteja errado, isso está mais próximo do resultado certo (ou seja, a perda é menor).

Observação: saiba mais sobre diferentes tipos de funções otimizadoras disponíveis em tf.keras na documentação do módulo: tf.keras.optimizers.

• O modelo repete isso pelo número de períodos que você especificar.

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

model.compile(optimizer=tf.keras.optimizers.SGD(), loss=tf.keras.losses.MeanSquaredError())

No snippet de código acima, você fala para o modelo usar mean_squared_error como função de perda e stochastic gradient descent (sgd) como função otimizadora. Você ainda não precisa entender a matemática por trás dessas funções, mas vai saber como elas funcionam.

Observação: ao longo do tempo, você vai aprender as funções de perda e otimizadoras adequadas para cada cenário.

Treinar a rede neural

Para treinar a rede neural para "aprender" a relação entre Xs e Ys, você vai usar a função model.fit.

Ela vai treinar o modelo repetindo o processo de testar uma resposta, medir se ela foi boa ou ruim (ou seja, a perda), usar a função otimizadora para testar outra resposta etc. Isso será repetido pelo número de períodos que você definir, que neste laboratório é 500.

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

model.fit(xs, ys, epochs=500)

No código acima, model.fit vai treinar o modelo por um número fixo de períodos.

Observação: saiba mais sobre model.fit na seção sobre adequação da documentação do modelo tf.keras.

Agora, seu arquivo deve estar mais ou menos assim (o código vai estar em duas células separadas):

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()) import tensorflow as tf import numpy as np xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float) ys = np.array([-2.0, 1.0, 4.0, 7.0, 10.0, 13.0], dtype=float) model = tf.keras.Sequential([tf.keras.layers.Dense(units=1, input_shape=[1])]) model.compile(optimizer=tf.keras.optimizers.SGD(), loss=tf.keras.losses.MeanSquaredError()) model.fit(xs, ys, epochs=500)

Executar o código

Seu script está pronto! Execute para conferir o que acontece.

1. Clique no botão Run ou pressione Shift + Enter para executar a segunda célula no notebook.

2. Confira a saída. O script aponta a perda de cada período. Sua saída pode ser um pouco diferente da mostrada aqui.

Observação: um número com valor e- está sendo mostrado como uma notação científica com um expoente negativo.

Se você navegar pelos períodos, vai notar que o valor da perda é bastante alto nos primeiros e diminui a cada etapa. Exemplo:

Conforme o treinamento avança, a perda fica muito pequena:

Quando o treinamento termina, a perda fica extremamente pequena, mostrando que nosso modelo está inferindo muito bem a relação entre os números:

Você provavelmente não precisa de todos os 500 períodos. Tente testar diferentes valores. Analisando esse exemplo, a perda é muito menor depois de apenas 50 períodos, então talvez isso seja suficiente.

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

Como usar o modelo

Agora você tem um modelo treinado para aprender a relação entre X e Y.

O método model.predict pode ser usado para descobrir o Y de um X desconhecido para o modelo durante o treinamento. Então, por exemplo, se X = 10, qual será o Y?

1. Adicione o seguinte código à terceira célula para fazer uma previsão:

cloud_logger.info(str(model.predict(np.array([10.0])))) Observação: o resultado da sua previsão é passado para cloud_logger para gerar registros do Cloud que podem ser consultados para acompanhar o progresso.

2. Pressione Ctrl+S ou clique em File -> Save para salvar seu notebook.

3. Para executar a terceira célula, clique no botão Run ou pressione Shift + Enter.

O valor de Y é listado depois do registro do treinamento (períodos).

Exemplo de saída:

Você deve ter pensado que Y=31, certo? Mas o resultado ficou um pouco acima (31,005917). Por que isso aconteceu?

Resposta: a rede neural lida com probabilidades. Ela calculou que há uma alta probabilidade de que a relação entre X e Y seja y=3x+1. Mas, com apenas seis pontos de dados, ela não tem como saber com certeza. Por isso, o resultado para 10 é muito próximo de 31, mas não necessariamente 31.

Conforme trabalha com redes neurais, você vai notar esse padrão recorrente. Você quase sempre vai lidar com probabilidades, não certezas, e vai programar um pouco para descobrir o resultado com base nas probabilidades, principalmente para classificações.

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

Parabéns!

Muito bem! Neste laboratório, você criou, treinou e testou seu próprio modelo de machine learning usando o TensorFlow.

Próximas etapas / Saiba mais

• Confira tudo que você precisa saber sobre a Vertex AI.
• A IA abre um mundo de diversão! Confira os Experimentos com o Google.
• Saiba mais sobre o TensorFlow.
• Chaveamento com o machine learning do Google
• Fundamentos do BQML
• Estimar tarifas de táxi com um modelo de previsão do BigQuery ML

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 16 de setembro de 2024

Laboratório testado em 16 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.