GPT-4¶

Quick Facts¶

Attribute	Value
Released	March 2023
Organization	OpenAI
Architecture	Decoder-only Transformer (estimated 1-2T MoE)
Context Window	8K (base), 32K (turbo), 128K (turbo extended)
Training Data	Text from internet (cutoff varies)
Multimodal	Vision (GPT-4V/GPT-4o)
API Status	Available via OpenAI API
License	Closed (API-only)
Cost	$0.03 input / $0.06 output per 1K tokens

-

Model Variants¶

GPT-4¶

Context: 8K tokens
Performance: SOTA on most benchmarks
Cost: High ($0.06/1K output)
Availability: Limited

GPT-4 Turbo (Latest)¶

Context: 128K tokens
Performance: Equal or better than base
Cost: Lower ($0.01 input / $0.03 output)
Knowledge Cutoff: April 2024

GPT-4V (Vision)¶

Capabilities: Analyze images natively
Examples: Charts, diagrams, screenshots, photos
Cost: Same as GPT-4
Context: 128K with images

GPT-4o (Optimized - 2024)¶

Capabilities: Native multimodal (text + image)
Performance: Better than GPT-4
Cost: Much lower ($0.005 input / $0.015 output)
Speed: 2x faster than GPT-4
Context: 128K tokens

Architecture (Estimated)¶

Public Information:
 - Decoder-only transformer
 - Mixture of Experts (likely)
 - Estimated 1-2 trillion parameters
 - Trained on 100s of billions tokens
 - RLHF alignment
 - Constitutional AI approach

What OpenAI Reveals:
 - Increased robustness
 - Better instruction following
 - Reduced hallucinations
 - Extended reasoning
 - Improved creativity

What's Hidden:
 - Exact parameter count
 - Model size
 - Training data specifics
 - Architecture modifications
 - Training techniques

-

Capabilities¶

Excellence Areas¶

Reasoning Can handle complex multi-step logic
Coding 91% on HumanEval
Mathematics Can solve competition problems
Writing Creative and coherent
Analysis Understands nuance
Vision Excellent image understanding
Long Context Handles 128K tokens
Instruction Follows guidelines precisely

Benchmark Performance¶

Metric GPT-4 Human Level Ranking
─────────────────────────────────────────────
MMLU 86.5% ~95% 1st/2nd
HumanEval 92.3% ~90% 1st
GSM8K 92% ~99% 1st/2nd
ARC Challenge 96.3% ~80% 1st
HellaSwag 97.5% ~80% 1st
GPQA (expert) 84.9% ~76% 1st

-

Real-World Examples¶

Example 1: Code Generation¶

import openai

client = openai.OpenAI(api_key="sk-...")

# Complex coding task
response = client.chat.completions.create(
 model="gpt-4",
 messages=[{
 "role": "user",
 "content": """
 Write a Python function that:
 1. Reads a CSV file
 2. Groups by column A
 3. Calculates mean of column B per group
 4. Exports to new CSV
 Optimize for memory and speed.
 """
 }]
)

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

Output: Produces production-ready code with optimizations, error handling, and comments.

Example 2: Legal Document Analysis¶

# Analyze complex legal document (128K context)

legal_doc = open("50_page_contract.txt").read()

response = client.chat.completions.create(
 model="gpt-4-turbo",
 messages=[{
 "role": "user",
 "content": f"""
 Analyze this contract and identify:
 1. Key terms and conditions
 2. Potential risks
 3. Unusual clauses
 4. Recommendations

 Contract:
 {legal_doc}
 """
 }]
)

Capability: GPT-4 Turbo handles full contract (60K+ tokens) and provides nuanced analysis.

Example 3: Vision Understanding¶

# GPT-4V

from pathlib import Path
import base64

def encode_image(image_path):
 with open(image_path, "rb") as image_file:
 return base64.b64encode(image_file.read()).decode('utf-8')

base64_image = encode_image("dashboard.png")

response = client.chat.completions.create(
 model="gpt-4-vision-preview",
 messages=[{
 "role": "user",
 "content": [
 {"type": "text", "text": "What issues do you see in this dashboard?"},
 {
 "type": "image_url",
 "image_url": {"url": f"data:image/png;base64,{base64_image}"}
 }
]
 }]
)

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

Output: Identifies UI issues, inconsistencies, and improvements.

Example 4: Multi-Step Reasoning¶

# Chain-of-Thought with GPT-4

response = client.chat.completions.create(
 model="gpt-4",
 messages=[{
 "role": "user",
 "content": """
 I have a box. Inside the box is a smaller box.
 Inside the smaller box is an even smaller box.
 I take out the smallest box.
 How many boxes remain in the original box?

 Let me think through this step by step.
 """
 }],
 temperature=0.7 # Allow reasoning
)

# GPT-4 correctly reasons through nested boxes

Example 5: Function Calling (Tool Use)¶

# GPT-4 decides when to use tools

tools = [
 {
 "type": "function",
 "function": {
 "name": "search_database",
 "description": "Search customer database",
 "parameters": {
 "type": "object",
 "properties": {
 "customer_id": {"type": "string"},
 "name": {"type": "string"}
 }
 }
 }
 },
 {
 "type": "function",
 "function": {
 "name": "calculate_discount",
 "description": "Calculate volume discount",
 "parameters": {
 "type": "object",
 "properties": {
 "purchase_amount": {"type": "number"},
 "customer_tier": {"type": "string"}
 }
 }
 }
 }
]

response = client.chat.completions.create(
 model="gpt-4",
 messages=[{
 "role": "user",
 "content": "Find customer John Smith and calculate his discount for $5000 purchase"
 }],
 tools=tools,
 tool_choice="auto"
)

# GPT-4 calls search_database, then calculate_discount automatically

Performance Comparison: GPT-4 vs Alternatives¶

comparison = {
 "GPT-4": {
 "Quality": 9.5, # Highest
 "Speed": 4, # Slow (API latency)
 "Cost": 1, # Most expensive
 "Availability": "API",
 "LocalDeployment": False,
 "Reasoning": 9.5,
 "Coding": 9.5
 },

 "Claude 3 Opus": {
 "Quality": 9.0,
 "Speed": 4.5,
 "Cost": 2,
 "Availability": "API",
 "LocalDeployment": False,
 "Reasoning": 9.0,
 "Coding": 8.5
 },

 "Llama 70B": {
 "Quality": 8.3,
 "Speed": 8, # Much faster (local)
 "Cost": 8, # Very cheap
 "Availability": "Weights",
 "LocalDeployment": True,
 "Reasoning": 8.0,
 "Coding": 8.0
 },

 "GPT-3.5": {
 "Quality": 7.0,
 "Speed": 9,
 "Cost": 8,
 "Availability": "API",
 "LocalDeployment": False,
 "Reasoning": 6.5,
 "Coding": 6.5
 }
}

-

Pricing Deep Dive¶

GPT-4 (Original - High Cost)¶

Input: $0.03 per 1K tokens
Output: $0.06 per 1K tokens

Example: 100K input + 50K output
Cost = (100 × $0.03) + (50 × $0.06) = $6.00

GPT-4 Turbo (Better Value)¶

Input: $0.01 per 1K tokens (67% cheaper)
Output: $0.03 per 1K tokens (50% cheaper)

Same example: 100K input + 50K output
Cost = (100 × $0.01) + (50 × $0.03) = $2.50 (58% savings!)

GPT-4o (Production Optimized)¶

Input: $0.005 per 1K tokens (83% cheaper than base)
Output: $0.015 per 1K tokens (75% cheaper)

Same example: 100K input + 50K output
Cost = (100 × $0.005) + (50 × $0.015) = $1.25 (79% savings!)

When GPT-4 ROI is Positive¶

# Calculate break-even point

def calculate_roi(task_complexity, volume, save_per_quality_win):
 """
 task_complexity: 1-10 (how hard to do well)
 volume: requests/month
 save_per_quality_win: $ saved by better quality
 """

 # Cost difference
 gpt4_monthly = volume * 0.03 # Approximate
 gpt35_monthly = volume * 0.0005 # Much cheaper
 extra_cost = gpt4_monthly - gpt35_monthly

 # Quality advantage
 gpt4_quality_edge = task_complexity * 0.01 # 1-10% edge
 monthly_savings = volume * gpt4_quality_edge * save_per_quality_win

 # ROI
 roi = monthly_savings / extra_cost if extra_cost > 0 else float('inf')

 return {
 "extra_cost": extra_cost,
 "monthly_savings": monthly_savings,
 "roi": roi,
 "verdict": "Use GPT-4" if roi > 1.0 else "Use GPT-3.5"
 }

# Complex reasoning task, 10K requests/month, $20 value per good answer
result = calculate_roi(task_complexity=9, volume=10000, save_per_quality_win=20)
# verdict

# Simple classification, 100K requests/month, $0.50 value
result = calculate_roi(task_complexity=2, volume=100000, save_per_quality_win=0.50)
# verdict

-

Best Practices¶

Use GPT-4 When¶

Complex Reasoning
Multi-step problem solving
Requires deep understanding
Expert-level analysis
High-Value Tasks
Each response worth $10+
Quality directly impacts revenue
Mistakes are costly
Creative Work
Content creation
Code generation
Strategic planning
Legal/Medical/Finance
Accuracy critical
Liability concerns
Complex domain knowledge

Use GPT-3.5 When¶

High Volume
1M+ requests/month
Cost becomes dominant factor
GPT-3.5 "good enough"
Simple Tasks
Classification
Summarization
Simple Q&A
Real-Time Apps
Need fast response (<100ms)
User experience critical
Latency matters more than quality

Use GPT-4o When¶

Production Deployment
Better performance than GPT-4
2x cheaper
New default for most use cases
Multimodal Needs
Vision understanding required
Better than GPT-4V
Native image support

Limitations & Challenges¶

Known Issues¶

Hallucinations: 2-5% of responses contain fabricated information
Knowledge Cutoff: Limited to training data cutoff (April 2024)
Math Errors: Complex arithmetic occasionally wrong
Reasoning Loops: May get stuck in circular reasoning
Token Limit: Even 128K can be limiting for complex tasks

Mitigations¶

# 1. Reduce hallucinations with RAG
context = retrieve_from_knowledge_base(query)
response = gpt4(f"Based on:\n{context}\n\nQuestion: {query}")

# 2. Break complex tasks into steps
steps = gpt4("Break down this task into steps")
results = [gpt4(f"Step {i}: {step}") for i, step in enumerate(steps)]

# 3. Use verification
answer = gpt4(query)
verification = gpt4(f"Is this answer correct? {answer}")

# 4. Temperature control
# Lower temperature = more deterministic (fewer errors)
response = client.chat.completions.create(
 model="gpt-4",
 temperature=0.2, # Less random, fewer hallucinations
 messages=[...]
)

Current Status (2024-2025)¶

Market Position¶

Still leading on most benchmarks Best-in-class reasoning Face strong competition (Claude 3, Llama 3 405B) Increasingly expensive relative to alternatives

Trends¶

Moving toward specialized models (reasoning, vision, etc.)
o1 line emerging for reasoning-focused tasks
GPT-4o becoming the new standard
Deprecating older variants (discontinuing GPT-4)

Future Direction¶

Better reasoning models (o1, o2)
More efficient variants (GPT-4o mini)
Enhanced vision capabilities
Real-time streaming
More granular control and customization

-

Integration Checklist¶

[] Create OpenAI account and API key
[] Install OpenAI Python library: pip install openai
[] Set API key: openai.api_key = "sk-..."
[] Test with simple prompt
[] Implement error handling (rate limits, timeouts)
[] Set up monitoring and logging
[] Configure temperature/parameters for your use case
[] Implement caching to reduce costs
[] Add function calling if needed
[] Test vision capabilities if multimodal

-

References¶

-

Last Updated: 2026-08-09

Current Status: GPT-4o is the new production standard Recommendation: Use GPT-4o for most new projects (better quality + cost)