Amazon에서 사용자 지정 GPU 지원 ML 모델을 트레이닝하고 배포하기 SageMaker

IAM 역할을 생성하고 필요한 정책을 연결합니다.

AWS Management Console에 로그인하여 IAM 콘솔을 열고 새로운 IAM 역할을 생성합니다. 다음 정책을 IAM 역할에 연결합니다. 

이에 대한 자세한 내용은 Amazon SageMaker 설명서의 노트북 인스턴스 생성을 참조하십시오.

SageMaker 노트북 인스턴스를 생성하십시오.

SageMaker 콘솔을 열고 Notebook 인스턴스를 선택한 다음 노트북 인스턴스 만들기를 선택합니다. IAM 역할에는 앞에서 생성한 IAM 역할을 선택합니다. 요구 사항에 따라 노트북 인스턴스를 구성한 다음 노트북 인스턴스 생성을 선택합니다.

자세한 단계 및 지침은 Amazon SageMaker 설명서의 노트북 인스턴스 생성을 참조하십시오.

리포지토리를 복제합니다.

SageMaker 노트북 인스턴스에서 터미널을 열고 다음 명령을 실행하여 Catboost 및 SageMaker 리포지토리로 리뷰 분류 모델 GitHub 구현을 복제합니다.

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

Jupyter Notebook을 시작합니다.

사전 정의된 단계가 포함된 Review classification model with Catboost and SageMaker.ipynb Jupyter Notebook을 시작합니다.

Jupyter Notebook에서 명령을 실행합니다.

Jupyter Notebook을 열고 다음 스토리에서 명령을 실행하여 ML 모델 학습에 필요한 데이터를 준비합니다.

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)

데이터를 전처리합니다.

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)

참고: 이 코드는 'review_body'의 null 값을 빈 문자열로 바꾸고 'verified_purchase' 열을 “알 수 없음”을 의미하는 'Unk' 문자열로 바꿉니다.

데이터를 훈련, 검증, 테스트 데이터 세트로 분할합니다.

대상 레이블의 분포를 분할된 집합에서 동일하게 유지하려면 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]

Docker 이미지를 준비하고 푸시합니다.

Jupyter Notebook에서 다음 스토리의 명령을 실행하여 Docker 이미지를 준비하고 Amazon ECR로 푸시합니다.

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

Docker 이미지를 로컬로 구축합니다.

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

Docker 이미지를 실행하고 Amazon ECR에 푸시합니다.

docker push ${fullname}

SageMaker 하이퍼파라미터 조정 작업을 생성합니다.

Jupyter 노트북에서 다음 스토리의 명령을 실행하여 Docker 이미지를 사용하여 SageMaker 하이퍼파라미터 조정 작업을 생성합니다.

추정기를 만드세요. SageMaker

Docker 이미지 이름을 사용하여 SageMaker 추정기를 생성합니다.

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)

HPO 작업을 생성합니다.

파라미터 범위를 사용하여 하이퍼파라미터 최적화(HPO) 미세 조정 작업을 생성하고 훈련 세트와 검증 세트를 파라미터로 함수에 전달합니다.

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)

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      })

가장 성과가 좋은 훈련 작업을 받습니다.

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

best_job =tuner.best_training_job()

모델 예측을 위해 테스트 데이터에 대한 SageMaker 일괄 변환 작업을 생성합니다.

Jupyter 노트북에서 다음 스토리의 명령을 실행하여 SageMaker 하이퍼파라미터 조정 작업에서 모델을 만들고 모델 예측을 위해 테스트 데이터에 대한 SageMaker 일괄 변환 작업을 제출하십시오.

모델을 생성하세요. SageMaker

최적의 교육 작업을 사용하여 SageMaker 모델 내에서 모델을 생성하십시오.

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' })

배치 변환 작업을 생성합니다.

테스트 데이터 세트에 배치 변환 작업을 생성합니다.

transformer.transform(input_path, 
                      content_type='text/csv',
                      split_type='Line')

결과를 읽고 모델의 성능을 평가합니다.

Jupyter Notebook에서 다음 스토리의 명령을 실행하여 결과를 읽고 ROC 곡선 아래 영역(ROC-AUC) 및 정밀도 재현율 곡선 아래 영역(PR-AUC) 모델 지표에서 모델의 성능을 평가합니다.

이에 대한 자세한 내용은 Amazon Machine Learning(Amazon ML) 설명서의 Amazon Machine Learning 주요 개념을 참조하세요.

배치 변환 작업 결과를 읽습니다.

배치 변환 작업 결과를 데이터 프레임으로 읽습니다.

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()

성능 지표를 평가합니다.

ROC-AUC 및 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)