Addestra e distribuisci un modello ML personalizzato supportato da GPU su Amazon SageMaker - Prontuario AWS
RiepilogoPrerequisiti e limitazioniArchitetturaStrumentiEpicheRisorse correlateInformazioni aggiuntive

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Addestra e distribuisci un modello ML personalizzato supportato da GPU su Amazon SageMaker

Ambiente: PoC o pilota

Tecnologie: apprendimento automatico e intelligenza artificiale; contenitori e microservizi

Servizi AWS: Amazon ECS; Amazon SageMaker

Riepilogo

L'addestramento e la distribuzione di un modello di machine learning (ML) supportato da unità di elaborazione grafica (GPU) richiedono una configurazione iniziale e l'inizializzazione di determinate variabili di ambiente per sfruttare appieno i vantaggi delle GPU NVIDIA. Tuttavia, configurare l'ambiente e renderlo compatibile con l' SageMaker architettura Amazon sul cloud Amazon Web Services (AWS) può richiedere molto tempo.

Questo modello ti aiuta ad addestrare e creare un modello ML personalizzato supportato da GPU utilizzando Amazon. SageMaker Fornisce i passaggi per addestrare e implementare un CatBoost modello personalizzato basato su un set di dati di Amazon Reviews open source. Puoi quindi analizzarne le prestazioni su un'istanza p3.16xlarge Amazon Elastic Compute Cloud (Amazon EC2).

Questo modello è utile se la tua organizzazione desidera implementare modelli ML esistenti supportati da GPU su. SageMaker I data scientist possono seguire i passaggi di questo schema per creare contenitori supportati da GPU NVIDIA e implementare modelli ML su tali contenitori.

Prerequisiti e limitazioni

Prerequisiti

  • Un account AWS attivo.

  • Un bucket sorgente Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3) per archiviare gli artefatti e le previsioni del modello.

  • Comprensione delle istanze dei notebook e dei SageMaker notebook Jupyter.

  • Una comprensione di come creare un ruolo AWS Identity and Access Management (IAM) con autorizzazioni di SageMaker ruolo di base, autorizzazioni di accesso e aggiornamento ai bucket S3 e autorizzazioni aggiuntive per Amazon Elastic Container Registry (Amazon ECR).

Limitazioni

  • Questo modello è destinato ai carichi di lavoro ML supervisionati con un codice di addestramento e distribuzione scritto in Python.

Architettura

Stack tecnologico

  • SageMaker

  • Amazon ECR

Strumenti

Strumenti

  • Amazon ECR — Amazon Elastic Container Registry (Amazon ECR) è un servizio di registro di immagini di container gestito da AWS sicuro, scalabile e affidabile.

  • Amazon SageMaker: SageMaker è un servizio di machine learning completamente gestito.

  • Docker: Docker è una piattaforma software per la creazione, il test e la distribuzione rapida di applicazioni.

  • Python — Python è un linguaggio di programmazione.

Codice

Il codice per questo modello è disponibile in GitHub Implementazione di un modello di classificazione delle recensioni con Catboost e repository. SageMaker

Epiche

AttivitàDescrizioneCompetenze richieste
Crea un ruolo IAM e allega le policy richieste.

Accedi alla Console di gestione AWS, apri la console IAM e crea un nuovo ruolo IAM. Collega al ruolo IAM le policy seguenti: 

  • AmazonEC2ContainerRegistryFullAccess

  • AmazonS3FullAccess

  • AmazonSageMakerFullAccess

Per ulteriori informazioni su questo argomento, consulta Creare un'istanza notebook nella SageMaker documentazione di Amazon.

Data scientist
Crea l'istanza del SageMaker notebook.

Apri la SageMaker console, scegli Istanze Notebook, quindi scegli Crea istanza Notebook. Per il ruolo IAM, scegli il ruolo IAM che hai creato in precedenza. Configura l'istanza del notebook in base ai tuoi requisiti, quindi scegli Crea istanza notebook.

Per passaggi e istruzioni dettagliati, consulta Creare un'istanza notebook nella SageMaker documentazione di Amazon.

Data scientist
Clonare il repository.

Apri il terminale nell'istanza del SageMaker notebook e clona il modello di classificazione GitHub Implementing a review con Catboost e SageMaker repository eseguendo il seguente comando:

git clone https://github.com/aws-samples/review-classification-using-catboost-sagemaker.git
Avvia il notebook Jupyter.

Avvia il notebook Review classification model with Catboost and SageMaker.ipynb Jupyter, che contiene i passaggi predefiniti.

Data scientist
AttivitàDescrizioneCompetenze richieste
Esegui i comandi nel notebook Jupyter.

Apri il notebook Jupyter ed esegui i comandi delle seguenti storie per preparare i dati per addestrare il tuo modello ML.

Data scientist
Leggi i dati dal bucket 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)
Data scientist
Preelabora i dati.
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)

Nota: questo codice sostituisce i valori nulli in 'review_body' con una stringa vuota e sostituisce la 'verified_purchase' colonna con'Unk', che significa «sconosciuto».

 

Data scientist
Suddividi i dati in set di dati di addestramento, convalida e test.

Per mantenere identica la distribuzione dell'etichetta di destinazione tra i set divisi, è necessario stratificare il campionamento utilizzando la libreria 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]
Data scientist
AttivitàDescrizioneCompetenze richieste
Prepara e invia l'immagine Docker.

Nel notebook Jupyter, esegui i comandi descritti nelle seguenti storie per preparare l'immagine Docker e inviarla ad Amazon ECR.

Ingegnere ML
Crea un repository in 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
Ingegnere ML
Crea un'immagine Docker localmente.
docker build -t "${algorithm_name}" .
docker tag ${algorithm_name} ${fullname}
Ingegnere ML
Esegui l'immagine Docker e inviala ad Amazon ECR.
docker push ${fullname}
Ingegnere ML
AttivitàDescrizioneCompetenze richieste
Crea un lavoro di ottimizzazione degli SageMaker iperparametri.

Nel notebook Jupyter, esegui i comandi descritti nelle seguenti storie per creare un processo di ottimizzazione degli SageMaker iperparametri utilizzando la tua immagine Docker.

Data scientist
Crea uno stimatore. SageMaker

Crea uno SageMaker stimatore utilizzando il nome dell'immagine 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)
Data scientist
Crea un lavoro HPO.

Crea un processo di ottimizzazione degli iperparametri (HPO) con intervalli di parametri e passa il treno e i set di convalida come parametri alla funzione.

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)
Data scientist
Esegui il job 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      })
Data scientist
Ricevi il lavoro di formazione con le migliori prestazioni.
import sagemaker as sage
from time import gmtime, strftime
sess = sage.Session()

best_job =tuner.best_training_job()
Data scientist
AttivitàDescrizioneCompetenze richieste
Crea un SageMaker processo di trasformazione in batch sui dati di test per la previsione dei modelli.

Nel notebook Jupyter, esegui i comandi descritti nelle seguenti storie per creare il modello in base al processo di ottimizzazione degli SageMaker iperparametri e invia un processo di trasformazione in SageMaker batch sui dati di test per la previsione del modello.

Data scientist
Create il modello. SageMaker

Crea un modello in SageMaker modello utilizzando il miglior lavoro di formazione.

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' })
Data scientist
Crea un processo di trasformazione in batch.

Crea un processo di trasformazione in batch sul set di dati di test.

transformer.transform(input_path, 
                      content_type='text/csv',
                      split_type='Line')
Data scientist
AttivitàDescrizioneCompetenze richieste
Leggi i risultati e valuta le prestazioni del modello.

Nel notebook Jupyter, esegui i comandi delle seguenti storie per leggere i risultati e valutare le prestazioni del modello in base alle metriche dei modelli Area Under the ROC Curve (ROC-AUC) e Area Under the Precision Recall Curve (PR-AUC).

Per ulteriori informazioni su questo argomento, consulta i concetti chiave di Amazon Machine Learning nella documentazione di Amazon Machine Learning (Amazon ML).

Data scientist
Leggi i risultati del processo di trasformazione in batch.

Leggi i risultati del processo di trasformazione in batch in un frame di dati.

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()
Data scientist
Valuta le metriche delle prestazioni.

Valuta le prestazioni del modello su ROC-AUC e 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)
Data scientist

Informazioni aggiuntive

L'elenco seguente mostra i diversi elementi del Dockerfile che vengono eseguiti nell'immagine Build, run e push dell'immagine Docker in Amazon ECR epic.

Installa Python con 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

Installa i pacchetti 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

Installa 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/*

Crea la struttura di directory richiesta per 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

Imposta le variabili di 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"

Copia i file di addestramento e inferenza nell'immagine Docker

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