Domain 3: Applications of Foundation Models (28% of exam)

Foundation Model Selection Criteria

Cost Considerations

Larger models cost more per token
Consider total cost: development + API usage over time
Balance model capability vs. budget constraints

Modality

Text-only for language tasks
Multi-modal for combined text/image/audio analysis
Choose based on application input/output types

Latency Requirements

Smaller models respond faster (<1 second)
Larger models may take several seconds
Critical for real-time user-facing applications

Multi-lingual Support

Some models trained on 100+ languages
Others optimized for English
Check language coverage for target markets

Model Size & Complexity

Parameters indicate model capacity (7B, 70B, 180B)
Larger = more capable but slower and more expensive
Choose smallest model that meets quality requirements

Customization Options

Some models support fine-tuning
Others are API-only (no fine-tuning available)
Consider future customization needs

Input/Output Length

Context window: maximum tokens (input + output combined)
Ranges from 4K to 200K+ tokens
Choose based on document length and response needs

Inference Parameters

Temperature

Controls randomness of responses (0.0 to 1.0)
Temperature = 0: Deterministic, consistent, focused (use for factual tasks, code generation)
Temperature = 1: Creative, diverse, unpredictable (use for brainstorming, creative writing)
0.3-0.7: Balanced for most applications

Top-P (Nucleus Sampling)

Alternative to temperature for controlling randomness
Considers only most likely tokens summing to probability p
Common values: 0.9-0.95

Max Tokens

Limits output length
Prevents runaway generation costs
Set based on expected response length

Stop Sequences

Tokens that halt generation when encountered
Use to format outputs or end at natural boundaries

Retrieval Augmented Generation (RAG)

What is RAG?

Combines retrieval from knowledge base with text generation
Grounds model responses in your data, reducing hallucinations
Model queries vector database for relevant context before generating response

RAG Benefits

Accuracy: Responses based on your data, not just model's training
Up-to-date: Use current data without retraining model
Citations: Can provide sources for generated content
Reduced hallucinations: Grounded in retrieved facts

RAG Workflow

Index: Convert documents to embeddings, store in vector database
Retrieve: Query vector DB with user question to find relevant chunks
Augment: Add retrieved context to user's prompt
Generate: Model produces response using context and question

Bedrock Knowledge Bases

Fully managed RAG solution integrated with Bedrock
Automatically handles chunking, embedding, indexing
Connects to S3 as data source
Supports multiple vector databases (OpenSearch, Aurora, Pinecone, Redis)

Vector Databases for Embeddings

Why Vector Databases?

Store and search high-dimensional embeddings efficiently
Enable similarity search at scale (millions to billions of vectors)
Support hybrid search (vector + keyword)

Amazon OpenSearch Service

Search and analytics engine with native vector search
Supports k-NN (k-nearest neighbors) algorithm
Good for hybrid search combining keywords and semantics
Scales to handle large embedding collections

Amazon Aurora (PostgreSQL-compatible)

Relational database with pgvector extension
Store embeddings alongside structured data in same database
Aurora Serverless scales automatically
Cost-effective for applications needing both SQL and vector search

Amazon Neptune

Graph database with vector search capabilities
Ideal for knowledge graphs + semantic search
Model complex entity relationships
Use when relationships between concepts matter

Amazon DocumentDB (MongoDB-compatible)

Document database with vector search
Store unstructured JSON documents with embeddings
Good for flexible schemas with semantic retrieval

Amazon RDS for PostgreSQL

Relational database with pgvector extension
Lower-cost alternative to Aurora for smaller workloads
Standard PostgreSQL with vector capabilities

Selection Guidance

Pure vector search → OpenSearch
Vectors + structured data → Aurora or RDS PostgreSQL
Vectors + graph relationships → Neptune
Vectors + flexible documents → DocumentDB

Foundation Model Customization Approaches

Pre-training (Most Expensive)

Train model from scratch on massive dataset
Requires enormous compute and data (months, millions of dollars)
Only for organizations building proprietary models
Not typically feasible for most use cases

Fine-tuning (Moderate Cost)

Adapt pre-trained model to specific task or domain
Requires labeled dataset (hundreds to thousands of examples)
Hours to days of training, thousands to tens of thousands of dollars
Use when you need specialized behavior not achievable with prompts

In-Context Learning (Low Cost)

Provide examples in the prompt itself (few-shot learning)
No training required - just API calls
Immediate results, only pay for tokens
Use when a few examples can guide the model

RAG (Low to Moderate Cost)

Connect model to your data without training
One-time indexing cost + ongoing retrieval costs
Most cost-effective for grounding responses in private data
Use when you need model to reference your documents

Cost Ranking (Least to Most)

In-context learning (cheapest)
RAG
Fine-tuning
Continued pre-training
Pre-training from scratch (most expensive)

Agents for Multi-Step Tasks

What are AI Agents?

Autonomous systems that break complex goals into steps and execute them
Use foundation models for reasoning and planning
Can call APIs, query databases, and use tools to complete tasks

Bedrock Agents Capabilities

Task orchestration: Plan and execute multi-step workflows
API integration: Call external services and AWS APIs
Knowledge bases: Access RAG for grounded responses
Action groups: Define available functions and tools
Error handling: Retry failed steps, adjust plans dynamically

Agent Use Cases

Complex customer support (check order, process refund, update preferences)
Research assistants (search, synthesize, summarize findings)
Data analysis (query databases, generate reports, create visualizations)
Booking systems (check availability, reserve, send confirmations)

Agent Architecture

Foundation model: Brain for reasoning and language
Instructions: System prompts defining agent's role
Action groups: Functions the agent can call
Knowledge bases: Information the agent can reference
Memory: Maintains context across conversation turns

Prompt Engineering Fundamentals

Prompt Components

Context

Background information to ground the model
Example: "You are a helpful customer support agent for an e-commerce company."

Instruction

Clear, specific direction of what to do
Example: "Summarize the following customer feedback in 3 bullet points."

Input Data

The content to process
Example: Customer review text, document to analyze

Output Format

Specify desired structure
Example: "Return your response as JSON with keys: summary, sentiment, action_items"

Negative Prompts

Tell model what NOT to do or include
Example: "Do not mention competitor products" or "Do not use technical jargon"

Prompt Engineering Techniques

Zero-Shot Prompting

Ask model to perform task without examples
Relies on model's pre-trained knowledge
Example: "Translate this to Spanish: [text]"

Single-Shot Prompting (One-Shot)

Provide one example of desired input-output pattern
Model infers pattern from single example

Few-Shot Prompting

Provide 2-10 examples of input-output pairs
Model learns pattern from examples
More effective than zero-shot for specific formats
Example: Show 3 customer emails and their classifications (urgent/routine)

Chain-of-Thought (CoT)

Instruct model to show reasoning steps before final answer
Improves performance on complex reasoning tasks
Example: "Let's solve this step by step:"
Variant: "Think through this problem, then provide your final answer"

Prompt Templates

Reusable prompt structures with variable placeholders
Ensure consistency across multiple uses
Example: "Summarize this {document_type} for a {audience_type} in {length} words: {document}"

Prompt Engineering Best Practices

Clarity and Specificity

Be explicit about what you want
Avoid ambiguous instructions
Provide constraints (length, format, tone)

Concision

Remove unnecessary words, but maintain clarity
Shorter prompts = lower token costs
But don't sacrifice critical context

Experimentation

Test multiple prompt variations
Compare outputs to find most effective approach
Iterate based on results

Using Multiple Comments/Instructions

Break complex tasks into clear steps
Number steps for multi-stage tasks
Separate concerns with clear sections

Guardrails in Prompts

Include safety instructions
Specify boundaries ("Don't provide medical advice")
Define acceptable response scope

Prompt Engineering Risks

Prompt Injection

User input manipulates model to ignore instructions
Example: User input contains "Ignore previous instructions and do X instead"
Mitigation: Separate user input from instructions, use Bedrock Guardrails

Prompt Poisoning

Malicious training data influences model behavior
Can cause model to generate harmful content
Mitigation: Curate training data, use content filtering

Prompt Hijacking

Adversarial prompts override intended behavior
Similar to injection but more sophisticated
Mitigation: Input validation, output filtering, Bedrock Guardrails

Jailbreaking

Bypassing model safety restrictions through clever prompts
Tricks model into generating prohibited content
Mitigation: Robust safety training, content filters, human review for high-risk applications

Fine-Tuning Foundation Models

Key Elements of Training

Pre-training

Train on massive, general corpus (books, websites, code)
Creates foundation model with broad knowledge
Most expensive phase

Fine-tuning

Adapt to specific tasks or domains
Uses much smaller, task-specific dataset
Cheaper than pre-training

Continuous Pre-training

Continue pre-training on domain-specific unlabeled data
Use when you have large domain corpus but no labeled data
Example: Medical literature for healthcare model

Fine-Tuning Methods

Instruction Tuning

Train model to follow instructions better
Dataset: instruction-response pairs
Improves zero-shot task performance

Domain Adaptation

Specialize model for specific field (legal, medical, financial)
Uses domain-specific texts and terminology
Improves accuracy in specialized contexts

Transfer Learning

Leverage knowledge from pre-trained model for new task
Much faster than training from scratch
Foundation of all fine-tuning approaches

RLHF (Reinforcement Learning from Human Feedback)

Train model using human preference rankings
Humans rate model outputs; model learns preferred responses
Improves helpfulness, harmlessness, honesty

Fine-Tuning Data Preparation

Data Curation

Select high-quality, relevant examples
Remove duplicates, errors, and biases
Ensure data represents real use cases

Data Governance

Track data lineage and sources
Implement access controls
Maintain compliance with regulations

Data Size Requirements

Fine-tuning: 100-10,000+ examples depending on task
Continuous pre-training: Millions of tokens
More data generally improves quality (with diminishing returns)

Data Labeling

Accurate labels critical for supervised fine-tuning
Consider inter-annotator agreement
Use multiple labelers for quality assurance

Data Representativeness

Cover diverse scenarios and edge cases
Balanced across categories (don't over-represent one class)
Match production data distribution

RLHF Data Collection

Collect human preferences on model outputs
Rank responses by quality/helpfulness
Requires clear evaluation guidelines for annotators

Evaluating Foundation Models

Human Evaluation

Experts manually assess model outputs
Rate on dimensions: accuracy, relevance, helpfulness, safety
Gold standard but expensive and slow
Use for final evaluation and quality spot-checks

Benchmark Datasets

Standardized test sets for comparing models
Examples: MMLU (general knowledge), HumanEval (code), TruthfulQA (truthfulness)
Enable objective comparisons across models

Automated Metrics

ROUGE (Recall-Oriented Understudy for Gisting Evaluation)

Measures overlap between generated and reference summaries
ROUGE-1: unigram overlap, ROUGE-2: bigram overlap, ROUGE-L: longest common subsequence
Higher scores = better match to reference
Use for summarization tasks

BLEU (Bilingual Evaluation Understudy)

Measures n-gram precision against reference translations
Originally for machine translation
Score 0-1 (or 0-100%), higher is better
Use for translation and text generation tasks

BERTScore

Computes semantic similarity using BERT embeddings
Better captures meaning than ROUGE/BLEU word overlap
More robust to paraphrasing
Use when semantic equivalence matters more than exact wording

Business Objective Evaluation

Productivity Metrics

Time saved per task
Tasks completed per hour
Automation rate (percentage of tasks fully automated)

User Engagement Metrics

Daily/monthly active users
Session duration
Feature adoption rate
User retention

Task Completion Metrics

Success rate of AI-assisted tasks
Error rate requiring human intervention
Time to resolution

Financial Metrics

Cost per interaction
Revenue impact
Customer lifetime value improvement
Return on AI investment

Domain 3 Quick Reference

Top Takeaways:

RAG grounds model responses in your data without expensive fine-tuning
Temperature=0 for consistency, temperature=1 for creativity, 0.3-0.7 for balance
Cost hierarchy: In-context learning < RAG < Fine-tuning < Pre-training
Chain-of-thought prompting improves reasoning by showing steps
Vector databases enable semantic search - choose based on other data needs

Critical Services:

RAG → Bedrock Knowledge Bases
Vector storage → OpenSearch, Aurora, Neptune, DocumentDB, RDS PostgreSQL
AI agents → Bedrock Agents
Pre-trained models → SageMaker JumpStart

Fine-Tuning vs RAG:

Use RAG when: Need current data, data changes frequently, want flexibility
Use fine-tuning when: Need specialized behavior, have large labeled dataset, willing to invest in training

Evaluation Metrics:

Summarization → ROUGE
Translation → BLEU
Semantic similarity → BERTScore
General quality → Human evaluation

Quick Decisions:

Need consistent outputs? → Temperature=0
Need creative responses? → Temperature=0.7-1.0
Need to reference your docs? → RAG with Bedrock Knowledge Bases
Need specialized domain knowledge? → Fine-tune
Need multi-step automation? → Bedrock Agents
Need vector search? → Choose DB based on data type (graph→Neptune, structured→Aurora, search→OpenSearch)

AWS Certified AI Practitioner