Transformers & Large Language Models

The Transformer Revolution

Transformers, introduced in 2017 with the paper "Attention Is All You Need," revolutionized AI by replacing recurrent networks with attention mechanisms. This architecture became the foundation for modern large language models like GPT, BERT, and beyond.

Attention Mechanism: The Core Concept

Multi-Head Attention Implementation

// Simplified Multi-Head Attention
class MultiHeadAttention {
  constructor(numHeads, dModel) {
    this.numHeads = numHeads;
    this.dModel = dModel;
    this.dHead = dModel / numHeads;
    
    // Initialize weight matrices (simplified)
    this.Wq = this.initWeights(dModel, dModel); // Query
    this.Wk = this.initWeights(dModel, dModel); // Key
    this.Wv = this.initWeights(dModel, dModel); // Value
    this.Wo = this.initWeights(dModel, dModel); // Output
  }

  initWeights(rows, cols) {
    return Array(rows).fill(0).map(() =>
      Array(cols).fill(0).map(() => Math.random() * 0.02 - 0.01)
    );
  }

  // Matrix multiplication
  matmul(A, B) {
    const result = [];
    for (let i = 0; i < A.length; i++) {
      result[i] = [];
      for (let j = 0; j < B[0].length; j++) {
        let sum = 0;
        for (let k = 0; k < B.length; k++) {
          sum += A[i][k] * B[k][j];
        }
        result[i][j] = sum;
      }
    }
    return result;
  }

  // Scaled dot-product attention
  attention(Q, K, V) {
    const dK = K[0].length;
    const scale = Math.sqrt(dK);
    
    // Calculate attention scores: QK^T / sqrt(d_k)
    const scores = [];
    for (let i = 0; i < Q.length; i++) {
      scores[i] = [];
      for (let j = 0; j < K.length; j++) {
        let score = 0;
        for (let k = 0; k < Q[i].length; k++) {
          score += Q[i][k] * K[j][k];
        }
        scores[i][j] = score / scale;
      }
    }
    
    // Softmax to get attention weights
    const weights = scores.map(row => this.softmax(row));
    
    // Weighted sum of values
    return this.matmul(weights, V);
  }

  softmax(arr) {
    const max = Math.max(...arr);
    const exps = arr.map(x => Math.exp(x - max));
    const sum = exps.reduce((a, b) => a + b, 0);
    return exps.map(x => x / sum);
  }

  // Forward pass
  forward(X) {
    // X: [seq_len, d_model]
    // 1. Linear projections
    const Q = this.matmul(X, this.Wq);
    const K = this.matmul(X, this.Wk);
    const V = this.matmul(X, this.Wv);
    
    // 2. Split into multiple heads (conceptual)
    // In practice, reshape and process heads in parallel
    
    // 3. Apply attention
    const attnOutput = this.attention(Q, K, V);
    
    // 4. Concatenate heads and apply output projection
    const output = this.matmul(attnOutput, this.Wo);
    
    return output;
  }

  visualize() {
    console.log("Multi-Head Attention Mechanism:
");
    console.log("┌────────────────────┐");
    console.log("│   Input Sequence   │");
    console.log("└───────┬────────────┘");
    console.log("       │");
    console.log("   ┌───┼───┐");
    console.log("   │   │   │");
    console.log("  Query Key Value");
    console.log("   │   │   │");
    console.log("   └───┬───┘");
    console.log("       │");
    console.log(" ┌─────┴─────┐");
    console.log(" │ Attention  │");
    console.log(" │ Mechanism  │");
    console.log(" └─────┬─────┘");
    console.log("       │");
    console.log("   Output");
    console.log("
Key Points:");
    console.log("- Number of heads: " + this.numHeads + "");
    console.log("- Model dimension: " + this.dModel + "");
    console.log("- Head dimension: " + this.dHead + "");
    console.log("- Each head learns different relationships");
  }
}

// Example
const attention = new MultiHeadAttention(8, 512);
attention.visualize();

// Simulated input sequence (3 words, 512-dim embeddings)
const sequence = [
  Array(512).fill(0).map(() => Math.random() * 0.1),
  Array(512).fill(0).map(() => Math.random() * 0.1),
  Array(512).fill(0).map(() => Math.random() * 0.1)
];

console.log("
Processing sequence...");
const output = attention.forward(sequence);
console.log("Input shape: [" + sequence.length + ", " + sequence[0].length + "]");
console.log("Output shape: [" + output.length + ", " + output[0].length + "]");

Transformer Architecture

Large Language Models (LLMs)

How LLMs Are Trained

// Simplified LLM Training Pipeline
class LLMTraining {
  constructor() {
    this.stages = [
      {
        name: "Pre-training",
        description: "Train on massive text corpora",
        objective: "Next token prediction",
        data: "Books, websites, code (billions of tokens)",
        duration: "Weeks/months on thousands of GPUs",
        cost: "Millions of dollars"
      },
      {
        name: "Supervised Fine-tuning",
        description: "Fine-tune on high-quality examples",
        objective: "Learn desired behavior",
        data: "Curated question-answer pairs",
        duration: "Days",
        cost: "Thousands of dollars"
      },
      {
        name: "RLHF (Reinforcement Learning from Human Feedback)",
        description: "Align model with human preferences",
        objective: "Maximize human satisfaction",
        data: "Human ratings of model outputs",
        duration: "Days/weeks",
        cost: "Thousands to millions"
      }
    ];
  }

  describeTraining() {
    console.log("LLM Training Pipeline:
");
    this.stages.forEach((stage, i) => {
      console.log("=== Stage " + i + 1 + ": " + stage.name + " ===");
      console.log("Description: " + stage.description + "");
      console.log("Objective: " + stage.objective + "");
      console.log("Data: " + stage.data + "");
      console.log("Duration: " + stage.duration + "");
      console.log("Cost: " + stage.cost + "");
      console.log("");
    });
  }

  // Token prediction example
  nextTokenPrediction(context, vocabulary) {
    console.log("Next Token Prediction Example:");
    console.log("Context: "" + context + """);
    console.log("
Model predicts probability distribution:");
    
    // Simulated probabilities
    const predictions = [
      { token: "learning", prob: 0.45 },
      { token: "language", prob: 0.25 },
      { token: "models", prob: 0.15 },
      { token: "systems", prob: 0.10 },
      { token: "other", prob: 0.05 }
    ];
    
    predictions.forEach(pred => {
      const bar = "█".repeat(Math.floor(pred.prob * 50));
      console.log("  " + pred.token.padEnd(15) + " " + bar + " " + (pred.prob * 100).toFixed(1) + "%");
    });
    
    const chosen = predictions[0].token;
    console.log("
Model chooses: "" + chosen + """);
    console.log("Updated context: "" + context + " " + chosen + """);
  }
}

const trainer = new LLMTraining();
trainer.describeTraining();
trainer.nextTokenPrediction("Artificial intelligence and machine", []);

Prompting Techniques for LLMs

Prompt: Classify the sentiment:
"This movie was amazing!"

Response: Positive

Examples:
"Great film!" -> Positive
"Terrible acting." -> Negative

"This movie was amazing!"
Response: Positive

Problem: If a store has 15 apples
and sells 7, then buys 12 more,
how many apples are there?

Let's think step by step:
1. Start: 15 apples
2. After selling: 15 - 7 = 8
3. After buying: 8 + 12 = 20

Answer: 20 apples

You are an expert Python developer.
Explain list comprehensions to a
beginner.

[Response would be tailored to
expert developer perspective]

LLM Applications & Use Cases