Deploying a trained ML Algorithm to AWS Sagemaker

## XGBoost Model deployment in Amazon Sagemaker.

#### This notebook should be run in an Amazon Sagemaker notebook instance.

#### Before running this notebook,

# you should have uploaded the pre-trained model and test_point.csv from your laptop to the

# same folder where you have this notebook file. test_point.csv contains few sample test data in csv format.

# This loads the pre-trained XGBoost model and saves in a S3 bucket in .tar.gz format as required by Sagemaker.

# Then it creates a sagemaker model from the model file stored in S3.

# Then configures and creates an Endpoint to deploy the model and also tests invoking the endpoint to get prediction.

#### Please remember not to run the last “Delete the Endpoint” cell if you want to test the deployed model from a client.

### Import libraries

 

from time import gmtime, strftime

import os

import boto3

import sagemaker

import joblib

import xgboost

from sagemaker import get_execution_role

import numpy as np

from sagemaker.amazon.amazon_estimator import get_image_uri

import time

import json

 

region = boto3.Session().region_name

role = get_execution_role()

### Create S3 bucket

# This creates a default S3 bucket where we will upload our model.

bucket = sagemaker.Session().default_bucket()

bucket_path = “https://s3-{}.amazonaws.com/{}”.format(region, bucket)

print(role)

print(region)

print(bucket)

print(bucket_path)

#### Install xgboost as it is needed for loading the model from the joblib dump file and test it before deployment.

#### Please note that the XGBoost version should be the same as the version with which the model was trained locally in the laptop.

model_file_name = “DEMO-local-xgboost-model”

### Load the pre-trained model and test it before deployment

mymodel = joblib.load(model_file_name)

file_name = (

   “test_point.csv”  # customize to your test file, will be ‘mnist.single.test’ if use data above

)

with open(file_name, “r”) as f:

   mypayload = np.loadtxt(f, delimiter=”,”)

print(mypayload)  

mymodel.predict(mypayload)

#### Create a tar.gz model file as this is the format required by Sagemaker for deployment.

#### This step Booster.save_model was needed before creating a tar.gz . Otherwise I faced issues with prediction on deployment.

mymodel._Booster.save_model(model_file_name)

#!tar czvf model.tar.gz $model_file_name

### Upload the pre-trained model to S3

#### prefix in S3

prefix = “sagemaker/DEMO-xgboost-byo”

fObj = open(“model.tar.gz”, “rb”)

key = os.path.join(prefix, model_file_name, “model.tar.gz”)

print(key)

boto3.Session().resource(“s3”).Bucket(bucket).Object(key).upload_fileobj(fObj)

#### Create a Sagemaker model

#### Get the built-in xgboost container image in Pagemaker to host our model

container = get_image_uri(boto3.Session().region_name, “xgboost”, “0.90-1”)

model_name = model_file_name + strftime(“%Y-%m-%d-%H-%M-%S”, gmtime())

model_url = “https://s3-{}.amazonaws.com/{}/{}”.format(region, bucket, key)

sm_client = boto3.client(“sagemaker”)

print(model_url)

primary_container = {

   “Image”: container,

   “ModelDataUrl”: model_url,

}

create_model_response2 = sm_client.create_model(

   ModelName=model_name, ExecutionRoleArn=role, PrimaryContainer=primary_container

)

print(create_model_response2[“ModelArn”])

### Create endpoint configuration

endpoint_config_name = “DEMO-XGBoostEndpointConfig-” + strftime(“%Y-%m-%d-%H-%M-%S”, gmtime())

print(endpoint_config_name)

create_endpoint_config_response = sm_client.create_endpoint_config(

   EndpointConfigName=endpoint_config_name,

   ProductionVariants=[

       {

           “InstanceType”: “ml.m4.xlarge”,

           “InitialInstanceCount”: 1,

           “InitialVariantWeight”: 1,

           “ModelName”: model_name,

           “VariantName”: “AllTraffic”,

       }

   ],

)

print(“Endpoint Config Arn: ” + create_endpoint_config_response[“EndpointConfigArn”])

### Create endpoint

endpoint_name = “DEMO-XGBoostEndpoint-” + strftime(“%Y-%m-%d-%H-%M-%S”, gmtime())

print(endpoint_name)

create_endpoint_response = sm_client.create_endpoint(

   EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name

)

print(create_endpoint_response[“EndpointArn”])

resp = sm_client.describe_endpoint(EndpointName=endpoint_name)

status = resp[“EndpointStatus”]

print(“Status: ” + status)

while status == “Creating”:

   time.sleep(60)

   resp = sm_client.describe_endpoint(EndpointName=endpoint_name)

   status = resp[“EndpointStatus”]

   print(“Status: ” + status)

print(“Arn: ” + resp[“EndpointArn”])

print(“Status: ” + status)

### Validate the model for use

#Now you can obtain the endpoint from the client library using the result from previous operations and generate classifications from the model using that endpoint.

runtime_client = boto3.client(“runtime.sagemaker”)

#Lets generate the prediction. We’ll pick csv data from the test data file

file_name = (

   “test_point.csv”  # customize to your test file, will be ‘mnist.single.test’ if use data above

)

with open(file_name, “r”) as f:

   payload = f.read().strip()     

print(“Payload :\n”)

print(payload)

response = runtime_client.invoke_endpoint(

   EndpointName=endpoint_name, ContentType=”text/csv”, Body=payload

)

print(“Results :\n”)

result = response[“Body”].read().decode(“ascii”)

# Unpack response

print(“\nPredicted Class Probabilities: {}.”.format(result))

### (Optional) Delete the Endpoint

#If you’re ready to be done with this notebook, please run the delete_endpoint line in the cell below.  This will remove the hosted endpoint you created and avoid any charges from a stray instance being left on.

#sm_client.delete_endpoint(EndpointName=endpoint_name)