Treine e implante um modelo de ML personalizado compatível com GPU na Amazon SageMaker - Recomendações da AWS
ResumoPré-requisitos e limitaçõesArquiteturaFerramentasÉpicosRecursos relacionadosMais informações

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Treine e implante um modelo de ML personalizado compatível com GPU na Amazon SageMaker

Ambiente: PoC ou piloto

Tecnologias: machine learning e IA; contêineres e microsserviços

Serviços da AWS: Amazon ECS; Amazon SageMaker

Resumo

Treinar e implantar um modelo de machine learning (ML) compatível com unidade de processamento gráfico (GPU) requer uma configuração e inicialização iniciais de determinadas variáveis de ambiente para liberar totalmente os benefícios das GPUs NVIDIA. No entanto, pode ser demorado configurar o ambiente e torná-lo compatível com a SageMaker arquitetura da Amazon na nuvem da Amazon Web Services (AWS).

Esse padrão ajuda você a treinar e criar um modelo de ML personalizado compatível com GPU usando a Amazon. SageMaker Ele fornece etapas para treinar e implantar um CatBoost modelo personalizado construído em um conjunto de dados de avaliações de código aberto da Amazon. Em seguida, é possível comparar o desempenho em uma instância p3.16xlarge do Amazon Elastic Compute Cloud (Amazon EC2).

Esse padrão é útil se sua organização quiser implantar modelos de ML existentes compatíveis com GPU no. SageMaker Seus cientistas de dados podem seguir as etapas desse padrão para criar contêineres compatíveis com GPU NVIDIA e implantar modelos de ML nesses contêineres.

Pré-requisitos e limitações

Pré-requisitos

  • Uma conta AWS ativa

  • Um bucket de origem do Amazon Simple Storage Service (Amazon S3) para armazenar os artefatos e as previsões do modelo.

  • Uma compreensão das instâncias de SageMaker notebooks e notebooks Jupyter.

  • Uma compreensão de como criar uma função do AWS Identity and Access Management (IAM) com permissões básicas de SageMaker função, permissões de acesso e atualização do bucket S3 e permissões adicionais para o Amazon Elastic Container Registry (Amazon ECR).

Limitações

  • Esse padrão é destinado a workloads de ML supervisionadas com código train-and-deploy no Python.

Arquitetura

Pilha de tecnologia

  • SageMaker

  • Amazon ECR

Ferramentas

Ferramentas

  • Amazon ECR: o Amazon Elastic Container Registry (Amazon ECR) é um serviço gerenciado de registro de imagem de contêiner, seguro, escalável e confiável.

  • Amazon SageMaker — SageMaker é um serviço de ML totalmente gerenciado.

  • Docker: o Docker é uma plataforma de software para criar, testar e implantar aplicativos rapidamente.

  • Python: Python é uma linguagem de programação.

Código

O código desse padrão está disponível em GitHub Implementação de um modelo de classificação de revisão com Catboost e SageMaker repositório.

Épicos

TarefaDescriçãoHabilidades necessárias
Criar um perfil do IAM e anexar as políticas necessárias.

Faça login no Console de Gerenciamento da AWS, abra o console do IAM e crie um novo perfil do IAM. Anexe as políticas a seguir ao perfil do IAM: 

  • AmazonEC2ContainerRegistryFullAccess

  • AmazonS3FullAccess

  • AmazonSageMakerFullAccess

Para obter mais informações sobre isso, consulte Criar uma instância de notebook na SageMaker documentação da Amazon.

Cientista de dados
Crie a instância do SageMaker notebook.

Abra o SageMaker console, escolha Instâncias do Notebook e, em seguida, escolha Criar instância do notebook. Em Perfil do IAM, selecione o perfil do IAM que você criou anteriormente. Configure a instância do bloco de anotações de acordo com seus requisitos e escolha Criar instância do bloco de anotações.

Para etapas e instruções detalhadas, consulte Criar uma instância de notebook na SageMaker documentação da Amazon.

Cientista de dados
Clonar o repositório.

Abra o terminal na instância do SageMaker notebook e clone a GitHub Implementação de um modelo de classificação de revisão com Catboost e SageMaker repositório executando o seguinte comando:

git clone https://github.com/aws-samples/review-classification-using-catboost-sagemaker.git
Inicie o servidor de caderno Jupyter.

Inicie Review classification model with Catboost and SageMaker.ipynb do caderno Jupyter, que contém as etapas predefinidas.

Cientista de dados
TarefaDescriçãoHabilidades necessárias
Execute comandos no caderno Jupyter.

Abra o caderno Jupyter e execute os comandos dos históricos a seguir para preparar os dados para treinar seu modelo de ML.

Cientista de dados
Ler os dados do bucket do S3.
import pandas as pd
import csv
fname = 's3://amazon-reviews-pds/tsv/amazon_reviews_us_Digital_Video_Download_v1_00.tsv.gz'
df = pd.read_csv(fname,sep='\t',delimiter='\t',error_bad_lines=False)
Cientista de dados
Pré-processar os dados.
import numpy as np 
def pre_process(df):    
   df.fillna(value={'review_body': '', 'review_headline': ''}, inplace=True)    
  df.fillna( value={'verified_purchase': 'Unk'}, inplace=True)  
  df.fillna(0, inplace=True)   
 return df 
df = pre_process(df) 
df.review_date = pd.to_datetime(df.review_date) 
df['target'] = np.where(df['star_rating']>=4,1,0)

Observação: esse código substitui valores nulos no 'review_body' por uma string vazia e substitui a coluna 'verified_purchase' por 'Unk', que significa “desconhecido”.

 

Cientista de dados
Dividir os dados em conjuntos de dados de treinamento, validação e teste.

Para manter a distribuição da label de destino idêntica nos conjuntos divididos, você deve estratificar a amostragem usando a biblioteca scikit-learn.

from sklearn.model_selection import StratifiedShuffleSplit
sss = StratifiedShuffleSplit(n_splits=2, test_size=0.10, random_state=0)
sss.get_n_splits(df, df['target'])
for train_index, test_index in sss.split(df, df['target']):
    X_train_vallid , X_test = df.iloc[train_index], df.iloc[test_index]
    
    
sss.get_n_splits(X_train_vallid, X_train_vallid['target'])    
for train_index, test_index in sss.split(X_train_vallid, X_train_vallid['target']):
    X_train , X_valid = X_train_vallid.iloc[train_index], X_train_vallid.iloc[test_index]
Cientista de dados
TarefaDescriçãoHabilidades necessárias
Preparar e enviar para a imagem do Docker.

No caderno Jupyter, execute os comandos dos históricos a seguir para preparar a imagem do Docker e enviá-la para o Amazon ECR.

Engenheiro de ML
Crie um repositório do Amazon ECR.
%%sh 

algorithm_name=sagemaker-catboost-github-gpu-img

chmod +x code/train
chmod +x code/serve

account=$(aws sts get-caller-identity --query Account --output text)

# Get the region defined in the current configuration (default to us-west-2 if none defined)
region=$(aws configure get region)
region=${region:-us-east-1}

fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"

aws ecr create-repository --repository-name "${algorithm_name}" > /dev/nul
Engenheiro de ML
Criar uma imagem do Docker localmente.
docker build -t "${algorithm_name}" .
docker tag ${algorithm_name} ${fullname}
Engenheiro de ML
Executar a imagem do Docker e enviá-la para o Amazon ECR.
docker push ${fullname}
Engenheiro de ML
TarefaDescriçãoHabilidades necessárias
Crie um trabalho de ajuste de SageMaker hiperparâmetros.

No notebook Jupyter, execute os comandos das histórias a seguir para criar um trabalho de ajuste de SageMaker hiperparâmetros usando sua imagem do Docker.

Cientista de dados
Crie um SageMaker estimador.

Crie um SageMaker estimador usando o nome da imagem do Docker.

import sagemaker as sage
from time import gmtime, strftime
sess = sage.Session()
from sagemaker.tuner import IntegerParameter, CategoricalParameter, ContinuousParameter, HyperparameterTuner

account = sess.boto_session.client('sts').get_caller_identity()['Account']
region = sess.boto_session.region_name
image = '{}.dkr.ecr.{}.amazonaws.com/sagemaker-catboost-github-gpu-img:latest'.format(account, region)
tree_hpo = sage.estimator.Estimator(image,
                       role, 1, 
                      'ml.p3.16xlarge',
                       train_volume_size = 100,
                       output_path="s3://{}/sagemaker/DEMO-GPU-Catboost/output".format(bucket),
                       sagemaker_session=sess)
Cientista de dados
Criar um trabalho do HPO.

Crie um trabalho de ajuste de otimização de hiperparâmetros (HPO) com intervalos de parâmetros e transmita os conjuntos de treinamento e validação como parâmetros para a função.

hyperparameter_ranges = {'iterations': IntegerParameter(80000, 130000),
                         'max_depth': IntegerParameter(6, 10),  
                         'max_ctr_complexity': IntegerParameter(4, 10),
                         'learning_rate': ContinuousParameter(0.01, 0.5)}

objective_metric_name = 'auc'
metric_definitions = [{'Name': 'auc',
                       'Regex': 'auc: ([0-9\\.]+)'}]

tuner = HyperparameterTuner(tree_hpo,
                            objective_metric_name,
                            hyperparameter_ranges,
                            metric_definitions,
                            objective_type='Maximize',
                            max_jobs=50,
                            max_parallel_jobs=2)
Cientista de dados
Executar o trabalho do HPO.
train_location = 's3://'+bucket+'/sagemaker/DEMO-GPU-Catboost/data/train/'
valid_location = 's3://'+bucket+'/sagemaker/DEMO-GPU-Catboost/data/valid/'

tuner.fit({'train': train_location,
           'validation': valid_location      })
Cientista de dados
Receber o trabalho de treinamento com melhor desempenho.
import sagemaker as sage
from time import gmtime, strftime
sess = sage.Session()

best_job =tuner.best_training_job()
Cientista de dados
TarefaDescriçãoHabilidades necessárias
Crie um trabalho SageMaker de transformação em lote nos dados de teste para previsão do modelo.

No notebook Jupyter, execute os comandos das histórias a seguir para criar o modelo a partir do seu trabalho de ajuste de SageMaker hiperparâmetros e enviar um trabalho de transformação em SageMaker lote nos dados de teste para previsão do modelo.

Cientista de dados
Crie o SageMaker modelo.

Crie um modelo em SageMaker modelo usando o melhor trabalho de treinamento.

attached_estimator = sage.estimator.Estimator.attach(best_job)

output_path ='s3://'+bucket+'/sagemaker/DEMO-GPU-Catboost/data/test-predictions/'
input_path  ='s3://'+bucket+'/sagemaker/DEMO-GPU-Catboost/data/test/'

transformer = attached_estimator.transformer(instance_count=1, 
                                             instance_type='ml.p3.16xlarge', 
                                             assemble_with='Line', 
                                             accept='text/csv',
                                             max_payload=1,
                                             output_path=output_path,
                                             env = {'SAGEMAKER_MODEL_SERVER_TIMEOUT' : '3600' })
Cientista de dados
Criar trabalho de transformação em lote.

Crie um trabalho de transformação em lote no conjunto de dados de teste.

transformer.transform(input_path, 
                      content_type='text/csv',
                      split_type='Line')
Cientista de dados
TarefaDescriçãoHabilidades necessárias
Leia os resultados e avalie o desempenho do modelo.

No caderno Jupyter, execute os comandos dos históricos a seguir para ler os resultados e avaliar o desempenho do modelo nas métricas do modelo Área abaixo da curva ROC (ROC-AUC) e Área abaixo da curva de recuperação de precisão (PR-AUC).

Para obter mais informações , consulte os Principais conceitos do Amazon Machine Learning na documentação do Amazon Machine Learning (Amazon ML).

Cientista de dados
Leia os resultados do trabalho de transformação em lote.

Leia o lote e transforme os resultados do trabalho em um quadro de dados.

file_name = 's3://'+bucket+'/sagemaker/DEMO-GPU-Catboost/data/test-predictions/file_1.out'

results = pd.read_csv(file_name, names=['review_id','target','score'] ,sep='\t',escapechar ='\\' , quoting=csv.QUOTE_NONE, 
                   lineterminator='\n',quotechar='"').dropna()
Cientista de dados
Avaliar as métricas de performance.

Avalie o desempenho do modelo no ROC-AUC e no PR-AUC.

from sklearn import  metrics
import matplotlib
import pandas as pd
matplotlib.use('agg', warn=False, force=True)
from matplotlib import pyplot as plt

%matplotlib inline 

def analyze_results(labels, predictions):
    precision, recall, thresholds = metrics.precision_recall_curve(labels, predictions)
    auc = metrics.auc(recall, precision)
    
    fpr, tpr, _ = metrics.roc_curve(labels, predictions)
    roc_auc_score = metrics.roc_auc_score(labels, predictions)
    
    print('Neural-Nets: ROC auc=%.3f' % ( roc_auc_score))
    
    plt.plot(fpr, tpr, label="data 1, auc=" + str(roc_auc_score))
    plt.xlabel('1-Specificity')
    plt.ylabel('Sensitivity')
    plt.legend(loc=4)
    plt.show()
    
    
    lr_precision, lr_recall, _ = metrics.precision_recall_curve(labels, predictions)
    lr_auc = metrics.auc(lr_recall, lr_precision)
    # summarize scores
    print('Neural-Nets: PR auc=%.3f' % ( lr_auc))
    # plot the precision-recall curves
    no_skill = len(labels[labels==1.0]) / len(labels)
    plt.plot([0, 1], [no_skill, no_skill], linestyle='--', label='No Skill')
    
    plt.plot(lr_recall, lr_precision, marker='.', label='Neural-Nets')
    # axis labels
    plt.xlabel('Recall')
    plt.ylabel('Precision')
    # show the legend
    plt.legend()
    # show the plot
    plt.show()
    
    
    return auc

analyze_results(results['target'].values,results['score'].values)
Cientista de dados

Mais informações

A lista a seguir mostra os diferentes elementos do Dockerfile que são executados no epic Criar, executar e enviar a imagem do Docker para o Amazon ECR.

Instale o Python com aws-cli.

FROM amazonlinux:1
 
 RUN yum update -y && yum install -y python36 python36-devel python36-libs python36-tools python36-pip && \
 yum install gcc tar make wget util-linux kmod man sudo git -y && \
 yum install wget -y && \
 yum install aws-cli -y && \
 yum install nginx -y && \
yum install gcc-c++.noarch -y && yum clean all

Instale os pacotes do Python

RUN pip-3.6 install --no-cache-dir --upgrade pip && \pip3 install --no-cache-dir --upgrade setuptools && \
pip3 install Cython && \
pip3 install --no-cache-dir numpy==1.16.0 scipy==1.4.1 scikit-learn==0.20.3 pandas==0.24.2 \
flask gevent gunicorn boto3 s3fs  matplotlib joblib catboost==0.20.2

Instale CUDA e CuDNN

RUN wget https://developer.nvidia.com/compute/cuda/9.0/Prod/local_installers/cuda_9.0.176_384.81_linux-run \
&& chmod u+x cuda_9.0.176_384.81_linux-run \
&& ./cuda_9.0.176_384.81_linux-run --tmpdir=/data --silent --toolkit --override \
&& wget https://custom-gpu-sagemaker-image.s3.amazonaws.com/installation/cudnn-9.0-linux-x64-v7.tgz \
&& tar -xvzf cudnn-9.0-linux-x64-v7.tgz \
&& cp /data/cuda/include/cudnn.h /usr/local/cuda/include \
&& cp /data/cuda/lib64/libcudnn* /usr/local/cuda/lib64 \

&& chmod a+r /usr/local/cuda/include/cudnn.h /usr/local/cuda/lib64/libcudnn* \
&&  rm -rf /data/*

Crie a estrutura de diretórios necessária para SageMaker

RUN mkdir /opt/ml /opt/ml/input /opt/ml/input/config /opt/ml/input/data /opt/ml/input/data/training /opt/ml/model /opt/ml/output /opt/program

Defina as variáveis de ambiente NVIDIA

ENV PYTHONPATH=/opt/program
ENV PYTHONUNBUFFERED=TRUE
ENV PYTHONDONTWRITEBYTECODE=TRUE
ENV PATH="/opt/program:${PATH}"

# Set NVIDIA mount environments
ENV LD_LIBRARY_PATH=/usr/local/nvidia/lib:/usr/local/nvidia/lib64:$LD_LIBRARY_PATH
ENV NVIDIA_VISIBLE_DEVICES="all"
ENV NVIDIA_DRIVER_CAPABILITIES="compute,utility"
ENV NVIDIA_REQUIRE_CUDA "cuda>=9.0"

Copie arquivos de treinamento e inferência na imagem do Docker 

COPY code/* /opt/program/
WORKDIR /opt/program