Lambda AWS SageMaker example code: python, nodejs, Java

What is AWS SageMaker?

Amazon SageMaker is a fully managed machine learning service provided by Amazon Web Services (AWS) that enables developers and data scientists to quickly and easily build, train, and deploy machine learning models.

SageMaker provides a variety of features and capabilities, including:

– Easy model creation: SageMaker provides pre-built algorithms and frameworks that can be used to quickly train and deploy machine learning models. It also supports custom algorithms and frameworks, such as TensorFlow, PyTorch, and MXNet.
– Scalable infrastructure: SageMaker automatically provisions and manages the infrastructure required to train and deploy models, including compute resources and storage.
– Model deployment: SageMaker makes it easy to deploy trained models to a variety of environments, including the SageMaker hosting environment, AWS Lambda, and EC2.
– Monitoring and management: SageMaker provides tools for monitoring and managing machine learning workflows, including tracking metrics, debugging, and troubleshooting.
– Collaboration and sharing: SageMaker provides features for collaboration and sharing, such as sharing notebooks and models with other users.
– SageMaker also provides the capability to use pre-trained models, such as ChatGPT, which can be fine-tuned to specific use cases. This allows developers and data scientists to quickly build and deploy models without having to start from scratch.

In summary, SageMaker is a comprehensive machine learning platform that provides an easy way to build, train, and deploy machine learning models with the scalability and security of the AWS infrastructure.

Python Lambda AWS SageMaker example code

Sure, here is an example of an AWS Lambda function that uses Amazon SageMaker to invoke a pre-trained model and return the result:

import json
import boto3

def lambda_handler(event, context):
    # Connect to SageMaker runtime
    sagemaker_runtime = boto3.client('runtime.sagemaker')

    # Get the input text from the event
    input_text = event['input_text']

    # Invoke the pre-trained model
    response = sagemaker_runtime.invoke_endpoint(
        EndpointName='chatgpt-endpoint',
        Body=input_text.encode('utf-8'),
        ContentType='application/json'
    )

    # Get the response from the model
    result = json.loads(response['Body'].read().decode('utf-8'))
    return result

This example assumes that you have already set up an endpoint for your pre-trained model in Amazon SageMaker and the endpoint name is ‘chatgpt-endpoint’.

In this example, the function takes an event and a context as input, the input text is extracted from the event using the key ‘input_text’ and passed as input to the sagemaker_runtime.invoke_endpoint method. The result of the model is returned by the function in form of a json object.

Please note that this is just an example and it may not work as is, it would require additional code and setup to make it work in your environment. Additionally, you may need to consider other factors, such as error handling, security and performance, depending on your specific use case.

Also, make sure that the IAM role associated with the lambda has the permission to access SageMaker and Lambda.

Java Lambda AWS SageMaker example code

Sure, here is an example of an AWS Lambda function written in Java that uses Amazon SageMaker to invoke a pre-trained model and return the result:

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.sagemakerruntime.AmazonSageMakerRuntime;
import com.amazonaws.services.sagemakerruntime.AmazonSageMakerRuntimeClientBuilder;
import com.amazonaws.services.sagemakerruntime.model.InvokeEndpointRequest;
import com.amazonaws.services.sagemakerruntime.model.InvokeEndpointResult;
import java.nio.charset.StandardCharsets;

public class LambdaFunctionHandler implements RequestHandler {

    @Override
    public String handleRequest(Object input, Context context) {
        // Connect to SageMaker runtime
        AmazonSageMakerRuntime sagemakerRuntime = AmazonSageMakerRuntimeClientBuilder.defaultClient();

        // Get the input text from the input object
        String inputText = (String) input;

        // Invoke the pre-trained model
        InvokeEndpointRequest request = new InvokeEndpointRequest()
            .withEndpointName("chatgpt-endpoint")
            .withContentType("application/json")
            .withAccept("application/json")
            .withBody(inputText);
        InvokeEndpointResult response = sagemakerRuntime.invokeEndpoint(request);

        // Get the response from the model
        return new String(response.getBody().array(), StandardCharsets.UTF_8);
    }
}

This example assumes that you have already set up an endpoint for your pre-trained model in Amazon SageMaker and the endpoint name is ‘chatgpt-endpoint’. In this example, the function takes an object as input, the input text is extracted from the object, and passed as input to the sagemakerRuntime.invokeEndpoint method. The result of the model is returned by the function in form of a string.

Please note that this is just an example and it may not work as is, it would require additional code and setup to make it work in your environment. Additionally, you may need to consider other factors, such as error handling, security and performance, depending on your specific use case.

Also, make sure that the IAM role associated with the lambda has the permission to access SageMaker and Lambda.

Nodejs Lambda AWS SageMaker example code

Sure, here is an example of an AWS Lambda function written in Node.js that uses Amazon SageMaker to invoke a pre-trained model and return the result:

const AWS = require('aws-sdk');
const sagemakerRuntime = new AWS.SageMakerRuntime({apiVersion: '2017-05-13'});

exports.handler = async (event) => {
    // Get the input text from the event
    const inputText = event.input_text;

    // Invoke the pre-trained model
    const params = {
        EndpointName: "chatgpt-endpoint",
        Body: inputText,
        ContentType: "application/json",
        Accept: "application/json"
    };
    const response = await sagemakerRuntime.invokeEndpoint(params).promise();

    // Get the response from the model
    const result = response.Body.toString('utf-8');

    return result;
};

This example assumes that you have already set up an endpoint for your pre-trained model in Amazon SageMaker and the endpoint name is ‘chatgpt-endpoint’. In this example, the function takes an event as input, the input text is extracted from the event using the key ‘input_text’ and passed as input to the sagemakerRuntime.invokeEndpoint method. The result of the model is returned by the function in form of a string.

Please note that this is just an example and it may not work as is, it would require additional code and setup to make it work in your environment. Additionally, you may need to consider other factors, such as error handling, security and performance, depending on your specific use case.

Also, make sure that the IAM role associated with the lambda has the permission to access SageMaker and Lambda.

AWS SageMaker cost

The cost of using Amazon SageMaker depends on several factors, including the type and number of instances used for training and inference, the amount of data stored, and the usage of additional services.

There are three main components that make up the cost of using SageMaker:

Compute: This includes the cost of running instances for training and inference, as well as the cost of using SageMaker’s built-in algorithms and frameworks.

Storage: This includes the cost of storing data in Amazon S3, as well as the cost of using SageMaker’s data management features.

Other Services: This includes the cost of using additional services such as data preparation, data labeling, and data management.

Additionally, you’ll be charged for data transfer out of the region, as well as for data stored by SageMaker.

You can use the AWS pricing calculator to estimate the cost of using SageMaker for your specific use case. The pricing calculator allows you to select different instance types, configure storage and data transfer options, and estimate the cost of using additional services.

It’s also important to note that if you choose to use a pre-trained model such as ChatGPT, you’ll be charged for the usage of the model, and if you fine-tune it, the cost of the instances used for fine-tuning.

In general, the cost of using SageMaker can vary greatly depending on the specific use case, so it’s important to monitor usage and adjust instances and other resources as needed to keep costs under control.

SageMaker with ChatGPT example code

Here is an example of using Amazon SageMaker to fine-tune a pre-trained ChatGPT model and deploy it as an endpoint:

import boto3

# Connect to SageMaker
sagemaker = boto3.client('sagemaker')

# Specify the S3 location of the pre-trained model and the location to save the fine-tuned model
model_data = 's3://path/to/pre-trained/model'
output_path = 's3://path/to/save/fine-tuned/model'

# Specify the training job name and the location of the training data
job_name = 'chatgpt-fine-tuning-job'
training_data = 's3://path/to/training/data'

# Create the training job
response = sagemaker.create_training_job(
    TrainingJobName=job_name,
    AlgorithmSpecification={
        'TrainingImage': 'openai/gpt-2:latest',
        'TrainingInputMode': 'File'
    },
    RoleArn='arn:aws:iam::ACCOUNT_ID:role/service-role/AmazonSageMaker-ExecutionRole-20210101T000000',
    InputDataConfig=[
        {
            'ChannelName': 'train',
            'DataSource': {
                'S3DataSource': {
                    'S3DataType': 'S3Prefix',
                    'S3Uri': training_data,
                    'S3DataDistributionType': 'FullyReplicated'
                }
            },
            'ContentType': 'text/plain',
            'CompressionType': 'None'
        }
    ],
    OutputDataConfig={
        'S3OutputPath': output_path
    },
    ResourceConfig={
        'InstanceType': 'ml.p3.2xlarge',
        'InstanceCount': 1,
        'VolumeSizeInGB': 50
    },
    StoppingCondition={
        'MaxRuntimeInSeconds': 86400
    },
    HyperParameters={
        'model_name': 'text-davinci-002',
        'overwrite_output_dir': 'True'
    }
)

# Wait for the training job to complete
sagemaker.get_waiter('training_job_completed_or_stopped').wait(TrainingJobName=job_name)

# Create an endpoint configuration
response = sagemaker.create_endpoint_config(
    EndpointConfigName='chatgpt-endpoint-config',
    ProductionVariants=[
        {
            'VariantName': 'chatgpt-variant',
            'ModelName': job_name,
            'InitialInstanceCount': 1,
            'InstanceType': 'ml.t2.medium'
        }
    ]
)

# Create the endpoint
response = sagemaker.create_endpoint(
    EndpointName='chatgpt-endpoint',
    EndpointConfigName='chatgpt-endpoint-config'
)