# LLM capabilities
capabilities = {
    'text_generation': 'Generate coherent text',
    'question_answering': 'Answer questions based on context',
    'summarization': 'Summarize long documents',
    'translation': 'Translate between languages',
    'code_generation': 'Write and explain code',
    'reasoning': 'Perform logical reasoning',
    'few_shot_learning': 'Learn from examples',
}

# LLM limitations
limitations = {
    'hallucination': 'Generate false information',
    'context_window': 'Limited input length',
    'knowledge_cutoff': 'Training data has cutoff date',
    'bias': 'Reflect biases in training data',
    'reasoning': 'Struggle with complex logic',
    'real_time': 'Cannot access real-time information',
}

# Simplified transformer architecture
class TransformerLLM:
    def __init__(self, vocab_size, d_model, num_layers, num_heads):
        self.vocab_size = vocab_size
        self.d_model = d_model
        self.num_layers = num_layers
        self.num_heads = num_heads
    
    def forward(self, input_ids):
        """
        1. Embedding: Convert tokens to vectors
        2. Positional encoding: Add position information
        3. Transformer blocks: Self-attention + Feed-forward
        4. Output layer: Convert to logits
        """
        # Embedding
        embeddings = self.embedding(input_ids)
        
        # Add positional encoding
        embeddings = embeddings + self.positional_encoding(input_ids)
        
        # Transformer blocks
        for layer in range(self.num_layers):
            embeddings = self.transformer_block(embeddings)
        
        # Output layer
        logits = self.output_layer(embeddings)
        
        return logits

from openai import OpenAI

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

# Simple completion
response = client.chat.completions.create(
    model='gpt-4',
    messages=[
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': 'What is machine learning?'}
    ],
    temperature=0.7,
    max_tokens=500
)

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

# Streaming response
stream = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': 'Write a poem about Python'}],
    stream=True
)

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

from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
import torch

# Text generation pipeline
generator = pipeline('text-generation', model='gpt2')
result = generator('The future of AI is', max_length=50)
print(result[0]['generated_text'])

# Question answering
qa_pipeline = pipeline('question-answering')
context = "Machine learning is a subset of artificial intelligence."
question = "What is machine learning?"
result = qa_pipeline(question=question, context=context)
print(f"Answer: {result['answer']}")

# Summarization
summarizer = pipeline('summarization')
text = """
Machine learning is a subset of artificial intelligence that focuses on
the development of algorithms and statistical models that enable computers
to improve their performance on tasks through experience.
"""
summary = summarizer(text, max_length=30, min_length=10)
print(summary[0]['summary_text'])

# Load custom model
tokenizer = AutoTokenizer.from_pretrained('gpt2')
model = AutoModelForCausalLM.from_pretrained('gpt2')

# Generate text
input_ids = tokenizer.encode('Hello', return_tensors='pt')
output = model.generate(input_ids, max_length=50)
text = tokenizer.decode(output[0])
print(text)

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory

# Initialize LLM
llm = OpenAI(temperature=0.7)

# Create prompt template
prompt = PromptTemplate(
    input_variables=['topic'],
    template='Write a short essay about {topic}'
)

# Create chain
chain = LLMChain(llm=llm, prompt=prompt)

# Run chain
result = chain.run(topic='artificial intelligence')
print(result)

# Conversation with memory
memory = ConversationBufferMemory()

conversation = LLMChain(
    llm=llm,
    prompt=PromptTemplate(
        input_variables=['history', 'input'],
        template='{history}\nUser: {input}\nAssistant:'
    ),
    memory=memory
)

# Multi-turn conversation
response1 = conversation.run(input='What is machine learning?')
response2 = conversation.run(input='Can you give an example?')

# Text generation
prompt = "Write a Python function that calculates factorial"
# LLM generates: def factorial(n): return 1 if n <= 1 else n * factorial(n-1)

# Question answering
prompt = "What is the capital of France?"
# LLM responds: "The capital of France is Paris."

# Summarization
prompt = "Summarize this article: [long article]"
# LLM provides concise summary

# Translation
prompt = "Translate to Spanish: Hello, how are you?"
# LLM responds: "Hola, ¿cómo estás?"

# Code explanation
prompt = "Explain this code: [code snippet]"
# LLM provides detailed explanation

# Reasoning
prompt = "If all birds can fly, and penguins are birds, can penguins fly?"
# LLM attempts logical reasoning

# Hallucination: Generating false information
prompt = "What is the population of Atlantis?"
# LLM might generate plausible-sounding but false answer

# Context window: Limited input length
# Most LLMs have 2K-100K token limits

# Knowledge cutoff: Training data has cutoff date
# Cannot know about events after training

# Bias: Reflects biases in training data
# May generate biased or stereotypical responses

# Reasoning: Struggles with complex logic
# May fail at multi-step reasoning

# Real-time: Cannot access current information
# Cannot browse internet or access real-time data

# Bad prompt
prompt = "Tell me about Python"

# Good prompt
prompt = """
You are an expert Python programmer. Explain Python's key features
for someone with no programming experience. Use simple language and
provide 2-3 practical examples. Keep response under 200 words.
"""

# Few-shot learning
prompt = """
Classify the sentiment of these reviews:

Review: "Great product, highly recommend!" 
Sentiment: Positive

Review: "Terrible quality, waste of money"
Sentiment: Negative

Review: "It's okay, nothing special"
Sentiment: ?
"""

# Chain-of-thought prompting
prompt = """
Solve this step by step:
Q: If a store has 50 apples and sells 30, then receives 20 more,
how many apples does it have?

Let me think through this:
1. Starting apples: 50
2. After selling 30: 50 - 30 = 20
3. After receiving 20: 20 + 20 = 40
Answer: 40
"""

# Temperature: Controls randomness
# Low (0.1): Deterministic, focused
# High (0.9): Creative, diverse

# Max tokens: Limit response length
# Affects cost and response time

# Top-p (nucleus sampling): Diversity control
# Selects from top p% of likely tokens

# Frequency penalty: Reduce repetition
# Higher values discourage repeated tokens

# Presence penalty: Encourage new topics
# Higher values encourage new topics

response = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': 'Write a story'}],
    temperature=0.8,
    max_tokens=500,
    top_p=0.9,
    frequency_penalty=0.5,
    presence_penalty=0.5
)

# Don't: Vague prompts
response = llm("Tell me about AI")

# Don't: Trust without verification
answer = llm("What is the capital of France?")
# Use answer without checking

# Don't: Ignore limitations
# Assume LLM can access real-time data

# Don't: No error handling
response = client.chat.completions.create(...)

# Do: Specific, detailed prompts
response = llm("""
Explain machine learning to a 10-year-old using simple language
and a real-world analogy. Keep response under 100 words.
""")

# Do: Verify important information
answer = llm("What is the capital of France?")
assert answer.lower() == "paris"

# Do: Acknowledge limitations
# Use LLM for creative tasks, not real-time facts

# Do: Handle errors
try:
    response = client.chat.completions.create(...)
except RateLimitError:
    print("Rate limited, retrying...")
except APIError as e:
    print(f"API error: {e}")