Getting Started with GPT Models - Practical Guide
Learn how to work with GPT models step by step, from understanding concepts to building real applications
🤖 What is GPT?
GPT stands for Generative Pre-trained Transformer - let's break down what each part means:
text
🧠 GPT EXPLAINED STEP BY STEP 🧠
(Understanding Each Component)
┌─────────────────────────────────────────────────────────────────┐
│ 🔤 G = GENERATIVE │
│ "Creates New Text" │
└─────────────────────┬───────────────────────────────────────────┘
│
💭 INPUT: "Once upon a time"
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 🎯 GENERATION PROCESS │
│ │
│ Step 1: Read input → "Once upon a time" │
│ Step 2: Predict next word → "there" (probability: 0.4) │
│ Step 3: Add to sequence → "Once upon a time there" │
│ Step 4: Predict next word → "was" (probability: 0.6) │
│ Step 5: Continue → "Once upon a time there was..." │
│ │
│ 🔄 REPEAT until story is complete or max length reached │
└─────────────────────┬───────────────────────────────────────────┘
│
▼
📖 OUTPUT: "Once upon a time there was a brave knight who..."
┌─────────────────────────────────────────────────────────────────┐
│ 🎓 P = PRE-TRAINED │
│ "Already Educated" │
└─────────────────────┬───────────────────────────────────────────┘
│
📚 TRAINING DATA (What GPT learned from):
┌─────────────────────────────────────────────────────────────────┐
│ • Books & Literature (millions of texts) │
│ • Web Pages & Articles (billions of pages) │
│ • News & Journals (real-world knowledge) │
│ • Code Repositories (programming patterns) │
│ • Conversations & Forums (human dialogue) │
│ │
│ 🧠 RESULT: GPT "read" most of human written knowledge │
│ 💡 BENEFIT: You don't need to train it from scratch │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ ⚡ T = TRANSFORMER │
│ "The AI Architecture" │
└─────────────────────┬───────────────────────────────────────────┘
│
🏗️ ARCHITECTURE COMPONENTS:
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 🎯 ATTENTION MECHANISM │
│ "Focuses on important words in context" │
│ │
│ Example: "The cat that chased mice sat down" │
│ ├─────── ATTENTION ─────────┤ │
│ "cat" pays attention to "sat" (subject-verb) │
│ │
│ 🔄 SELF-ATTENTION LAYERS │
│ "Each word considers all other words simultaneously" │
│ │
│ 📊 FEED-FORWARD NETWORKS │
│ "Process and transform the understood meaning" │
│ │
│ 🎛️ MULTI-HEAD ATTENTION │
│ "Multiple 'attention heads' focus on different relationships" │
└─────────────────────────────────────────────────────────────────┘🎛️ Key Parameters for Controlling GPT Output
Understanding how to control GPT's behavior is crucial for getting the results you want:
🎲 Temperature - Controlling Creativity
text
🌡️ TEMPERATURE CONTROL GUIDE 🌡️
(Creativity vs Consistency)
❄️ LOW TEMPERATURE (0.0 - 0.3) 🔥 HIGH TEMPERATURE (0.7 - 1.0)
┌─────────────────────────────┐ ┌─────────────────────────────┐
│ "Conservative Mode" │ │ "Creative Mode" │
│ │ │ │
│ ✅ CHARACTERISTICS: │ │ ✅ CHARACTERISTICS: │
│ • Predictable outputs │ │ • Surprising outputs │
│ • Consistent responses │ │ • Varied responses │
│ • Focused & precise │ │ • Diverse & imaginative │
│ • Deterministic behavior │ │ • Random behavior │
│ │ │ │
│ 🎯 BEST FOR: │ │ 🎯 BEST FOR: │
│ • Technical documentation │ │ • Creative writing │
│ • Code generation │ │ • Brainstorming │
│ • Factual Q&A │ │ • Story generation │
│ • Formal writing │ │ • Poetry & art │
│ │ │ │
│ ⚠️ RISKS: │ │ ⚠️ RISKS: │
│ • Can be boring/repetitive │ │ • May be incoherent │
│ • Less creative solutions │ │ • Inconsistent facts │
└─────────────────────────────┘ └─────────────────────────────┘
│ │
▼ ▼
📝 Example Output: 📝 Example Output:
"The weather today is sunny "The weather today is a
and pleasant with clear skies." shimmering tapestry of golden
threads dancing across azure
canvas!"
⚖️ MIDDLE GROUND (0.4 - 0.6)
┌─────────────────────────────┐
│ "Balanced Mode" │
│ │
│ • Good mix of creativity │
│ and consistency │
│ • Suitable for most tasks │
│ • Recommended starting │
│ point │
└─────────────────────────────┘🪙 Tokens - Controlling Output Length
text
🎯 TOKEN MANAGEMENT GUIDE 🎯
(Controlling Response Length)
💰 WHAT ARE TOKENS?
┌─────────────────────────────────────────────────────────────────┐
│ Tokens are the "building blocks" of text that GPT understands │
│ │
│ 📝 TEXT: "Hello world!" │
│ 🔧 TOKENIZATION: │
│ "Hello world!" → ["Hello", " world", "!"] → [15496, 995, 0] │
│ │
│ 💡 RULE OF THUMB: │
│ • 1 token ≈ 4 characters in English │
│ • 1 token ≈ 0.75 words on average │
│ • 100 tokens ≈ 75 words ≈ 1-2 sentences │
└─────────────────────────────────────────────────────────────────┘
📊 TOKEN LIMITS FOR DIFFERENT OUTPUTS:
┌─────────────────────────────────────────────────────────────────┐
│ │
│ 🔥 SHORT & SNAPPY (10-50 tokens) │
│ • Quick answers │
│ • Headlines │
│ • Code snippets │
│ Example: "What is AI?" → "AI is artificial intelligence." │
│ │
│ 📝 MEDIUM RESPONSES (50-200 tokens) │
│ • Explanations │
│ • Summaries │
│ • Short paragraphs │
│ Example: Explaining a concept in 2-3 sentences │
│ │
│ 📚 LONG-FORM CONTENT (200-1000+ tokens) │
│ • Articles │
│ • Stories │
│ • Detailed analysis │
│ • Complete code functions │
│ Example: Writing a full blog post or tutorial │
│ │
│ ⚡ REAL-TIME CHAT (20-100 tokens) │
│ • Conversational responses │
│ • Quick back-and-forth │
│ • Instant assistance │
│ Example: Chatbot interactions │
└─────────────────────────────────────────────────────────────────┘💬 Message Roles - Structuring Conversations
Understanding message roles is key to getting GPT to behave exactly as you want:
text
👥 MESSAGE ROLE SYSTEM GUIDE 👥
(Teaching GPT How to Behave)
┌─────────────────────────────────────────────────────────────────┐
│ 🎯 SYSTEM MESSAGE │
│ "The Master Instructions" │
└─────────────────────┬───────────────────────────────────────────┘
│
🧠 PURPOSE: Sets the AI's personality, expertise, and behavior
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 📋 EXAMPLES OF SYSTEM MESSAGES: │
│ │
│ 🤖 HELPFUL ASSISTANT: │
│ "You are a helpful AI assistant. Be concise and accurate." │
│ │
│ 👨💻 CODE EXPERT: │
│ "You are a senior software engineer. Provide clean, │
│ well-commented code with best practices." │
│ │
│ 📚 TEACHER: │
│ "You are a patient teacher. Explain concepts step-by-step │
│ using simple language and examples." │
│ │
│ 🎭 CHARACTER: │
│ "You are a pirate captain. Speak in pirate language and │
│ share tales of the seven seas." │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 👤 USER MESSAGE │
│ "Your Input/Question" │
└─────────────────────┬───────────────────────────────────────────┘
│
💭 PURPOSE: Your actual question, request, or input to the AI
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 📝 EXAMPLES OF USER MESSAGES: │
│ │
│ ❓ QUESTIONS: │
│ "What is machine learning?" │
│ "How do I center a div in CSS?" │
│ │
│ 📋 REQUESTS: │
│ "Write a Python function to sort a list" │
│ "Explain quantum computing in simple terms" │
│ │
│ 🎯 TASKS: │
│ "Summarize this article..." │
│ "Translate this to Spanish..." │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 🤖 ASSISTANT MESSAGE │
│ "GPT's Response" │
└─────────────────────┬───────────────────────────────────────────┘
│
🎯 PURPOSE: The AI's response to your input
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ 💬 CONVERSATION FLOW EXAMPLE: │
│ │
│ 🎯 SYSTEM: "You are a helpful coding assistant." │
│ │
│ 👤 USER: "Write a Python function to add two numbers" │
│ │
│ 🤖 ASSISTANT: "def add_numbers(a, b): │
│ return a + b" │
│ │
│ 👤 USER: "Add error handling to this function" │
│ │
│ 🤖 ASSISTANT: "def add_numbers(a, b): │
│ try: │
│ return float(a) + float(b) │
│ except (ValueError, TypeError): │
│ return 'Invalid input types'" │
└─────────────────────────────────────────────────────────────────┘🛠️ Setting Up Your Development Environment
Let's set up everything you need to start working with GPT models:
📦 Required Packages Installation
First, let's install all the necessary packages for working with GPT and AI models:
python
# Install required packages
%pip install openai config langchain pydantic tiktoken faiss-cpu transformers torch datasets evaluate accelerate ipywidgets matplotlib seaborn clean-text scikit-learn sentencepiece pandasPackage Breakdown:
- openai: Official OpenAI/Azure OpenAI client
- langchain: Framework for building LLM applications
- pydantic: Data validation and parsing
- tiktoken: Tokenization library for OpenAI models
- transformers: Hugging Face transformers library
- torch: PyTorch for machine learning
- datasets: Hugging Face datasets library
- faiss-cpu: Vector similarity search
- ipywidgets: Interactive Jupyter widgets
- matplotlib/seaborn: Data visualization
- pandas: Data manipulation and analysis
🚀 Basic GPT Implementation
Let's start with a simple implementation to generate text:
🔧 Setting Up the Client
python
import openai
import config
from openai import AzureOpenAI
import json
from IPython.display import display, Markdown
# Azure OpenAI Configuration
subscription_key = "" # Add your subscription key here
endpoint = ""
model_name = "gpt-4.1-nano"
deployment = "gpt-4.1-nano"
api_version = "2024-12-01-preview"
# Initialize the client
client = AzureOpenAI(
api_version=api_version,
azure_endpoint=endpoint,
api_key=subscription_key,
)✨ Basic Text Generation
python
def generate_text(prompt, max_tokens=50, temperature=0.7):
"""
Generate text using GPT model
Args:
prompt (str): Input text to complete
max_tokens (int): Maximum number of tokens to generate
temperature (float): Controls randomness (0.0-1.0)
Returns:
str: Generated text
"""
response = client.chat.completions.create(
model=model_name,
messages=[{"role": "user", "content": prompt}],
max_tokens=max_tokens,
temperature=temperature,
)
# Optional: Save response for debugging
# with open("response.json", "w") as f:
# json.dump(response.model_dump(), f, indent=4)
return response.choices[0].message.content
# Example usage
prompt = "Once upon a time"
response = generate_text(prompt)
display(Markdown(f"**Generated Text:**\n\n{response}"))🎨 Customizing Output Parameters
python
def generate_custom_text(prompt, max_tokens=50, temperature=0.7):
"""
Generate text with customizable parameters
Parameters explained:
- max_tokens: Controls length (10=very short, 100=paragraph, 500=article)
- temperature: Controls creativity (0.1=conservative, 0.7=balanced, 0.9=creative)
"""
response = client.chat.completions.create(
model=model_name,
messages=[{"role": "user", "content": prompt}],
max_tokens=max_tokens,
temperature=temperature,
)
return response.choices[0].message.content
# Example: Creative storytelling
prompt = "Write a short story about a brave knight."
response = generate_custom_text(prompt, max_tokens=100, temperature=0.5)
display(Markdown(f"**Custom Generated Text:**\n\n{response}"))🎯 Practical Applications
📝 Text Summarization
Let's build a text summarization system using system messages to guide GPT's behavior:
python
def text_summarizer(text_to_summarize):
"""
Summarize text and extract keywords using GPT
Uses system message to provide context and examples
"""
response = client.chat.completions.create(
model=model_name,
messages=[
{
"role": "system",
"content": "You will be provided with a block of text, and your task is to extract a list of keywords from it."
},
{
"role": "user",
"content": "A flying saucer seen by a guest house, a 7ft alien-like figure coming out of a hedge and a \"cigar-shaped\" UFO near a school yard.\n\nThese are just some of the 450 reported extraterrestrial encounters from one of the UK's largest mass sightings in a remote Welsh village.\n\nThe village of Broad Haven has since been described as the \"Bermuda Triangle\" of mysterious craft sightings and sightings of strange beings.\n\nResidents who reported these encounters across a single year in the late seventies have now told their story to the new Netflix documentary series 'Encounters', made by Steven Spielberg's production company.\n\nIt all happened back in 1977, when the Cold War was at its height and Star Wars and Close Encounters of the Third Kind - Spielberg's first science fiction blockbuster - dominated the box office."
},
{
"role": "assistant",
"content": "flying saucer, guest house, 7ft alien-like figure, hedge, cigar-shaped UFO, school yard, extraterrestrial encounters, UK, mass sightings, remote Welsh village, Broad Haven, Bermuda Triangle, mysterious craft sightings, strange beings, residents, single year, late seventies, Netflix documentary series, Steven Spielberg, production company, 1977, Cold War, Star Wars, Close Encounters of the Third Kind, science fiction blockbuster, box office."
},
{
"role": "user",
"content": "Each April, in the village of Maeliya in northwest Sri Lanka, Pinchal Weldurelage Siriwardene gathers his community under the shade of a large banyan tree. The tree overlooks a human-made body of water called a wewa – meaning reservoir or \"tank\" in Sinhala. The wewa stretches out besides the village's rice paddies for 175-acres (708,200 sq m) and is filled with the rainwater of preceding months. \n\nSiriwardene, the 76-year-old secretary of the village's agrarian committee, has a tightly-guarded ritual to perform. By boiling coconut milk on an open hearth beside the tank, he will seek blessings for a prosperous harvest from the deities residing in the tree. \"It's only after that we open the sluice gate to water the rice fields,\" he told me when I visited on a scorching mid-April afternoon.\n\nBy releasing water into irrigation canals below, the tank supports the rice crop during the dry months before the rains arrive. For nearly two millennia, lake-like water bodies such as this have helped generations of farmers cultivate their fields. An old Sinhala phrase, \"wewai dagabai gamai pansalai\", even reflects the technology's centrality to village life; meaning \"tank, pagoda, village and temple\"."
},
{
"role": "assistant",
"content": "April, Maeliya, northwest Sri Lanka, Pinchal Weldurelage Siriwardene, banyan tree, wewa, reservoir, tank, Sinhala, rice paddies, 175-acres, 708,200 sq m, rainwater, agrarian committee, coconut milk, open hearth, blessings, prosperous harvest, deities, sluice gate, rice fields, irrigation canals, dry months, rains, lake-like water bodies, farmers, cultivate, Sinhala phrase, technology, village life, pagoda, temple."
},
{
"role": "user",
"content": text_to_summarize
}
],
temperature=0.5,
max_tokens=256
)
# Optional: Save detailed response for analysis
with open("text_summarization_response.json", "w") as f:
json.dump(response.model_dump(), f, indent=4)
return response.choices[0].message.content.strip()
# Example usage
sample_text = """Master Reef Guide Kirsty Whitman didn't need to tell me twice. Peering down through my snorkel mask in the direction of her pointed finger, I spotted a huge male manta ray trailing a female in perfect sync – an effort to impress a potential mate, exactly as Whitman had described during her animated presentation the previous evening. Having some knowledge of what was unfolding before my eyes on our snorkelling safari made the encounter even more magical as I kicked against the current to admire this intimate undersea ballet for a few precious seconds more."""
keywords = text_summarizer(sample_text)
print("Extracted Keywords:", keywords)🎯 Advanced Techniques
🔄 Conversation Management
python
class GPTConversation:
"""
Manage multi-turn conversations with GPT
"""
def __init__(self, system_message="You are a helpful assistant."):
self.messages = [{"role": "system", "content": system_message}]
self.client = client
def add_user_message(self, content):
"""Add a user message to the conversation"""
self.messages.append({"role": "user", "content": content})
def get_response(self, max_tokens=150, temperature=0.7):
"""Get GPT response and add it to conversation history"""
response = self.client.chat.completions.create(
model=model_name,
messages=self.messages,
max_tokens=max_tokens,
temperature=temperature,
)
assistant_message = response.choices[0].message.content
self.messages.append({"role": "assistant", "content": assistant_message})
return assistant_message
def clear_conversation(self, new_system_message=None):
"""Clear conversation history"""
if new_system_message:
self.messages = [{"role": "system", "content": new_system_message}]
else:
self.messages = self.messages[:1] # Keep only system message
# Example usage
chat = GPTConversation("You are a Python programming tutor. Help users learn coding step by step.")
# Multi-turn conversation
chat.add_user_message("How do I create a list in Python?")
response1 = chat.get_response()
print("Response 1:", response1)
chat.add_user_message("How do I add items to this list?")
response2 = chat.get_response()
print("Response 2:", response2)🎨 Specialized GPT Functions
python
def creative_writer_gpt(prompt, style="fantasy"):
"""Specialized function for creative writing"""
system_messages = {
"fantasy": "You are a fantasy novelist. Write in vivid, imaginative language with rich descriptions.",
"mystery": "You are a mystery writer. Create suspenseful, intriguing narratives with unexpected twists.",
"sci-fi": "You are a science fiction author. Incorporate futuristic concepts and technology.",
"romance": "You are a romance novelist. Focus on emotions, relationships, and heartfelt moments."
}
response = client.chat.completions.create(
model=model_name,
messages=[
{"role": "system", "content": system_messages.get(style, system_messages["fantasy"])},
{"role": "user", "content": prompt}
],
max_tokens=200,
temperature=0.8, # Higher creativity for storytelling
)
return response.choices[0].message.content
def technical_explainer_gpt(topic, audience="beginner"):
"""Specialized function for technical explanations"""
system_messages = {
"beginner": "You are a patient teacher. Explain technical concepts using simple language and analogies.",
"intermediate": "You are a technical instructor. Provide detailed explanations with examples.",
"expert": "You are a subject matter expert. Provide comprehensive, technical explanations."
}
prompt = f"Explain {topic} in a way that a {audience} can understand."
response = client.chat.completions.create(
model=model_name,
messages=[
{"role": "system", "content": system_messages.get(audience, system_messages["beginner"])},
{"role": "user", "content": prompt}
],
max_tokens=300,
temperature=0.3, # Lower for more precise technical content
)
return response.choices[0].message.content
# Examples
fantasy_story = creative_writer_gpt("A dragon discovers a hidden library", "fantasy")
print("Fantasy Story:", fantasy_story)
tech_explanation = technical_explainer_gpt("machine learning", "beginner")
print("Technical Explanation:", tech_explanation)🎓 Best Practices and Tips
✅ Do's
- Clear System Messages: Always provide clear instructions in system messages
- Appropriate Temperature: Use low temperature (0.1-0.3) for factual content, high (0.7-0.9) for creative tasks
- Token Management: Set appropriate token limits based on your use case
- Error Handling: Always include try-catch blocks for API calls
- Rate Limiting: Respect API rate limits to avoid throttling
❌ Don'ts
- Don't expose API keys: Keep your API keys secure and use environment variables
- Don't ignore token costs: Monitor your token usage to control costs
- Don't rely on perfect accuracy: Always validate GPT outputs for factual content
- Don't use maximum temperature: Very high temperature (>0.9) often produces nonsensical output
- Don't forget context limits: Most models have context length limits
🔧 Debugging Tips
python
def debug_gpt_response(prompt, save_full_response=True):
"""
Debug function that saves full response details
"""
response = client.chat.completions.create(
model=model_name,
messages=[{"role": "user", "content": prompt}],
max_tokens=100,
temperature=0.7,
)
if save_full_response:
debug_info = {
"prompt": prompt,
"model": model_name,
"full_response": response.model_dump(),
"token_usage": {
"prompt_tokens": response.usage.prompt_tokens,
"completion_tokens": response.usage.completion_tokens,
"total_tokens": response.usage.total_tokens
}
}
with open("debug_response.json", "w") as f:
json.dump(debug_info, f, indent=4)
return response.choices[0].message.content
# Use for debugging
debug_response = debug_gpt_response("Explain photosynthesis")
print("Debug Response:", debug_response)📚 Learning Path
- LLM Fundamentals: Understanding the foundation of Large Language Models
- Getting Started with GPT: Practical GPT implementation (you are here)
- Prompt Engineering: Advanced techniques for better results
- Fine-tuning: Customizing models for specific tasks
- RAG Systems: Combining LLMs with external knowledge
Next Steps:
- Prompt Engineering: Learn advanced prompting techniques
- NLP Fundamentals: Understand the underlying technology
- Vector Embeddings: Learn about semantic representations