Deploying Your Machine Learning Model to Production in the Cloud

Image by Editor
AWS, or Amazon Web Services, is a cloud computing service used in many companies for storage, analytics, purposes, deployment providers, and plenty of others. It’s a platform makes use of a number of providers to assist enterprise in a serverless method with pay-as-you-go schemes.
Machine studying modeling exercise can be certainly one of the actions that AWS helps. With a number of providers, modeling actions might be supported, akin to creating the mannequin to making it into manufacturing. AWS has proven versatility, which is crucial for any enterprise that wants scalability and velocity.
This article will talk about deploying a machine studying mannequin in the AWS cloud into manufacturing. How might we do this? Let’s discover additional.

Before you begin this tutorial, you want to create an AWS account, as we would want them to entry all the AWS providers. I assume that the reader would use the free tier to observe this text.  Additionally, I assume the reader already is aware of how to use Python programming language and has primary information of machine studying.  Also, we are going to give attention to the mannequin deployment half and won’t focus on different facets of knowledge science exercise, akin to knowledge preprocessing and mannequin analysis.
With that in thoughts, we are going to begin our journey of deploying your machine studying mannequin in the AWS Cloud providers.

In this tutorial, we are going to develop a machine-learning mannequin to predict churn from the given knowledge. The coaching dataset is acquired from Kaggle, which you’ll be able to obtain right here.
After we’ve acquired the dataset, we’d create an S3 bucket to retailer the dataset. Search the S3 in the AWS providers and make the bucket.
 Image by Author
In this text, I named the bucket “telecom-churn-dataset” and situated in Singapore. You can change them if you’d like, however let’s go along with this one for now.
After you may have completed creating the bucket and importing the knowledge into your bucket, we are going to go to the AWS SageMaker service. In this service, we are going to use the Studio as our working surroundings. If you may have by no means used the Studio, let’s create a site and person earlier than continuing additional.
First, select the Domains inside the Amazon SageMaker Admin configurations.
 Image by Author
In the Domains, you’ll see a variety of buttons to choose. In this display, choose the Create area button. 
 Image by Author
Choose the fast setup if you’d like to velocity up the creation course of. After it’s completed, it’s best to see a brand new area created in the dashboard. Select the new area you simply created after which click on the Add person button.
 Image by Author
Next, it’s best to identify the person profile in accordance to your preferences. For the execution position, you may go away it on default for now, because it’s the one which was created throughout the Domain creation course of.
 Image by Author
Just click on subsequent till the canvas setting. In this part, I flip off a number of settings that we don’t want, akin to Time Series Forecasting. 
After all the pieces is ready, go to the studio choice and choose the Open studio button with the person identify you simply created.
 Image by Author
Inside the Studio, navigate to the sidebar that appears like a folder icon and create a brand new pocket book there. We can allow them to by default, like the picture beneath.
 Image by Author
With the new pocket book, we’d work to create a churn prediction mannequin and deploy the mannequin into API inferences that we are able to use in manufacturing.
First, let’s import the needed package deal and browse the churn knowledge.

import boto3
import pandas as pd
import sagemaker

sagemaker_session = sagemaker.Session()
position = sagemaker.get_execution_role()

df = pd.read_csv(‘s3://telecom-churn-dataset/telecom_churn.csv’)

 Image by Author
Next, we’d cut up the knowledge above into coaching knowledge and testing knowledge with the following code.

from sklearn.model_selection import train_test_split

prepare, check = train_test_split(df, test_size = 0.3, random_state = 42)

We set the check knowledge to be 30% of the authentic knowledge. With our knowledge cut up, we’d add them again into the S3 bucket.


prepare.to_csv(f’s3://{bucket}/telecom_churn_train.csv’, index = False)
check.to_csv(f’s3://{bucket}/telecom_churn_test.csv’, index = False)

You can see the knowledge inside your S3 bucket, which at the moment consists of three completely different datasets.
 Image by Author
With our dataset prepared, we’d now develop a churn prediction mannequin and deploy them. In the AWS, we regularly use a script coaching methodology for machine studying coaching. That’s why we’d develop a script earlier than beginning the coaching.
For the subsequent step, we want to create an extra Python file, which I referred to as, in the identical folder.
 Image by Author
Inside this file, we’d set our mannequin growth course of to create the churn mannequin. For this tutorial, I might undertake some code from Ram Vegiraju.
First, we’d import all the needed packages for creating the mannequin.

import argparse
import os
import io
import boto3
import json
import pandas as pd

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import joblib

Next, we’d use the parser methodology to management the variable that we are able to enter into our coaching course of. The total code that we’d put in our script to prepare our mannequin is in the code beneath.

if __name__ == ‘__main__’:

parser = argparse.ArgumentParser()

parser.add_argument(‘–estimator’, sort=int, default=10)
parser.add_argument(‘–sm-model-dir’, sort=str, default=os.environ.get(‘SM_MODEL_DIR’))
parser.add_argument(‘–model_dir’, sort=str)
parser.add_argument(‘–train’, sort=str, default=os.environ.get(‘SM_CHANNEL_TRAIN’))

args, _ = parser.parse_known_args()

estimator = args.estimator
model_dir = args.model_dir
sm_model_dir = args.sm_model_dir
training_dir = args.prepare

s3_client = boto3.consumer(‘s3′)

obj = s3_client.get_object(Bucket=bucket, Key=’telecom_churn_train.csv’)
train_data = pd.read_csv(io.BytesIO(obj[‘Body’].learn()))

obj = s3_client.get_object(Bucket=bucket, Key=’telecom_churn_test.csv’)
test_data = pd.read_csv(io.BytesIO(obj[‘Body’].learn()))

X_train = train_data.drop(‘Churn’, axis =1)
X_test = test_data.drop(‘Churn’, axis =1)

y_train = train_data[‘Churn’]
y_test = test_data[‘Churn’]

rfc = RandomForestClassifier(n_estimators=estimator)
rfc.match(X_train, y_train)
y_pred = rfc.predict(X_test)

print(‘Accuracy Score: ‘,accuracy_score(y_test, y_pred))

joblib.dump(rfc, part of(args.sm_model_dir, “rfc_model.joblib”))

Lastly,  we want to put 4 completely different features that SageMaker requires to make inferences: model_fn, input_fn, output_fn, and predict_fn.

#Deserialized mannequin to load them

def model_fn(model_dir):
mannequin = joblib.load( part of(model_dir, “rfc_model.joblib”))
return mannequin
#The request enter of the utility
def input_fn(request_body, request_content_type):
if request_content_type == ‘utility/json’:
request_body = json.hundreds(request_body)
inp_var = request_body[‘Input’]
return inp_var
increase ValueError(“This mannequin solely helps utility/json enter”)
#The prediction features
def predict_fn(input_data, mannequin):
return mannequin.predict(input_data)

#The output perform
def output_fn(prediction, content_type):
res = int(prediction[0])
resJSON = {‘Output’: res}
return resJSON

With our script prepared, we’d run the coaching course of. In the subsequent step, we’d cross the script we created above into the SKLearn estimator. This estimator is a Sagemaker object that may deal with the whole coaching course of, and we’d solely want to cross all the parameters comparable to the code beneath.

from sagemaker.sklearn import SKLearn

sklearn_estimator = SKLearn(entry_point=””,
‘estimator’: 15})

If the coaching is profitable, you’ll find yourself with the following report.
 Image by Author
If you need to test the Docker picture for the SKLearn coaching and your mannequin artifact location, you may entry them utilizing the following code.

model_artifact = sklearn_estimator.model_data
image_uri = sklearn_estimator.image_uri

print(f’The mannequin artifact is saved at: {model_artifact}’)
print(f’The picture URI is: {image_uri}’)

With the mannequin in place, we’d then deploy the mannequin into an API endpoint that we are able to use for prediction. To do this, we are able to use the following code.

import time

churn_endpoint_name=”churn-rf-model-“+time.strftime(“%Y-%m-%d-%H-%M-%S”, time.gmtime())


If the deployment is profitable, the mannequin endpoint is created, and you’ll entry it to create a prediction. You also can see the endpoint in the Sagemaker dashboard.
 Image by Author
You can now make predictions with this endpoint. To do this, you may check the endpoint with the following code.

consumer = boto3.consumer(‘sagemaker-runtime’)
content_type = “utility/json”

#change together with your meant enter knowledge
request_body = {“Input”: [[128,1,1,2.70,1,265.1,110,89.0, 9.87,10.0]]}

#change together with your endpoint identify
endpoint_name = “churn-rf-model-2023-09-24-12-29-04″
#Data serialization
knowledge = json.hundreds(json.dumps(request_body))
payload = json.dumps(knowledge)

#Invoke the endpoint
response = consumer.invoke_endpoint(
outcome = json.hundreds(response[‘Body’].learn().decode())[‘Output’]

Congratulation. You have now efficiently deployed your mannequin in the AWS Cloud. After you may have completed the testing course of, don’t overlook to clear up the endpoint. You can use the following code to do this.

from sagemaker import Session

sagemaker_session = Session()

Don’t overlook to shut down the occasion you utilize and clear up the S3 storage in the event you don’t want it anymore.
For additional studying, you may learn extra about the SKLearn estimator and Batch Transform inferences in the event you want to not have an endpoint mannequin.

AWS Cloud platform is a multi-purpose platform that many firms use to assist their enterprise. One of the providers typically used is for knowledge analytic functions, particularly mannequin manufacturing. In this text, we study to use AWS SageMaker and the way to deploy the mannequin into the endpoint.  Cornellius Yudha Wijaya is an information science assistant supervisor and knowledge author. While working full-time at Allianz Indonesia, he loves to share Python and Data suggestions through social media and writing media.

Recommended For You