GSP271

Informações gerais

Introdução

Neste laboratório, você vai implementar regressão logística usando uma biblioteca de machine learning para Apache Spark. O Spark é executado em um cluster do Dataproc para desenvolver um modelo de dados de um conjunto de dados multivariável.

O Cloud Dataproc é um serviço de nuvem totalmente gerenciado, rápido e fácil de usar, que executa os clusters do Apache Spark e do Apache Hadoop de maneira simples e econômica. O Dataproc se integra facilmente a outros serviços do Google Cloud, oferecendo uma plataforma completa e potente de processamento de dados, análise e machine learning.

O Apache Spark é um mecanismo de análise para processamento de dados em grande escala. A regressão logística está disponível como um módulo da biblioteca de machine learning do Apache Spark, MLlib. O Spark MLlib, também chamado de Spark ML, inclui implementações para a maioria dos algoritmos de machine learning padrão, como clustering k-means, florestas aleatórias, mínimos quadrados alternados, árvores de decisão, máquinas de vetores de suporte e outros. O Spark pode ser executado em um cluster do Hadoop, como o Dataproc, para processar conjuntos de dados muito grandes em paralelo.

O conjunto de dados base que este laboratório usa foi obtido da Agência de Estatísticas de Transporte dos EUA. Ele tem informações históricas sobre voos domésticos nos Estados Unidos e pode ser usado para demonstrar muitos conceitos e técnicas da ciência de dados. Este laboratório fornece os dados como um conjunto de arquivos de texto formatados em CSV.

Objetivos

• Criar um conjunto de dados de treinamento para machine learning usando o Spark
• Desenvolver um modelo de machine learning de regressão logística usando o Spark
• Avaliar o comportamento preditivo de um modelo de machine learning usando o Spark no Dataproc
• Avaliar o modelo

Configuração e requisitos

Antes de clicar no botão Start Lab

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o 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, 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 ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.

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

Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar, você verá um pop-up para selecionar a forma de pagamento. No painel Detalhes do laboratório à esquerda, você vai encontrar o seguinte:

   • O botão Abrir console do Google Cloud
   • O tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações, se forem necessárias

2. Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.

   O laboratório ativa os recursos e depois abre a página Fazer login em outra guia.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Fazer login.

   {{{user_0.username | "Nome de usuário"}}}

   Você também encontra o Nome de usuário no painel Detalhes do laboratório.

4. Clique em Seguinte.

5. Copie a Senha abaixo e cole na caixa de diálogo de boas-vindas.

   {{{user_0.password | "Senha"}}}

   Você também encontra a Senha no painel Detalhes do laboratório.

6. Clique em Seguinte.

   Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

7. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.

Observação: clique em Menu de navegação no canto superior esquerdo para acessar uma lista de produtos e serviços do Google Cloud.

Tarefa 1. Criar um cluster do Dataproc

Normalmente, a primeira etapa para escrever jobs do Hadoop é iniciar a instalação do Hadoop. Isso envolve configurar um cluster, instalar o Hadoop nele e configurá-lo para que todas as máquinas conheçam umas às outras e possam se comunicar de maneira segura.

Em seguida, é necessário iniciar os processos YARN e MapReduce. Feito isso, você estará pronto para escrever alguns programas Hadoop. No Google Cloud, o Dataproc torna conveniente a criação de um cluster Hadoop capaz de executar MapReduce, Pig, Hive, Presto e Spark.

Se você estiver usando o Spark, o Dataproc vai oferecer um ambiente Spark totalmente gerenciado e sem servidor. Basta enviar um programa Spark para que ele seja executado pelo Dataproc. Dessa forma, o Dataproc está para o Apache Spark assim como o Dataflow está para o Apache Beam. Na verdade, o Dataproc e o Dataflow compartilham serviços de back-end.

Nesta seção, você vai criar uma VM e depois um cluster do Dataproc nela.

1. No console do Cloud, acesse o Menu de navegação () e clique em Compute Engine > Instâncias de VM.

2. Clique no botão SSH ao lado da VM startup-vm para iniciar um terminal e conectar.

3. Clique em Conectar para confirmar a conexão SSH.

4. Execute o seguinte comando para clonar o repositório data-science-on-gcp e navegue até o diretório 06_dataproc:

git clone https://github.com/GoogleCloudPlatform/data-science-on-gcp/ cd ~/data-science-on-gcp/06_dataproc

5. Defina a variável do projeto e do bucket usando o seguinte código:

export PROJECT_ID=$(gcloud info --format='value(config.project)') export BUCKET_NAME=$PROJECT_ID-dsongcp

6. Edite o arquivo create_cluster.sh removendo o código de dependência por zona --zone ${REGION}-a

nano create_cluster.sh

Sua resposta será semelhante ao seguinte:

gcloud dataproc clusters create ch6cluster \ --enable-component-gateway \ --region ${REGION} \ --master-machine-type n1-standard-4 \ --master-boot-disk-size 500 --num-workers 2 \ --worker-machine-type n1-standard-4 \ --worker-boot-disk-size 500 \ --optional-components JUPYTER --project $PROJECT \ --initialization-actions=$INSTALL \ --scopes https://www.googleapis.com/auth/cloud-platform

7. Salve o arquivo usando Ctrl+X, pressione Y e Enter

8. Crie um cluster do Dataproc para executar jobs, especificando o nome do bucket e a região em que ele está:

./create_cluster.sh $BUCKET_NAME {{{ project_0.default_region | "REGION" }}}

Esse comando pode levar alguns minutos.

Observação: ao executar essas tarefas fora deste laboratório, a zona do Compute precisa estar na mesma região que o bucket para evitar cobranças de saída de rede. Criar cluster do Cloud Dataproc

JupyterLab no Dataproc

1. No console do Cloud, no Menu de navegação, clique em Dataproc. Talvez seja necessário clicar em Mais produtos e rolar a tela para baixo.

2. Na lista de Clusters, clique no nome do cluster para visualizar detalhes.

3. Clique na guia Interfaces da Web e depois em JupyterLab na parte de baixo do painel direito.

4. Na seção de acesso rápido Notebook, clique em Python 3 para abrir um novo notebook.

Para usar um Notebook, digite comandos em uma célula. Para executar os comandos na célula, pressione Shift + Enter ou clique no triângulo no menu superior "Notebook" para executar células selecionadas e avançar.

Tarefa 2. Configurar o bucket e iniciar a sessão do pyspark

1. Configure um bucket do Google Cloud Storage onde seus arquivos brutos estão hospedados:

PROJECT=!gcloud config get-value project PROJECT=PROJECT[0] BUCKET = PROJECT + '-dsongcp' import os os.environ['BUCKET'] = PROJECT + '-dsongcp'

2. Execute a célula pressionando Shift + Enter ou clicando no triângulo no menu superior do Notebook para Executar células selecionadas e avançar.

Observação: depois de colar os comandos na célula do notebook Jupyter, sempre execute a célula para executar o comando e avançar para a próxima célula.

3. Crie uma sessão Spark usando o seguinte bloco de código:

from pyspark.sql import SparkSession from pyspark import SparkContext sc = SparkContext('local', 'logistic') spark = SparkSession \ .builder \ .appName("Logistic regression w/ Spark ML") \ .getOrCreate()

Quando esse código for adicionado ao início de qualquer script do Spark Python, todos os códigos desenvolvidos com o shell interativo do Spark ou o notebook do Jupyter também vão funcionar ao serem iniciados como scripts independentes.

Crie um DataFrame do Spark para treinamento

1. Digite os seguintes comandos na nova célula:

from pyspark.mllib.classification import LogisticRegressionWithLBFGS from pyspark.mllib.regression import LabeledPoint

2. Execute a célula.

Observação: ao colar comandos na célula do notebook do Jupyter, lembre-se de executar a célula para garantir que o último comando de qualquer sequência seja executado antes de prosseguir para a próxima etapa.

Tarefa 3. Ler e limpar o conjunto de dados

Quando você iniciou este laboratório, um script automatizado forneceu dados como um conjunto de arquivos CSV preparados e foi colocado no bucket do Cloud Storage.

• Agora, busque o nome do bucket do Cloud Storage na variável de ambiente definida anteriormente e crie o DataFrame traindays lendo um CSV preparado que o script automatizado coloca em seu bucket do Cloud Storage.

O CSV identifica um subconjunto de dias como válido para treinamento. Isso permite que você crie visualizações de todo o conjunto de dados flights, que é dividido em um conjunto de dados usado para treinar seu modelo e um conjunto de dados usado para testar ou validar o modelo.

Ler o conjunto de dados

1. Insira e execute os seguintes comandos na nova célula:

traindays = spark.read \ .option("header", "true") \ .csv('gs://{}/flights/trainday.csv'.format(BUCKET)) traindays.createOrReplaceTempView('traindays')

2. Criar uma visualização Spark SQL:

traindays.createOrReplaceTempView('traindays')

3. Consulte os primeiros registros da visualização do conjunto de dados de treinamento:

spark.sql("SELECT * from traindays LIMIT 5").show()

Isso mostra os cinco primeiros registros da tabela de treinamento:

A próxima etapa do processo é identificar os arquivos de dados de origem.

4. Você usará o fragmento de arquivo all_flights-00000-* para isso, porque ele tem um subconjunto representativo do conjunto de dados completo e seu processamento tem uma duração razoável:

inputs = 'gs://{}/flights/tzcorr/all_flights-00000-*'.format(BUCKET) Observação: Para processar o conjunto de dados completo, altere a linha anterior para a linha a seguir: #inputs = 'gs://{}/flights/tzcorr/all_flights-*'.format(BUCKET) # FULL

5. Agora leia os dados no Spark SQL a partir do arquivo de entrada que você criou:

flights = spark.read.json(inputs) flights.createOrReplaceTempView('flights')

6. Em seguida, crie uma consulta que use apenas os dados dos dias identificados como parte do conjunto de dados de treinamento:

trainquery = """ SELECT DEP_DELAY, TAXI_OUT, ARR_DELAY, DISTANCE FROM flights f JOIN traindays t ON f.FL_DATE == t.FL_DATE WHERE t.is_train_day == 'True' """ traindata = spark.sql(trainquery)

7. Inspecione alguns dados e verifique se estão corretos:

print(traindata.head(2)) Observação: O seguinte aviso vai aparecer: "Truncated the string representation of a plan since it was too large". Neste laboratório, você pode ignorar esse aviso porque ele só será relevante se você quiser inspecionar os logs do esquema SQL.

O resultado deve ser algo semelhante ao seguinte:

[Row(DEP_DELAY=-2.0, TAXI_OUT=26.0, ARR_DELAY=0.0, DISTANCE=677.0), Row(DEP_DELAY=-2.0, TAXI_OUT=22.0, ARR_DELAY=3. 0, DISTANCE=451.0)]

8. Peça ao Spark que faça uma análise do conjunto de dados:

traindata.describe().show()

Isso vai produzir algo semelhante ao seguinte:

Limpar o conjunto de dados

Os valores de média e desvio padrão foram arredondados para duas casas decimais para tornar a tabela mais clara, mas os valores de ponto flutuante completos vão aparecer na tela.

A tabela mostra que há alguns problemas com os dados. Nem todos os registros têm valores para todas as variáveis. Há diferentes estatísticas de contagem para DEP_DELAY, TAXI_OUT, ARR_DELAY e DISTANCE. Isso acontece porque:

• há voos programados que não partem;
• alguns partem, mas são cancelados antes de decolar;
• alguns voos são desviados e, portanto, não chegam.

Observação: as contagens das colunas são todas diferentes; temos que remover NULLs nas variáveis de atraso (correspondem a voos cancelados ou desviados).

1. Digite o seguinte código na nova célula: trainquery = """ SELECT DEP_DELAY, TAXI_OUT, ARR_DELAY, DISTANCE FROM flights f JOIN traindays t ON f.FL_DATE == t.FL_DATE WHERE t.is_train_day == 'True' AND f.dep_delay IS NOT NULL AND f.arr_delay IS NOT NULL """ traindata = spark.sql(trainquery) traindata.describe().show()

Isso vai produzir algo semelhante ao seguinte:

2. Remova voos que foram cancelados ou desviados usando a seguinte consulta:

trainquery = """ SELECT DEP_DELAY, TAXI_OUT, ARR_DELAY, DISTANCE FROM flights f JOIN traindays t ON f.FL_DATE == t.FL_DATE WHERE t.is_train_day == 'True' AND f.CANCELLED == 'False' AND f.DIVERTED == 'False' """ traindata = spark.sql(trainquery) traindata.describe().show()

Essa saída deve mostrar o mesmo valor de contagem para cada coluna, o que indica que o problema foi corrigido.

Tarefa 4. Desenvolver um modelo de regressão logística

Agora você pode criar uma função que converta um conjunto de pontos de dados do seu DataFrame em um exemplo de treinamento. Um exemplo de treinamento contém uma amostra dos recursos de entrada e a resposta correta para essas entradas.

Neste caso, você responde se o atraso na chegada é inferior a 15 minutos. Os rótulos que você usa como entradas são os valores de atraso de partida, tempo de taxiamento antes da decolagem e distância do voo.

1. Insira e execute o seguinte na nova célula para criar a definição para a função de exemplo de treinamento:

def to_example(fields): return LabeledPoint(\ float(fields['ARR_DELAY'] < 15), #ontime? \ [ \ fields['DEP_DELAY'], \ fields['TAXI_OUT'], \ fields['DISTANCE'], \ ])

2. Associe esta função de exemplo de treinamento ao conjunto de dados de treinamento:

examples = traindata.rdd.map(to_example)

3. Insira e execute o seguinte comando para fornecer um DataFrame de treinamento para o módulo de regressão logística do Spark:

lrmodel = LogisticRegressionWithLBFGS.train(examples, intercept=True)

O DataFrame de treinamento cria um modelo de regressão logística com base em seu conjunto de dados de treinamento.

• Use o parâmetro intercept=True porque a previsão do atraso de chegada não é igual a zero quando todas as entradas são zero neste caso.
• Se estivesse trabalhando com um conjunto de dados de treinamento no qual você espera uma previsão de zero quando todas as entradas forem zero, nesse caso você especificaria intercept=False.

4. Quando esse método de treinamento terminar, o objeto lrmodel terá pesos e um valor de interceptação que você poderá inspecionar:

print(lrmodel.weights,lrmodel.intercept)

A resposta será semelhante a:

[-0.17926510230641074,-0.1353410840270897,0.00047781052266304745] 5.403405250989946

Esses pesos, quando usados com a fórmula de regressão linear, permitem criar um modelo usando código na linguagem que você escolher.

5. Teste isso fornecendo algumas variáveis de entrada para um voo que tenha:

• Atraso de partida de 6 minutos
• Tempo de taxiamento antes da decolagem de 12 minutos
• Distância de voo de 594 milhas

print(lrmodel.predict([6.0,12.0,594.0]))

O resultado 1 prevê que o voo chegará no horário.

6. Agora tente com um atraso de partida bem mais longo, de 36 minutos.

print(lrmodel.predict([36.0,12.0,594.0]))

O resultado 0 prevê que o voo não chegará no horário.

Esses resultados não são probabilidades. Eles são retornados como verdadeiro ou falso com base em um limite configurado por padrão como 0,5.

7. Você pode retornar a probabilidade real eliminando o limite:

lrmodel.clearThreshold() print(lrmodel.predict([6.0,12.0,594.0])) print(lrmodel.predict([36.0,12.0,594.0]))

Os resultados são probabilidades, com o primeiro próximo de 1 e o segundo próximo de 0.

8. Defina o limite como 0,7 para corresponder à sua exigência de poder cancelar as reuniões se a probabilidade de uma chegada no horário cair para menos de 70%:

lrmodel.setThreshold(0.7) print(lrmodel.predict([6.0,12.0,594.0])) print(lrmodel.predict([36.0,12.0,594.0]))

Seus resultados são novamente 1 e 0, mas agora elas refletem o limite de probabilidade de 70% que você exige, e não o padrão de 50%.

Tarefa 5. Salvar e restaurar um modelo de regressão logística

Você pode salvar um modelo de regressão logística do Spark diretamente no Cloud Storage. Isso permite reutilizar um modelo sem precisar treiná-lo novamente do zero.

Um local de armazenamento contém apenas um modelo. Isso evita interferência com outros arquivos que poderiam causar problemas de carregamento do modelo. Para fazer isso, verifique se o local de armazenamento está vazio antes de salvar seu modelo de regressão do Spark.

1. Insira o seguinte código na nova célula e execute:

MODEL_FILE='gs://' + BUCKET + '/flights/sparkmloutput/model' os.system('gsutil -m rm -r ' + MODEL_FILE)

Isso vai retornar o erro CommandException: 1 files/objects could not be removed, porque o modelo ainda não foi salvo. O erro indica que não há arquivos presentes no local de destino. Você precisa ter certeza de que esse local está vazio antes de salvar o modelo, e esse comando garante isso.

2. Salve o modelo executando o seguinte:

lrmodel.save(sc, MODEL_FILE) print('{} saved'.format(MODEL_FILE))

3. Agora, destrua o objeto do modelo na memória e confirme que ele não contém mais nenhum dado do modelo:

lrmodel = 0 print(lrmodel)

4. Agora recupere o modelo do armazenamento:

from pyspark.mllib.classification import LogisticRegressionModel lrmodel = LogisticRegressionModel.load(sc, MODEL_FILE) lrmodel.setThreshold(0.7)

Os parâmetros do modelo, ou seja, os pesos e os valores do intercepto, foram restaurados.

Criar um modelo de regressão logística

Tarefa 6. Prever com o modelo de regressão logística

1. Teste o modelo com um cenário em que o voo definitivamente não chegará no horário:

print(lrmodel.predict([36.0,12.0,594.0]))

Isso imprime 0, prevendo que o voo provavelmente vai chegar atrasado, dado seu limite de probabilidade de 70%.

2. Por fim, volte a testar o modelo usando dados de um voo que deve chegar no horário:

print(lrmodel.predict([8.0,4.0,594.0]))

Isso imprime 1, prevendo que o voo provavelmente vai chegar a tempo, dado seu limite de probabilidade de 70%.

Tarefa 7. Examinar o comportamento do modelo

1. Insira o seguinte código em uma nova célula e execute a célula:

lrmodel.clearThreshold() # para fazer com que o modelo produza probabilidades print(lrmodel.predict([20, 10, 500]))

Com os limites removidos, você obtém probabilidades. A probabilidade de chegar atrasado aumenta à medida que cresce o atraso na partida.

2. Com um atraso na partida de 20 minutos e um tempo de taxiamento antes de decolar de 10 minutos, a distância afeta a probabilidade de o voo chegar no horário da seguinte maneira:

import matplotlib.pyplot as plt import seaborn as sns import pandas as pd import numpy as np dist = np.arange(10, 2000, 10) prob = [lrmodel.predict([20, 10, d]) for d in dist] sns.set_style("whitegrid") ax = plt.plot(dist, prob) plt.xlabel('distance (miles)') plt.ylabel('probability of ontime arrival')

Você pode notar que o efeito é relativamente pequeno. A probabilidade aumenta de cerca de 0,63 para cerca de 0,76 à medida que a distância muda de um trecho muito curto para um voo intercontinental.

3. Execute o seguinte na nova célula:

delay = np.arange(-20, 60, 1) prob = [lrmodel.predict([d, 10, 500]) for d in delay] ax = plt.plot(delay, prob) plt.xlabel('departure delay (minutes)') plt.ylabel('probability of ontime arrival')

Por outro lado, se mantivermos a distância e o tempo de taxiamento antes de decolar constantes e examinarmos a dependência do atraso na partida, teremos um impacto mais significativo.

Tarefa 8. Avaliar o modelo

1. Para avaliar o modelo de regressão logística, você precisa de dados de teste:

inputs = 'gs://{}/flights/tzcorr/all_flights-00001-*'.format(BUCKET) flights = spark.read.json(inputs) flights.createOrReplaceTempView('flights') testquery = trainquery.replace("t.is_train_day == 'True'","t.is_train_day == 'False'")

2. Agora associe esta função de exemplo de treinamento ao conjunto de dados de teste:

testdata = spark.sql(testquery) examples = testdata.rdd.map(to_example)

3. Peça ao Spark que faça uma análise do conjunto de dados:

testdata.describe().show()

Isso vai produzir algo semelhante ao seguinte:

4. Defina uma função eval e retorne detalhes de total de cancelamentos, total de não cancelamentos, cancelamentos corretos e não cancelamentos corretos de voos:

def eval(labelpred): ''' data = (label, pred) data[0] = label data[1] = pred ''' cancel = labelpred.filter(lambda data: data[1] < 0.7) nocancel = labelpred.filter(lambda data: data[1] >= 0.7) corr_cancel = cancel.filter(lambda data: data[0] == int(data[1] >= 0.7)).count() corr_nocancel = nocancel.filter(lambda data: data[0] == int(data[1] >= 0.7)).count() cancel_denom = cancel.count() nocancel_denom = nocancel.count() if cancel_denom == 0: cancel_denom = 1 if nocancel_denom == 0: nocancel_denom = 1 return {'total_cancel': cancel.count(), \ 'correct_cancel': float(corr_cancel)/cancel_denom, \ 'total_noncancel': nocancel.count(), \ 'correct_noncancel': float(corr_nocancel)/nocancel_denom \ }

5. Agora, avalie o modelo passando o rótulo previsão correta:

lrmodel.clearThreshold() # so it returns probabilities labelpred = examples.map(lambda p: (p.label, lrmodel.predict(p.features))) print('All flights:') print(eval(labelpred))

Saída:

All flights: {'total_cancel': 14689, 'correct_cancel': 0.8239498944788617, 'total_noncancel': 67495, 'correct_noncancel': 0.9556411586043411}

6. Mantenha apenas os exemplos próximos ao limite de decisão superior a 65% e inferior a 75%:

print('Flights near decision threshold:') labelpred = labelpred.filter(lambda data: data[1] > 0.65 and data[1] < 0.75) print(eval(labelpred))

Saída:

Flights near decision threshold: {'total_cancel': 714, 'correct_cancel': 0.3711484593837535, 'total_noncancel': 850, 'correct_noncancel': 0.6788235294117647}

Parabéns!

Agora você sabe usar o Spark para realizar regressão logística com um cluster do Dataproc.

Comece o próximo laboratório

Continue com:

• Machine learning com TensorFlow na Vertex AI

Próximas etapas / Saiba mais

• Data Science on the Google Cloud Platform, 2ª edição, O'Reilly Media, Inc.

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 4 de dezembro de 2023

Laboratório testado em 4 de dezembro de 2023

Copyright 2024 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.