Transformers y Modelos de Lenguaje a Gran Escala

La revolución Transformer

Los Transformers, introducidos en 2017 con el paper "Attention Is All You Need", revolucionaron la IA al reemplazar redes recurrentes por mecanismos de atención. Esta arquitectura se convirtió en la base de los modelos de lenguaje modernos como GPT, BERT y más.

Mecanismo de atención: el concepto central

Implementación de atención multi-cabeza

// 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 + "]");

Arquitectura Transformer

Modelos de lenguaje a gran escala (LLMs)

Cómo se entrenan los LLMs

// 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", []);

Técnicas de prompting para 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]

Aplicaciones y casos de uso de LLMs