Introduction
Machine Learning models are rapidly transitioning from experimental stages to real-world applications. The journey from a fully trained model to functioning application involves several steps, the most significant being deployment. AWS SageMaker simplifies this process by offering a managed platform for building, training, and deploying models. It supports real-time predictions, manages dynamic workloads, and integrates seamlessly with other services.
This article guides you through the process of deploying a machine learning model, specifically a .pkl (Pickle) file onto AWS SageMaker and connecting it to a frontend application for real-time predictions.
By the end, you'll understand how to deploy a trained model on SageMaker and integrate it with a frontend application.
Diagrammatic Representation
Prerequisites
AWS Management Console
A trained model
Before we dive into the deployment process, make sure your model is saved as a .pkl file and then compressed into a '.tar.gz' format. If you don’t have your model in this format yet, use the following code snippet in your Jupyter notebook to save and compress your model:
import joblib import tarfile model = model_name #Enter your model name here joblib.dump(model, 'model.pkl') #Saving it as .pkl file with tarfile.open('model.tar.gz', 'w:gz') as tar: #Compressing into tar.gz tar.add('model.pkl') files.download('model.tar.gz') #Downloading the file locally Setup Steps
1. Sign-in to the AWS Management Console and navigate to S3
2. Create a S3 bucket
a) Click create bucket
b) Enter a unique bucket name (e.g. 'mymlbucket') and then create it!
c) Go to your bucket and upload your 'model.tar.gz' file
3. Go to SageMaker
Open SageMaker console and set up a SageMaker domain.
Follow the steps below to create one
4. Launch SageMaker Studio
We'll use SageMaker Studio to create our own JupyterLab workspace.
Click on Studio and then click Open Studio.
This will take you to the SageMaker Studio console.
Navigate to JupyterLab and create your own workspace.
Now you're all set to begin the deployment process in SageMaker Studio!
Deploying the model
1. Install the SageMaker Python SDK
We start by installing SageMaker Python SDK in our notebook and configuring it with an IAM role to access S3. Follow these steps:
!pip install sagemaker #This command installs SageMaker Python SDK 2. Import SageMaker and Configure the Session
Next, import the SageMaker library and setup the session using IAM role
import sagemaker from sagemaker.sklearn.model import SKLearnModel sagemaker_session = sagemaker.Session() role = 'arn:aws:iam::account_id:role/service-role/AmazonSageMaker- ExecutionRole' Now, we come to one of the most essential parts— the 'inference.py' script. This script defines how the input data will be processed during inference. It comprises several key components such as loading the model, preprocessing inputs (like converting JSON inputs to formats such as DataFrames), predicting the data, formatting the output, and most importantly, handling errors.
import json import joblib import os import numpy as np import pandas as pd def model_fn(model_dir): model = joblib.load(f"{model_dir}/model.pkl") # Loading the model return model def input_fn(request_body, request_content_type): if request_content_type == 'application/json': input_data = json.loads(request_body) # Ensuring correct data types for the input input_data['Store'] = np.int64(input_data['Store']) input_data['Holiday_Flag'] = np.int64(input_data['Holiday_Flag']) input_data['Month'] = np.int32(input_data['Month']) input_data['DayOfWeek'] = np.int32(input_data['DayOfWeek']) input_data['Temperature'] = np.float64(input_data['Temperature']) input_data['Fuel_Price'] = np.float64(input_data['Fuel_Price']) input_data['CPI'] = np.float64(input_data['CPI']) input_data['Unemployment'] = np.float64(input_data['Unemployment']) input_df = pd.DataFrame([input_data]) # Converting input to DataFrame expected_features = ['Store', 'Holiday_Flag', 'Temperature', 'Fuel_Price', 'CPI', 'Unemployment', 'Month', 'DayOfWeek'] input_df = input_df[expected_features] return input_df else: return None def predict_fn(input_data, model): prediction = model.predict(input_data) # Making predictions return prediction def output_fn(prediction, response_content_type): result = {'Predicted Weekly Sales': prediction[0]} return json.dumps(result) 3. The above steps helped us in setting up the environment and configuring the role. Now it is time to DEPLOY!
I am using the following code snippet for this. This code loads the model from S3 and we specify entry point script for inference
from sagemaker.sklearn.model import SKLearnModel model_uri = 's3://bucket_name/model.tar.gz' # Bucket that has the model entry_point = 'inference.py' # Entry point script model = SKLearnModel( model_data=model_uri, role=role, entry_point=entry_point, framework_version='1.2-1', # scikit-learn version sagemaker_session=sagemaker_session ) predictor = model.deploy( instance_count=1, instance_type='ml.m5.large' ) 4. After successfully completing the deployment, endpoint URL can be retrieved from SageMaker Studio console. This endpoint URL is essential for testing your model and integrating it with your frontend.
5. It's time to TEST !! We'll us this endpoint URL to test our model. Use the following code snippet. Make sure to change the input data attributes as per your model
import boto3 import json # Initialize the SageMaker runtime client sagemaker_runtime = boto3.client('sagemaker-runtime') # Input data input_data = { 'Store': 41, 'Month': 12, 'DayOfWeek': 17, 'Holiday_Flag': 0, 'Temperature': 24.31, 'Fuel_Price': 44.72, 'CPI': 119.0964, 'Unemployment': 5.106 } # Convert input data to JSON string payload = json.dumps(input_data) # Invoke the SageMaker endpoint response = sagemaker_runtime.invoke_endpoint( EndpointName='sagemaker-scikit-learn-2024-08-18-09', # Replace with your actual endpoint name ContentType='application/json', Body=payload ) # Parse and print the response result = json.loads(response['Body'].read().decode()) print(f"Predicted Weekly Sales: {result['Predicted Weekly Sales']}") 6.And just like that, your model has been successfully deployed ! Now we can take it further by connecting it with AWS Lambda and API gateway to display predictions onto the frontend applications!
Connecting SageMaker to Lambda
1. Navigate to AWS Lambda
Click 'Create function' and use Python as runtime language
2. Set up IAM role:
It is necessary to provide right set of permissions to Lambda, these include access to AWS SageMaker and API gateway
3. After creating the function, use the following code snippet to connect it with Lambda
```python import boto3 import json def lambda_handler(event, context): print("Event:", event) if 'body' not in event: return { 'statusCode': 400, 'body': json.dumps({'error': "'body' missing in the event"}) } sagemaker_runtime = boto3.client('runtime.sagemaker') try: response = sagemaker_runtime.invoke_endpoint( EndpointName='sagemaker-scikit-learn-2024-08-18-09', ContentType='application/json', Body=json.dumps(input_data) ) result = json.loads(response['Body'].read().decode()) return { 'statusCode': 200, 'headers': {'Content-Type': 'application/json'}, 'body': json.dumps({'predicted_sales': result}) } except Exception as e: return { 'statusCode': 500, 'body': json.dumps({'error': str(e)}) } ``` 4. Deploy the function ! You have successfully connected AWS SageMaker and Lambda!
Now, with the connection established, proceed with connecting it to API Gateway and integrating it with your frontend application as your next steps.
Frontend in Action
After successful connection, you'll be able to see your frontend receiving the predictions! Here's mine!
Conclusion
Deploying a machine learning model on AWS SageMaker bridges the gap between development and production. The above steps should help you navigate your way to deploying your first model !
If you encounter any issues or need additional insights during the deployment process, CloudWatch is your go-to tool for monitoring and troubleshooting!
Top comments (0)