Entrena e implementa un modelo de aprendizaje automático personalizado compatible con GPU en Amazon SageMaker - Recomendaciones de AWS
ResumenRequisitos previos y limitacionesArquitecturaHerramientasEpicsRecursos relacionadosInformación adicional

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Entrena e implementa un modelo de aprendizaje automático personalizado compatible con GPU en Amazon SageMaker

Creado por Ankur Shukla (AWS)

Entorno: PoC o piloto

Tecnologías: machine learning e IA; contenedores y microservicios

Servicios de AWS: Amazon ECS; Amazon SageMaker

Resumen

El entrenamiento y la implementación de un modelo de machine learning (ML) compatible con unidades de procesamiento de gráficos (GPU) requieren de la configuración e inicialización de determinadas variables de entorno para aprovechar al máximo las ventajas de las GPU NVIDIA. Sin embargo, configurar el entorno y hacerlo compatible con la SageMaker arquitectura de Amazon en la nube de Amazon Web Services (AWS) puede llevar mucho tiempo.

Este patrón te ayuda a entrenar y crear un modelo de aprendizaje automático personalizado compatible con GPU mediante Amazon. SageMaker Proporciona los pasos para entrenar e implementar un CatBoost modelo personalizado basado en un conjunto de datos de Amazon reviews de código abierto. Podrá comparar su rendimiento en una instancia p3.16xlarge de Amazon Elastic Compute Cloud (Amazon EC2).

Este patrón es útil si tu organización quiere implementar modelos de aprendizaje automático compatibles con la GPU existentes en él. SageMaker Sus científicos de datos pueden seguir los pasos de este patrón para crear contenedores compatibles con las GPU de NVIDIA e implementar modelos de ML en dichos contenedores.

Requisitos previos y limitaciones

Requisitos previos

  • Una cuenta de AWS activa.

  • Un bucket de origen de Amazon Simple Storage Service (Amazon S3) para almacenar artefactos y predicciones del modelo.

  • Conocimiento de las instancias de cuadernos y de los SageMaker cuadernos de Jupyter.

  • Comprensión de cómo crear un rol de AWS Identity and Access Management (IAM) con permisos de SageMaker rol básicos, permisos de acceso y actualización al bucket de S3 y permisos adicionales para Amazon Elastic Container Registry (Amazon ECR).

Limitaciones

  • Este patrón está diseñado para cargas de trabajo de aprendizaje supervisadas con código de entrenamiento e implementación en Python.

Arquitectura

Flujo de trabajo para entrenar y crear un modelo de aprendizaje automático personalizado compatible con la GPU utilizando. SageMaker

Pila de tecnología

  • SageMaker

  • Amazon ECR

Herramientas

Herramientas

  • Amazon ECR: Amazon Elastic Container Registry (Amazon ECR) es un servicio de registro de imágenes de contenedor administrado por AWS que es seguro, escalable y fiable.

  • Amazon SageMaker: SageMaker es un servicio de aprendizaje automático totalmente gestionado.

  • Docker: Docker es una plataforma de software para crear, probar e implementar aplicaciones rápidamente.

  • Python: es un lenguaje de programación.

Código

El código de este patrón está disponible en el repositorio GitHub Implementación de un modelo de clasificación de reseñas con Catboost y el SageMaker repositorio.

Epics

TareaDescripciónHabilidades requeridas

Cree un rol de IAM y adjunte las políticas necesarias.

Inicie sesión en la consola de administración de AWS, abra la consola de IAM y cree el rol de IAM. Adjunte las políticas siguientes al rol de IAM: 

  • AmazonEC2ContainerRegistryFullAccess

  • AmazonS3FullAccess

  • AmazonSageMakerFullAccess

Para obtener más información al respecto, consulta Crear una instancia de bloc de notas en la SageMaker documentación de Amazon.

Científico de datos

Cree la instancia de SageMaker bloc de notas.

Abre la SageMaker consola, selecciona Instancias de Notebook y, a continuación, selecciona Crear instancia de Notebook. En Rol de IAM, seleccione el rol de IAM que creó anteriormente. Configure la instancia de cuaderno según sus necesidades y seleccione Crear instancia de cuaderno.

Para obtener instrucciones y pasos detallados, consulta Crear una instancia de bloc de notas en la SageMaker documentación de Amazon.

Científico de datos

Clonar el repositorio.

Abre el terminal en la instancia del SageMaker portátil y clona el SageMaker repositorio GitHub Implementación de un modelo de clasificación de reseñas con Catboost y ejecuta el siguiente comando:

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

Inicio del servidor de cuaderno de Jupyter.

Inicie el cuaderno de Jupyter Review classification model with Catboost and SageMaker.ipynb, que contiene los pasos predefinidos.

Científico de datos
TareaDescripciónHabilidades requeridas

Ejecute comandos en el cuaderno de Jupyter.

Abra el cuaderno de Jupyter y ejecute los comandos de las siguientes historias para preparar los datos que entrenarán a su modelo de ML.

Científico de datos

Lea los datos del bucket de 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)
Científico de datos

Preprocese los datos.

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: Este código reemplaza los valores nulos de 'review_body' por una cadena vacía, y reemplaza la columna 'verified_purchase' por 'Unk', que significa “desconocido”.

 

Científico de datos

Divida los datos en conjuntos de datos de entrenamiento, validación y prueba.

Para mantener la distribución de la etiqueta de destino idéntica en los conjuntos divididos, debe estratificar el muestreo mediante la 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]
Científico de datos
TareaDescripciónHabilidades requeridas

Cree y envíe imágenes de Docker.

En el cuaderno de Jupyter, ejecute los comandos de las siguientes historias para preparar la imagen de Docker e insertarla en Amazon ECR.

Ingeniero de ML

Cree un repositorio en 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
Ingeniero de ML

Cree una imagen de Docker de forma local.

docker build -t "${algorithm_name}" .
docker tag ${algorithm_name} ${fullname}
Ingeniero de ML

Ejecute la imagen de Docker y envíela a Amazon ECR.

docker push ${fullname}
Ingeniero de ML
TareaDescripciónHabilidades requeridas

Cree un trabajo de ajuste de SageMaker hiperparámetros.

En el cuaderno de Jupyter, ejecute los comandos de las siguientes historias para crear un trabajo de ajuste de SageMaker hiperparámetros con su imagen de Docker.

Científico de datos

Crea un estimador. SageMaker

Cree un SageMaker estimador con el nombre de la imagen de 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)
Científico de datos

Cree un trabajo de HPO.

Cree un trabajo de ajuste de optimización de hiperparámetros (HPO) con rangos de parámetros y pase el tren y los conjuntos de validación como parámetros a la función.

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)
Científico de datos

Ejecute el trabajo de 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      })
Científico de datos

Reciba el trabajo de entrenamiento de mayor rendimiento.

import sagemaker as sage
from time import gmtime, strftime
sess = sage.Session()

best_job =tuner.best_training_job()
Científico de datos
TareaDescripciónHabilidades requeridas

Cree un trabajo de transformación SageMaker por lotes en los datos de las pruebas para la predicción del modelo.

En el cuaderno de Jupyter, ejecute los comandos de las siguientes historias para crear el modelo a partir de su trabajo de ajuste de SageMaker hiperparámetros y envíe un trabajo de transformación SageMaker por lotes con los datos de la prueba para la predicción del modelo.

Científico de datos

Cree el modelo. SageMaker

Cree un modelo dentro del SageMaker modelo utilizando el mejor trabajo de entrenamiento.

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' })
Científico de datos

Crear trabajos de transformación por lotes.

Cree un trabajo de transformación por lotes en el conjunto de datos de prueba.

transformer.transform(input_path, 
                      content_type='text/csv',
                      split_type='Line')
Científico de datos
TareaDescripciónHabilidades requeridas

Lea los resultados y evalúe el rendimiento del modelo.

En el cuaderno de Jupyter, ejecute los comandos de las siguientes historias para leer los resultados y evaluar el rendimiento del modelo según las métricas del modelo Área bajo la curva ROC (ROC-AUC) y Área bajo la curva de recuperación de precisión (PR-AUC).

Para obtener más información, consulte Conceptos clave de machine learning de Amazon en la documentación de Amazon Machine Learning (Amazon ML).

Científico de datos

Lea los resultados del trabajo de transformación por lotes.

Lea los resultados del trabajo de transformación por lotes en un marco de datos.

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()
Científico de datos

Evalúe las métricas de rendimiento.

Evalúe el rendimiento del modelo en ROC-AUC y 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)
Científico de datos

Recursos relacionados

Información adicional

La siguiente lista muestra los diferentes elementos de Dockerfile que se ejecutan en la épica Compilar, ejecutar y enviar la imagen de Docker a Amazon ECR.

Instale 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

Instale los paquetes de 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 y 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/*

Cree la estructura de directorios requerida 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

Establezca las variables de entorno 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 los archivos de entrenamiento e inferencia en la imagen de Docker

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