Generative AI: Large Language Models, GPT, and Prompt Engineering

Introduction

What is Generative AI?

• Content Creation: Generates new, original content
• Learning from Data: Trained on vast datasets
• Pattern Recognition: Identifies patterns in training data
• Creative Output: Produces human-like creative content

• Text Generation: GPT, Claude, Llama
• Image Generation: DALL-E, Midjourney, Stable Diffusion
• Code Generation: GitHub Copilot, Codex
• Audio Generation: MusicLM, AudioLM
• Video Generation: Runway, Pika

• Content creation and writing
• Code generation and assistance
• Conversational AI and chatbots
• Creative design and art
• Data analysis and insights
• Language translation
• Summarization and extraction

Large Language Models (LLMs)

• Transformer Architecture: Uses attention mechanisms
• Pre-training: Trained on vast text corpora
• Fine-tuning: Adapted for specific tasks
• Inference: Generates text based on prompts

• GPT (OpenAI): GPT-3.5, GPT-4, GPT-4 Turbo
• Claude (Anthropic): Claude 2, Claude 3
• Llama (Meta): Llama 2, Llama 3
• Gemini (Google): Gemini Pro, Gemini Ultra
• Mistral: Mistral 7B, Mixtral

• Text Generation: Creative writing, content creation
• Question Answering: Information retrieval and synthesis
• Code Generation: Programming assistance
• Translation: Multi-language support
• Summarization: Condensing long texts
• Reasoning: Complex problem solving

Understanding GPT Models

• GPT-1: First transformer-based language model
• GPT-2: Improved generation capabilities
• GPT-3: Breakthrough in few-shot learning
• GPT-3.5: Enhanced with instruction following
• GPT-4: Multimodal capabilities, improved reasoning
• GPT-4 Turbo: Faster, more efficient version

python
# Using OpenAI Python SDK
from openai import OpenAI

client = OpenAI(api_key='your-api-key')

# Text completion
response = client.chat.completions.create(
    model='gpt-4',
    messages=[
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': 'Explain quantum computing in simple terms'}
    ],
    temperature=0.7,
    max_tokens=500
)

print(response.choices[0].message.content)

javascript
// Using OpenAI Node.js SDK
const OpenAI = require('openai');

const openai = new OpenAI({
    apiKey: process.env.OPENAI_API_KEY
});

async function generateText(prompt) {
    const completion = await openai.chat.completions.create({
        model: 'gpt-4',
        messages: [
            { role: 'system', content: 'You are a helpful assistant.' },
            { role: 'user', content: prompt }
        ],
        temperature: 0.7,
        max_tokens: 500
    });
    
    return completion.choices[0].message.content;
}

// Usage
const response = await generateText('Explain machine learning');
console.log(response);

Prompt Engineering

• Be Specific: Clear, detailed instructions
• Provide Context: Include relevant background
• Use Examples: Few-shot learning with examples
• Iterate: Refine prompts based on results
• Structure: Use clear formatting and structure

python
# Simple prompt
prompt = "Write a blog post about Python programming"

# Better prompt with context
prompt = """
Write a technical blog post about Python programming.
Target audience: Intermediate developers
Length: 1000 words
Topics to cover: Best practices, common pitfalls, performance tips
Tone: Professional but accessible
"""

python
# Few-shot prompt with examples
prompt = """
Classify the sentiment of the following text as positive, negative, or neutral:

Text: "I love this product!"
Sentiment: positive

Text: "This is terrible."
Sentiment: negative

Text: "The weather is okay today."
Sentiment: neutral

Text: "This movie was amazing!"
Sentiment:
"""

python
# Chain-of-thought reasoning
prompt = """
Solve this math problem step by step:

Problem: If a train travels 120 miles in 2 hours, how fast is it going?

Let's think step by step:
1. The train travels 120 miles
2. It takes 2 hours
3. Speed = Distance / Time
4. Speed = 120 miles / 2 hours
5. Speed = 60 miles per hour

Answer: 60 miles per hour

Now solve: If a car travels 180 miles in 3 hours, how fast is it going?

Let's think step by step:
"""

python
# System prompt for role definition
messages = [
    {
        'role': 'system',
        'content': 'You are an expert Python developer with 10 years of experience. Provide clear, concise, and practical code examples.'
    },
    {
        'role': 'user',
        'content': 'How do I implement a decorator in Python?'
    }
]

Advanced Prompting Techniques

python
prompt = """
You are a senior software architect with expertise in microservices.
Your task is to design a scalable architecture for an e-commerce platform.
Consider: scalability, reliability, performance, and cost.
"""

python
# Reusable prompt template
def create_code_review_prompt(code, language):
    return f"""
Review the following {language} code and provide:
1. Code quality assessment
2. Potential bugs or issues
3. Performance improvements
4. Best practices suggestions

Code:
```{language}
{code}

**3. Iterative Refinement:**
```python
# First attempt
prompt1 = "Write a function to sort a list"

# Refined prompt
prompt2 = """
Write a Python function to sort a list of integers in ascending order.
Requirements:
- Use merge sort algorithm
- Handle edge cases (empty list, single element)
- Include type hints
- Add docstring
- Return sorted list
"""

python
prompt = """
Generate a product description for a wireless headphone.
Constraints:
- Maximum 100 words
- Include: features, benefits, target audience
- Use persuasive language
- No technical jargon
- Focus on user experience
"""

Building AI Applications with LLMs

python
# Simple chatbot with OpenAI
from openai import OpenAI
import streamlit as st

client = OpenAI(api_key=st.secrets['OPENAI_API_KEY'])

st.title('AI Chatbot')

# Initialize chat history
if 'messages' not in st.session_state:
    st.session_state.messages = [
        {'role': 'system', 'content': 'You are a helpful assistant.'}
    ]

# Display chat history
for message in st.session_state.messages[1:]:
    with st.chat_message(message['role']):
        st.markdown(message['content'])

# User input
if prompt := st.chat_input('What would you like to know?'):
    st.session_state.messages.append({'role': 'user', 'content': prompt})
    
    with st.chat_message('user'):
        st.markdown(prompt)
    
    # Get AI response
    response = client.chat.completions.create(
        model='gpt-4',
        messages=st.session_state.messages
    )
    
    assistant_message = response.choices[0].message.content
    st.session_state.messages.append({
        'role': 'assistant',
        'content': assistant_message
    })
    
    with st.chat_message('assistant'):
        st.markdown(assistant_message)

python
# Code generation function
def generate_code(description, language='python'):
    prompt = f"""
    Generate {language} code based on the following description:
    
    Description: {description}
    
    Requirements:
    - Write clean, well-documented code
    - Include error handling
    - Add type hints
    - Follow best practices
    - Include example usage
    """
    
    response = client.chat.completions.create(
        model='gpt-4',
        messages=[
            {'role': 'system', 'content': 'You are an expert software developer.'},
            {'role': 'user', 'content': prompt}
        ],
        temperature=0.3
    )
    
    return response.choices[0].message.content

# Usage
code = generate_code('A function to calculate fibonacci numbers')
print(code)

python
# Text summarization
def summarize_text(text, max_length=200):
    prompt = f"""
    Summarize the following text in approximately {max_length} words:
    
    {text}
    
    Summary:
    """
    
    response = client.chat.completions.create(
        model='gpt-4',
        messages=[
            {'role': 'user', 'content': prompt}
        ],
        max_tokens=max_length
    )
    
    return response.choices[0].message.content

Fine-Tuning LLMs

• Domain-Specific: Need specialized knowledge
• Custom Format: Specific output format required
• Consistency: Need consistent style or tone
• Cost Optimization: Reduce API costs with smaller models

python
# Prepare training data
# Format: JSONL with prompt-completion pairs
training_data = [
    {
        'prompt': 'What is Python?',
        'completion': 'Python is a high-level programming language...'
    },
    # More examples...
]

# Save to JSONL file
import json
with open('training_data.jsonl', 'w') as f:
    for item in training_data:
        f.write(json.dumps(item) + '\n')

# Upload to OpenAI
from openai import OpenAI
client = OpenAI()

# Upload file
file = client.files.create(
    file=open('training_data.jsonl', 'rb'),
    purpose='fine-tune'
)

# Create fine-tuning job
job = client.fine_tuning.jobs.create(
    training_file=file.id,
    model='gpt-3.5-turbo'
)

# Check status
status = client.fine_tuning.jobs.retrieve(job.id)
print(status.status)

python
# Use fine-tuned model
response = client.chat.completions.create(
    model='ft:gpt-3.5-turbo:your-org:custom-model:abc123',
    messages=[
        {'role': 'user', 'content': 'Your prompt'}
    ]
)

LLM Parameters and Configuration

• Temperature: Controls randomness (0.0-2.0)
  • Lower (0.0-0.3): More deterministic, focused
  • Higher (0.7-2.0): More creative, diverse
• Max Tokens: Maximum length of response
• Top P: Nucleus sampling (0.0-1.0)
• Frequency Penalty: Reduces repetition (-2.0 to 2.0)
• Presence Penalty: Encourages new topics (-2.0 to 2.0)

python
# Deterministic output (for code, facts)
response = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': prompt}],
    temperature=0.2,  # Low temperature for consistency
    max_tokens=500,
    top_p=0.9
)

# Creative output (for writing, brainstorming)
response = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': prompt}],
    temperature=0.9,  # High temperature for creativity
    max_tokens=1000,
    frequency_penalty=0.5,  # Reduce repetition
    presence_penalty=0.3  # Encourage new topics
)

Cost Optimization and Best Practices

• Use GPT-3.5-turbo for simple tasks
• Use GPT-4 for complex reasoning
• Consider open-source models for cost savings

• Keep prompts concise but clear
• Use system messages effectively
• Cache common prompts

python
# Estimate tokens (roughly 4 characters = 1 token)
def estimate_tokens(text):
    return len(text) // 4

# Truncate if needed
def truncate_to_tokens(text, max_tokens):
    max_chars = max_tokens * 4
    return text[:max_chars]

python
# Cache common responses
from functools import lru_cache
import hashlib

@lru_cache(maxsize=100)
def get_cached_response(prompt_hash):
    # Check cache first
    pass

def hash_prompt(prompt):
    return hashlib.md5(prompt.encode()).hexdigest()

python
# Stream responses for better UX
stream = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': prompt}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end='')

Open-Source LLMs

• Llama 2/3 (Meta): Strong performance, commercial use allowed
• Mistral: Efficient, fast inference
• Falcon: High-quality, open-source
• Vicuna: Fine-tuned Llama for conversations
• Code Llama: Specialized for code generation

python
# Using Hugging Face Transformers
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

# Load model
model_name = 'meta-llama/Llama-2-7b-chat-hf'
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map='auto'
)

# Generate text
prompt = 'Explain machine learning'
inputs = tokenizer(prompt, return_tensors='pt')
outputs = model.generate(
    inputs.input_ids,
    max_length=200,
    temperature=0.7
)

generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(generated_text)

python
# Install: pip install ollama
import ollama

# Generate text
response = ollama.generate(
    model='llama2',
    prompt='Explain quantum computing'
)

print(response['response'])

AI Safety and Ethics

• Test for bias in outputs
• Use diverse training data
• Monitor for discriminatory content

python
# Content filtering
response = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': user_input}],
    moderation=True  # Enable content moderation
)

• Don't send sensitive data to APIs
• Use data anonymization
• Implement proper access controls

• Disclose AI usage to users
• Provide source attribution
• Explain limitations

• Review AI outputs
• Implement human-in-the-loop
• Set up monitoring and alerts

Real-World Applications

• Blog posts and articles
• Social media content
• Marketing copy
• Product descriptions

• Code generation
• Bug fixing
• Code review
• Documentation generation

• Chatbots
• FAQ automation
• Ticket routing
• Response generation

• Tutoring systems
• Content generation
• Quiz creation
• Personalized learning

• Report generation
• Data summarization
• Insight extraction
• Trend analysis

• Story writing
• Poetry generation
• Script writing
• Creative brainstorming

Conclusion

Share this article

Comments