Crie, treine e implante um modelo de Machine Learning

com o Amazon SageMaker

Neste tutorial, você aprenderá como usar o Amazon SageMaker para criar, treinar e implantar um modelo de machine learning (ML). Usaremos o conhecido algoritmo XGBoost ML neste exercício. O Amazon SageMaker é um serviço de machine learning modular, totalmente gerenciado, que ajuda desenvolvedores e cientistas de dados a criar, treinar e implantar modelos ML em grande escala.

Costuma ser complexo e demorado passar modelos ML da conceitualização para a produção. Você precisa gerenciar grandes volumes de dados para treinar o modelo, escolher o melhor algoritmo para treiná-lo, gerenciar a capacidade computacional e treiná-la e, depois, implantar o modelo em um ambiente de produção. O Amazon SageMaker reduz essa complexidade, facilitando a criação e implantação de modelos ML. Depois de escolher os algoritmos e as estruturas de trabalho certas entre as diversas opções disponíveis, ele gerencia toda a infraestrutura subjacente para treinar o seu modelo em escala de petabytes e implantá-lo para produção.

Neste tutorial, você assumirá a função de um desenvolvedor de machine learning que trabalha em um banco. Solicitaram que você desenvolva um modelo de machine learning para prever se um cliente se inscreverá para um certificado de depósito (CD). O modelo será treinado no conjunto de dados de marketing que contém informações sobre a demografia do cliente, respostas a eventos de marketing e fatores externos.

Os dados foram rotulados para sua conveniência e uma coluna no conjunto de dados identifica se o cliente está inscrito para um produto oferecido pelo banco. Uma versão deste conjunto de dados está publicamente disponível no repositório ML pré-selecionado pela Universidade da Califórnia, em Irvine. Este tutorial implementa um modelo de machine learning supervisionado porque os dados são rotulados. (a aprendizagem não supervisionada ocorre quando os conjuntos de dados não são rotulados.)

Neste tutorial, você vai:

  1. Criar uma instância de bloco de anotações
  2. Preparar os dados
  3. Treinar o modelo para aprender com os dados
  4. Implantar o modelo
  5. Avaliar a performance do modelo ML
 
Os recursos criados e usados neste tutorial estão qualificados para o nível gratuito da AWS. Lembre-se de concluir a Etapa 7 e encerrar os seus recursos. Se a sua conta ficou ativa com esses recursos por mais de dois meses, ela será cobrada menos de 0,50 USD.
 

Este tutorial exige uma conta da AWS

Os recursos criados neste tutorial estão qualificados para o nível gratuito. 

Saiba mais sobre o nível gratuito >>


Etapa 1. Acesse o console do Amazon SageMaker

Navegue até o console do Amazon SageMaker.


Quando você clicar aqui, o Console de Gerenciamento da AWS abrirá uma nova janela para que você possa manter aberto este guia detalhado. Em seguida, digite SageMaker na barra de pesquisa e selecione Amazon SageMaker para abrir o console do serviço.

build-train-deploy-machine-learning-model-sagemaker-1
build-train-deploy-machine-learning-model-sagemaker-1

(clique para aumentar)


Etapa 2. Criar uma instância de bloco de anotações do Amazon SageMaker

Nesta etapa, você criará uma instância de bloco de anotações do Amazon SageMaker. 


2a. No painel do Amazon SageMaker, selecione Notebook instances (Instâncias do bloco de anotações). 

build-train-deploy-machine-learning-model-sagemaker-2a
build-train-deploy-machine-learning-model-sagemaker-2a

(clique para aumentar)


2b. Na página Create notebook instance (Criar instância do bloco de anotações), insira um nome no campo Notebook instance name (Nome da instância do bloco de anotações). Este tutorial usa MySageMakerInstance como o nome da instância, mas, se preferir você poderá escolher outro nome.

Para este tutorial, você pode manter o tipo de instância de bloco de anotações padrão ml.t2.medium.

Para habilitar a instância de bloco de anotações para acessar e fazer upload seguro de dados no Amazon S3, uma função do IAM deve ser especificada. No campo IAM role (Função do IAM), escolha Create a new role (Criar uma nova função) para que o Amazon SageMaker crie uma função com as permissões necessárias e as atribua à sua instância. Outra opção é escolher uma função do IAM existente na sua conta com essa finalidade.

build-train-deploy-machine-learning-model-sagemaker-2b
build-train-deploy-machine-learning-model-sagemaker-2b

(clique para aumentar)


2c. Na caixa Create an IAM role (Criar uma função do IAM), selecione Any S3 bucket (Qualquer bucket do S3). Isso permite à instância do Amazon SageMaker acessar todos os buckets do S3 na sua conta. Mais adiante neste tutorial, você criará um novo bucket do S3. Caso já tenha um bucket que deseje usar, selecione Specific S3 buckets (Buckets do S3 específicos) e especifique o nome do bucket.

Selecione Create role (Criar função).

build-train-deploy-machine-learning-model-sagemaker-2c
build-train-deploy-machine-learning-model-sagemaker-2c

(clique para aumentar)


2d. Note que o Amazon SageMaker criou para você uma função chamada AmazonSageMaker-ExecutionRole-***.

Para este tutorial, usaremos os valores padrão para os outros campos. Escolha Create notebook instance (Criar instância de bloco de anotações).

build-train-deploy-machine-learning-model-sagemaker-2d
build-train-deploy-machine-learning-model-sagemaker-2d

(clique para aumentar)


2e. Na página Notebook instances (Instâncias de bloco de anotações), você deve ver a nova instância de bloco de anotações MySageMakerInstance no status Pending (Pendente).

A instância de bloco de anotações deve passar do status Pending (Pendente) para InService em menos de dois minutos.

build-train-deploy-machine-learning-model-sagemaker-2e
build-train-deploy-machine-learning-model-sagemaker-2e

(clique para aumentar)


Etapa 3. Prepare os dados

Nesta etapa, você usará o bloco de anotações do Amazon SageMaker para pré-processar os dados necessários para treinar o modelo de machine learning.


3a. Na página Notebook instances (Instâncias do bloco de anotações), aguarde até a transição de MySageMakerInstance do status Pending (Pendente) para InService.

Quando o status for InService, selecione MySageMakerInstance e abra-o usando o menu suspenso Actions (Ações) ou escolhendo Open Jupyter (Abrir Jupyter) ao lado do status InService.

build-train-deploy-machine-learning-model-sagemaker-3a
build-train-deploy-machine-learning-model-sagemaker-3a

(clique para aumentar)

build-train-deploy-machine-learning-model-sagemaker-3a1
build-train-deploy-machine-learning-model-sagemaker-3a1

(clique para aumentar)


3b. Quando o Jupyter abrir, na guia Files (Arquivos), escolha New (Novo) e, depois, conda_python3

build-train-deploy-machine-learning-model-sagemaker-3b
build-train-deploy-machine-learning-model-sagemaker-3b

(clique para aumentar)


3c. Para preparar os dados, treine o modelo ML e implante-o. Será preciso importar algumas bibliotecas e definir algumas variáveis de ambiente no ambiente de bloco de anotações Jupyter. Copie o seguinte código na célula de código da sua instância e selecione Run (Executar).

Durante a execução do código, aparece um * entre colchetes conforme mostrado na primeira captura de tela à direita. Após alguns segundos, a execução do código será concluída, o * será substituído pelo número 1 e você verá uma mensagem de êxito, conforme mostrado na segunda captura de tela à direita. 

# import libraries
import boto3, re, sys, math, json, os, sagemaker, urllib.request
from sagemaker import get_execution_role
import numpy as np                                
import pandas as pd                               
import matplotlib.pyplot as plt                   
from IPython.display import Image                 
from IPython.display import display               
from time import gmtime, strftime                 
from sagemaker.predictor import csv_serializer   

# Define IAM role
role = get_execution_role()
prefix = 'sagemaker/DEMO-xgboost-dm'
containers = {'us-west-2': '433757028032.dkr.ecr.us-west-2.amazonaws.com/xgboost:latest',
              'us-east-1': '811284229777.dkr.ecr.us-east-1.amazonaws.com/xgboost:latest',
              'us-east-2': '825641698319.dkr.ecr.us-east-2.amazonaws.com/xgboost:latest',
              'eu-west-1': '685385470294.dkr.ecr.eu-west-1.amazonaws.com/xgboost:latest'} # each region has its XGBoost container
my_region = boto3.session.Session().region_name # set the region of the instance
print("Success - the MySageMakerInstance is in the " + my_region + " region. You will use the " + containers[my_region] + " container for your SageMaker endpoint.")
build-train-deploy-machine-learning-model-sagemaker-3c-1
build-train-deploy-machine-learning-model-sagemaker-3c-1

(clique para aumentar)

build-train-deploy-machine-learning-model-sagemaker-3c-2

(clique para aumentar)

build-train-deploy-machine-learning-model-sagemaker-3c-2

3d. Nesta etapa, você cria um bucket do S3 que armazenará dados para este tutorial.

Copie o seguinte código na próxima célula de código no bloco de anotações e altere o nome do bucket do S3 para torná-lo único. Os nomes de bucket do S3 devem ser globalmente únicos e ter algumas outras restrições e limitações.

Selecione Run (Executar). Se você não receber uma mensagem de êxito, altere o nome do bucket e tente novamente.

 

bucket_name = 'your-s3-bucket-name' # <--- CHANGE THIS VARIABLE TO A UNIQUE NAME FOR YOUR BUCKET
s3 = boto3.resource('s3')
try:
    if  my_region == 'us-east-1':
      s3.create_bucket(Bucket=bucket_name)
    else: 
      s3.create_bucket(Bucket=bucket_name, CreateBucketConfiguration={ 'LocationConstraint': my_region })
    print('S3 bucket created successfully')
except Exception as e:
    print('S3 error: ',e)
build-train-deploy-machine-learning-model-sagemaker-3d
build-train-deploy-machine-learning-model-sagemaker-3d

(clique para aumentar)


3e. Depois, faça download dos dados para a instância do Amazon SageMaker e carregue-a em um quadro de dados. Copie e execute o seguinte código:

try:
  urllib.request.urlretrieve ("https://d1.awsstatic.com/tmt/build-train-deploy-machine-learning-model-sagemaker/bank_clean.27f01fbbdf43271788427f3682996ae29ceca05d.csv", "bank_clean.csv")
  print('Success: downloaded bank_clean.csv.')
except Exception as e:
  print('Data load error: ',e)

try:
  model_data = pd.read_csv('./bank_clean.csv',index_col=0)
  print('Success: Data loaded into dataframe.')
except Exception as e:
    print('Data load error: ',e)
build-train-deploy-machine-learning-model-sagemaker-3e
build-train-deploy-machine-learning-model-sagemaker-3e

(clique para aumentar)


3f. Misturaremos os dados, que serão divididos em dados de treinamento e dados de teste.

Os dados de treinamento (70% dos clientes) serão usados durante o ciclo de treinamento de modelos. Usaremos a otimização baseada em gradiente para refinar de forma iterativa o modelo de parâmetros. A otimização baseada em gradiente é uma forma de encontrar valores de parâmetro de modelo que minimizam o erro de modelos, usando o gradiente da função de perda de modelos.

Os dados de teste (30% de clientes restantes) serão usados para avaliar a performance do modelo e medir até que ponto o modelo treinado é generalizado para dados não examinados.

Copie o seguinte código em uma nova célula de código e selecione Run (Executar) para misturar e dividir os dados:

train_data, test_data = np.split(model_data.sample(frac=1, random_state=1729), [int(0.7 * len(model_data))])
print(train_data.shape, test_data.shape)
build-train-deploy-machine-learning-model-sagemaker-3f
build-train-deploy-machine-learning-model-sagemaker-3f

(clique para aumentar)


Etapa 4. Treine o modelo a partir dos dados

Nesta etapa, você treinará o modelo de machine learning com o conjunto de dados de treinamento. 


4a. Para usar um modelo XGBoost do Amazon SageMaker pré-criado, você precisará reformatar o cabeçalho e a primeira coluna dos dados de treinamento e carregar os dados do bucket do S3.

Copie o seguinte código em uma nova célula de código e selecione Run (Executar) para reformatar e carregar os dados:

pd.concat([train_data['y_yes'], train_data.drop(['y_no', 'y_yes'], axis=1)], axis=1).to_csv('train.csv', index=False, header=False)
boto3.Session().resource('s3').Bucket(bucket_name).Object(os.path.join(prefix, 'train/train.csv')).upload_file('train.csv')
s3_input_train = sagemaker.s3_input(s3_data='s3://{}/{}/train'.format(bucket_name, prefix), content_type='csv')

4b. Em seguida, você precisa configurar a sessão do Amazon SageMaker, criar uma instância do modelo XGBoost (um estimador) e definir hiperparâmetros do modelo. Copie o seguinte código em uma nova célula de código e selecione Run (Executar):

sess = sagemaker.Session()
xgb = sagemaker.estimator.Estimator(containers[my_region],role, train_instance_count=1, train_instance_type='ml.m4.xlarge',output_path='s3://{}/{}/output'.format(bucket_name, prefix),sagemaker_session=sess)
xgb.set_hyperparameters(max_depth=5,eta=0.2,gamma=4,min_child_weight=6,subsample=0.8,silent=0,objective='binary:logistic',num_round=100)

4c. Com os dados carregados e o estimador XGBoost configurado, treine o modelo usando a otimização de gradiente em uma instância ml.m4.xlarge, copiando o código a seguir na próxima célula de código e selecionando Run (Executar).

Após alguns minutos, você deve começar a ver os logs de treinamento sendo gerados.

xgb.fit({'train': s3_input_train})
build-train-deploy-machine-learning-model-sagemaker-4c
build-train-deploy-machine-learning-model-sagemaker-4c

(clique para aumentar)


Etapa 5. Implante o modelo

Nesta etapa, você implantará o modelo treinado em um endpoint, reformatará, carregará os dados CSV e executará o modelo para criar previsões.


5a. Para implantar o modelo em um servidor e criar um endpoint que você possa acessar, copie o seguinte código na próxima célula de código e selecione Run (Executar):

xgb_predictor = xgb.deploy(initial_instance_count=1,instance_type='ml.m4.xlarge')
build-train-deploy-machine-learning-model-sagemaker-5a
build-train-deploy-machine-learning-model-sagemaker-5a

(clique para aumentar)


5b. Para prever se clientes nos dados de teste se inscreveram ou não para produto bancário, copie o seguinte código na próxima célula de código e selecione Run (Executar):

test_data_array = test_data.drop(['y_no', 'y_yes'], axis=1).values #load the data into an array
xgb_predictor.content_type = 'text/csv' # set the data type for an inference
xgb_predictor.serializer = csv_serializer # set the serializer type
predictions = xgb_predictor.predict(test_data_array).decode('utf-8') # predict!
predictions_array = np.fromstring(predictions[1:], sep=',') # and turn the prediction into an array
print(predictions_array.shape)
build-train-deploy-machine-learning-model-sagemaker-5b
build-train-deploy-machine-learning-model-sagemaker-5b

(clique para aumentar)


Etapa 6. Avalie a performance do modelo

Nesta etapa, você avaliará a performance e a precisão do modelo de machine learning.


6a. Copie e cole o código a seguir e selecione Run (Executar) para comparar valores reais vs. previstos em uma tabela chamada confusion matrix (matriz de confusão).

Com base na previsão, você pode concluir que previu que um cliente se inscreverá para um certificado de depósito com precisão para 90% dos clientes nos dados de teste, com uma precisão de 65% (278/429) para inscritos e 90% (10,785/11,928) para não inscritos.

cm = pd.crosstab(index=test_data['y_yes'], columns=np.round(predictions_array), rownames=['Observed'], colnames=['Predicted'])
tn = cm.iloc[0,0]; fn = cm.iloc[1,0]; tp = cm.iloc[1,1]; fp = cm.iloc[0,1]; p = (tp+tn)/(tp+tn+fp+fn)*100
print("\n{0:<20}{1:<4.1f}%\n".format("Overall Classification Rate: ", p))
print("{0:<15}{1:<15}{2:>8}".format("Predicted", "No Purchase", "Purchase"))
print("Observed")
print("{0:<15}{1:<2.0f}% ({2:<}){3:>6.0f}% ({4:<})".format("No Purchase", tn/(tn+fn)*100,tn, fp/(tp+fp)*100, fp))
print("{0:<16}{1:<1.0f}% ({2:<}){3:>7.0f}% ({4:<}) \n".format("Purchase", fn/(tn+fn)*100,fn, tp/(tp+fp)*100, tp))
build-train-deploy-machine-learning-model-sagemaker-6a
build-train-deploy-machine-learning-model-sagemaker-6a

(clique para aumentar)


Etapa 7. Encerre seus recursos

Nesta etapa, você encerrará recursos relacionados ao Amazon SageMaker.

Importante: é recomendável encerrar os recursos que não estão em uso, pois isso reduz custos. Poderá haver cobranças caso os recursos não sejam encerrados.


7a. Para excluir o endpoint do Amazon SageMaker e os objetos no bucket do S3, copie, cole e Run (Executar) o seguinte código:  

sagemaker.Session().delete_endpoint(xgb_predictor.endpoint)
bucket_to_delete = boto3.resource('s3').Bucket(bucket_name)
bucket_to_delete.objects.all().delete()
build-train-deploy-machine-learning-model-sagemaker-7a
build-train-deploy-machine-learning-model-sagemaker-7a

(clique para aumentar)


Parabéns!

Você aprendeu como usar o Amazon SageMaker para preparar, treinar, implantar e avaliar um modelo de machine learning. O Amazon SageMaker facilita a criação de modelos de ML, fornecendo tudo de que você precisa para se conectar com rapidez aos dados de treinamento e selecionar o melhor algoritmo e estrutura para o seu aplicativo, gerenciando toda a infraestrutura subjacente para poder treinar modelos em escala de petabytes.


 

Saiba mais

O Amazon SageMaker vem com algoritmos de machine learning pré-criados que podem ser usados para vários casos de uso. Saiba mais sobre o uso de algoritmos incorporados que acompanham o Amazon SageMaker. 

Aprofundamento

Você pode usar o Machine Learning com o Ajuste automático de modelos no Amazon SageMaker. Isso permite ajustar automaticamente hiperparâmetros nos seus modelos para atingir o melhor resultado possível. Verifique a documentação do Ajuste automático de modelos e esta publicação no blog para se aprofundar nesta capacidade. 

Veja em ação

O Amazon SageMaker tem vários blocos de anotações de amostra disponíveis que atendem muitos casos de uso comuns para o machine learning. Verifique-os no GitHub!


Este tutorial foi útil para você?