GenAI: Automated Content Generation App using AWS Bedrock, SageMaker, AWS Lambda: From Myth to Reality (Step by Step)

In the world of Generative AI (GenAI), deploying applications that leverage cutting-edge models is becoming increasingly accessible thanks to cloud-based services like AWS Bedrock. This article introduces AWS Bedrock, compares it with other Generative AI services, and provides a step-by-step guide to deploying a simple AI-powered application. It also discusses key components, cost considerations, and dependencies, giving technical professionals, consultants, and C-level executives the knowledge needed to integrate AI solutions into their strategies.

1. Introduction to AWS Bedrock

AWS Bedrock is a fully managed service from Amazon Web Services that makes it easy to build and deploy Generative AI applications. It provides seamless access to pre-trained foundational models (FMs) from leading AI research organizations, including Anthropic, Stability AI, Cohere, and Amazon's own models. By integrating Bedrock into the development process, organizations can fine-tune these models for specific use cases without worrying about the complexities of infrastructure management.

Bedrock allows developers to quickly deploy text generation, image generation, and code generation models with minimal configuration. The service integrates smoothly with other AWS offerings like Amazon S3, AWS Lambda, and Amazon SageMaker, making it an attractive choice for businesses looking to enhance their AI capabilities.

2. Comparison with Other Generative AI Services

While there are many AI services on the market, such as Google’s Vertex AI, Microsoft Azure OpenAI Service, and OpenAI's API, AWS Bedrock stands out for the following reasons:

• Ease of Integration: Bedrock integrates natively with other AWS services, making it ideal for companies already using the AWS ecosystem.
• Model Variety: It provides a range of foundation models from multiple vendors, allowing users to choose the best model for their use case.
• Cost Efficiency: Bedrock does not require upfront infrastructure investment, which can reduce costs for smaller projects. However, this service does not fall in the free tier of AWS. For this other options are available.

3. Step-by-Step Guide: Deploying a Simple AI-Powered Application

Step 1: Define the Project Requirements

Before starting, determine the goal of the application and select the appropriate Generative AI model based on the use case. For this tutorial, we’ll create a text generation application that generates product descriptions for an e-commerce website.

Amazon Bedrock allows you to work with pre-trained and fine-tuned generative AI models.

• Requirements: An AWS account, knowledge of Python, and access to the AWS Management Console.
• Dependencies: Python development environment, access to foundational models through AWS Bedrock.

Step 2: Set Up Your AWS Environment

1. Create an AWS Account (if not already done).
2. Navigate to AWS Bedrock in the AWS Management Console.
3. Create a new project and configure permissions using IAM roles to grant access to Bedrock models.
4. Open the AWS Management Console, navigate to Amazon SageMaker, and create a notebook instance.
5. Choose an instance type (e.g., ml.t2.medium), attach the IAM role, and launch.

Step 3: Choose a Model for Text Generation (Get Started and Build Understanding)

1. In the Bedrock console, browse the available models. For this example, we’ll choose the Cohere Text Generation model.
2. Select the model and configure any necessary parameters, such as the temperature (for randomness) and the maximum token limit.
3. Alternatively use the below command to find out the list of available models. Models availability depends on the used AWS region and individual AWS account settings:

• AI21 Labs Jurrasic ,
• Amazon Titan ,
• Anthropic Claude ,
• Cohere Command , and
• Stability AI .

Use the below commands to list the available models under the account.

$ > aws bedrock list-foundation-models
{
    "modelSummaries": [
        {
            "modelArn": "arn:aws:bedrock:me-central-1::foundation-model/amazon.titan-tg1-large",
            "modelId": "amazon.titan-tg1-large",
            "modelName": "Titan Text Large",
            "providerName": "Amazon",
            "inputModalities": [
                "TEXT"
            ],
            "outputModalities": [
                "TEXT"
            ],
            "responseStreamingSupported": true,
            "customizationsSupported": [
                "FINE_TUNING"
            ],
            "inferenceTypesSupported": [
                "ON_DEMAND"
            ]
        },
    [ … ]
}        

You may require enabling access to the available models.

Step 4: Deploy the Model Endpoint

1. Create a new endpoint for the text generation model.
2. Deploy the endpoint, which will generate a URL for accessing the model’s API.
3. Test the endpoint using sample inputs to ensure the model is functioning correctly.

Step 5: Develop the Application

I prefer creating a local environment with Python and calling bedrock endpoint. Please note this requires enabling and configuring AWS locally on your device. use "aws configure" for this.

1. Set up a local development environment. This tutorial assumes you’re using Python. Install necessary packages like boto3 (AWS SDK for Python) and requests.
2. Write a Python script that connects to the Bedrock endpoint and sends a text prompt to the model. You can find a sample implementation on GitHub .

python

import boto3

# Initialize a Bedrock client
client = boto3.client('bedrock', region_name='me-central-1')

# Define the text generation function
def generate_description(prompt):
    response = client.invoke_model(
        ModelId='cohere-text-gen',
        Body={'prompt': prompt, 'maxTokens': 150, 'temperature': 0.7}
    )
    return response['generatedText']

# Example usage
prompt = "Describe the features of a smartwatch"
print(generate_description(prompt))        

Once tested using python code move to the next phase. i.e real application

Step 6: Build the real application with Amazon Bedrock for Generative AI

Moving towards the real application, use the sample code. I am using UAE region which has some models available now

6.1 Generating Text with a Pre-trained Model

import boto3

# Initialize Bedrock client
client = boto3.client('bedrock', region_name='me-central-1')

# Input text prompt for content generation
input_text = "Write an introduction to generative AI for content creation."

# Invoke the Bedrock model
response = client.invoke_endpoint(
    EndpointName='your-bedrock-endpoint',
    Body={
        'text': input_text
    }
)

# Extract and print generated content
generated_text = response['Body']['generated_text']
print("Generated Content:\n", generated_text)        

Step 6.2: Fine-Tuning Models on Amazon SageMaker

To enhance content generation, fine-tuning a pre-trained model is recommended. Use SageMaker's training features to customize the model.

6.2.1 Prepare Your Dataset

• Create a text dataset for fine-tuning. Make sure it’s in a .csv or .json format.
• Upload the dataset to an S3 bucket.

6.2.2 Set Up Training Job

import sagemaker
from sagemaker import TrainingInput, Estimator

# Set up training parameters
role = 'your-sagemaker-execution-role'
bucket = 'your-s3-bucket'
training_data = TrainingInput(f's3://{bucket}/your-dataset.csv', content_type='text/csv')

# Define SageMaker Estimator
estimator = Estimator(
    image_uri='your-training-image-uri',
    role=role,
    instance_count=1,
    instance_type='ml.m5.large',
    output_path=f's3://{bucket}/output',
)

# Start the training job
estimator.fit({'train': training_data})        

6.3 Deploy the Fine-Tuned Model

• Deploy the trained model to an endpoint using estimator.deploy().

Step 7: Deploy a realtime model

After training the model, deploying it involves setting up an endpoint where the model can be accessed for real-time inference. Here are the steps to deploy the fine-tuned model using Amazon SageMaker:

Step 1: Create a Model from the Training Output

First, create a SageMaker model using the training output. This step requires specifying the model artifacts generated during training and the corresponding Docker image.

python
from sagemaker.model import Model

# Get the S3 path of the trained model artifacts
model_data = estimator.model_data

# Create the model object
model = Model(
    model_data=model_data,
    image_uri='your-training-image-uri',
    role=role
)        

• model_data: This is the path to the trained model artifacts in S3. It was automatically saved during the training job.
• image_uri: The Docker image URI used for inference, usually the same as the one used for training.

Step 2: Deploy the Model to a Real-Time Endpoint

Next, deploy the model to a SageMaker endpoint, specifying the instance type and the number of instances for hosting the model.

python
# Deploy the model to an endpoint
predictor = model.deploy(
    initial_instance_count=1,
    instance_type='ml.m5.large',
    endpoint_name='your-fine-tuned-model-endpoint'
)        

• initial_instance_count: The number of instances to be used for the endpoint. Start with one instance and scale as needed.
• instance_type: The instance type for deployment. Choose a type based on the expected load (e.g., ml.m5.large for general-purpose or ml.g4dn.xlarge for GPU acceleration).
• endpoint_name: A custom name for the endpoint. This name will be used to invoke the model for predictions.

Step 3: Test the Endpoint with Sample Input

Now that the endpoint is live, you can test the model by sending requests to it and checking the responses.

python
# Example input text for testing
input_text = "Explain the impact of generative AI on digital marketing."

# Make a prediction using the deployed model
response = predictor.predict(input_text)

# Print the generated response
print("Model Output:\n", response)
        

• predictor.predict(): Sends the input data to the endpoint and returns the model's output.

Step 8: Integrating Amazon Textract for Document Processing

Amazon Textract can be used to extract text from documents, which can be processed by the generative AI model for further content creation.

8.1 Extract Text from a Document

import boto3

# Initialize Textract client
textract = boto3.client('textract')

# Upload document to S3
document_s3_path = 's3://your-bucket/your-document.pdf'

# Extract text from the document
response = textract.detect_document_text(
    Document={
        'S3Object': {
            'Bucket': 'your-bucket',
            'Name': 'your-document.pdf'
        }
    }
)

# Collect extracted text
extracted_text = ""
for item in response['Blocks']:
    if item['BlockType'] == 'LINE':
        extracted_text += item['Text'] + "\n"
print("Extracted Text:\n", extracted_text)        

8.2 Generate a Summary Using the Fine-Tuned Model

# Use the fine-tuned model to generate a summary of the extracted text
response = client.invoke_endpoint(
    EndpointName='your-fine-tuned-model-endpoint',
    Body={
        'text': extracted_text
    }
)

# Display the summary
summary = response['Body']['generated_text']
print("Generated Summary:\n", summary)        

Step 9: Automating Workflows with AWS Lambda

Create a Lambda function to automate the content creation p9rocess.

9.1 Set Up AWS Lambda Trigger

• Trigger the Lambda function when a new document is uploaded to S3.
• Integrate the Lambda function with Textract and Bedrock.

9.2 Lambda Code Example

import boto3

def lambda_handler(event, context):
    # Parse S3 event
    bucket = event['Records'][0]['s3']['bucket']['name']
    document = event['Records'][0]['s3']['object']['key']

    # Extract text using Textract
    textract = boto3.client('textract')
    response = textract.detect_document_text(
        Document={
            'S3Object': {
                'Bucket': bucket,
                'Name': document
            }
        }
    )

    # Concatenate extracted text
    extracted_text = "".join([item['Text'] for item in response['Blocks'] if item['BlockType'] == 'LINE'])

    # Generate content using Bedrock
    bedrock = boto3.client('bedrock', region_name='us-west-2')
    response = bedrock.invoke_endpoint(
        EndpointName='your-endpoint',
        Body={
            'text': extracted_text
        }
    )

    # Return generated content
    generated_content = response['Body']['generated_text']
    return {"GeneratedContent": generated_content}        

Step 10: Monitoring and Optimizing the Workflow

Use Amazon CloudWatch to monitor your content generation workflows, track performance, and optimize the processes.

10.1 Set Up CloudWatch Alarms

• Monitor the utilization of SageMaker instances, Lambda function execution times, and Bedrock model response times.
• Set up alerts for high utilization or failures.

11. Key Components, Cost Considerations, and Dependencies

11.1 Key Components

• Model Endpoint: The API endpoint that serves the model predictions.
• AWS Lambda or EC2: For hosting the application backend.
• AWS IAM Roles: For managing access permissions.
• Monitoring and Logging: Tools like Amazon CloudWatch for tracking model performance.

11.2 Cost Considerations

The cost of using AWS Bedrock depends on several factors, including:

• API Usage: Pay-per-inference charges, based on the number of requests and model type.
• Data Storage: Costs associated with storing input and output data in Amazon S3.
• Compute Resources: If additional resources like Amazon EC2 or Lambda are used.

11.3 Internal and External Dependencies

• Internal Dependencies: Team’s expertise with AWS services, and data privacy policies.
• External Dependencies: Model providers, and third-party integrations (e.g., APIs for external data sources).

12. Expected Cost Details

To provide an estimate, consider a scenario with 10,000 model inferences per month:

• Model Inference Cost: Approximately $0.001 per inference, totaling $10.
• Data Storage Cost: $0.023 per GB stored in S3 (e.g., 1 GB of data = $0.023).
• Lambda Compute Cost: $0.20 per million requests (minimal cost impact).

The monthly cost would be around $20-$30 for a lightweight application, scaling up as usage increases.

13. Conclusions

Deploying a simple AI-powered application using AWS Bedrock enables organizations to rapidly experiment with Generative AI without managing complex infrastructure. Bedrock’s integration with other AWS services provides flexibility, scalability, and cost-efficiency, making it suitable for a wide range of use cases. However, understanding the cost drivers and dependencies is crucial to effectively manage expenses and optimize performance.

AWS Bedrock is a compelling choice for organizations already using AWS and looking to integrate AI into their technology strategies. For businesses with minimal cloud infrastructure or those seeking specific models, alternatives like Google Vertex AI or Azure OpenAI Service might also be worth exploring.

Explore the Code Sample: GitHub Repository Additional Resources: AWS Bedrock Documentation

#AWSBedrock #GenerativeAI #MachineLearning #CloudComputing #TechInnovation #AI #TextGeneration #CloudServices #AWS #Cohere #AIstrategy #TechLeaders #DigitalTransformation #MachineLearning