Fonctionnement des LLM

┌─────────────────────────────────────────────────────────────┐
│                    PIPELINE LLM                              │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  Texte → Tokenizer → Embeddings → Transformer → Logits     │
│                                       ↓                      │
│                                   Sampling                   │
│                                       ↓                      │
│                                 Next Token                   │
│                                       ↓                      │
│                              Répéter jusqu'à                 │
│                              <end> ou max_tokens             │
│                                                              │
└─────────────────────────────────────────────────────────────┘

"Bonjour"     → 1 token
"anticonstitutionnellement" → 4+ tokens
"GPT-4"       → 3 tokens (G, PT, -4)
" "           → 1 token (espace)
"🎉"          → 1-2 tokens

1. Commencer avec des caractères individuels
2. Fusionner les paires les plus fréquentes
3. Répéter jusqu'à atteindre la taille de vocabulaire

"lower" + "lower" + "newest"
↓ Après BPE
["low", "er", "low", "er", "new", "est"]

"playing" → ["play", "##ing"]
Le ## indique une continuation

import tiktoken

encoder = tiktoken.encoding_for_model("gpt-4")
tokens = encoder.encode("Bonjour, comment allez-vous ?")
print(len(tokens))  # Nombre de tokens
print(tokens)       # IDs des tokens

# Vocabulaire de 100k tokens, dimension 4096
embedding_layer = nn.Embedding(100000, 4096)

# Token ID 15496 → Vecteur [4096]
token_id = torch.tensor([15496])
embedding = embedding_layer(token_id)
# Shape: [1, 4096]

Token Embedding  +  Position Embedding  =  Input Embedding
    [4096]       +       [4096]         =      [4096]

┌─────────────────────────────────┐
│       TRANSFORMER BLOCK          │
├─────────────────────────────────┤
│                                  │
│   Input                          │
│     ↓                            │
│   LayerNorm                      │
│     ↓                            │
│   Multi-Head Self-Attention      │
│     ↓                            │
│   + (Residual)                   │
│     ↓                            │
│   LayerNorm                      │
│     ↓                            │
│   Feed Forward (MLP)             │
│     ↓                            │
│   + (Residual)                   │
│     ↓                            │
│   Output                         │
│                                  │
└─────────────────────────────────┘

        × N couches (GPT-4: ~120)

Séquence : [Le, chat, dort]

Attention autorisée :
         Le   chat  dort
Le      [✓    ✗     ✗  ]
chat    [✓    ✓     ✗  ]
dort    [✓    ✓     ✓  ]

Prompt: "Le chat"

Étape 1: "Le chat" → modèle → "dort" (probabilité 0.23)
Étape 2: "Le chat dort" → modèle → "sur" (probabilité 0.31)
Étape 3: "Le chat dort sur" → modèle → "le" (probabilité 0.45)
...

next_token = logits.argmax()

logits = logits / temperature
probs = softmax(logits)

# temperature < 1 : plus déterministe
# temperature > 1 : plus aléatoire
# temperature = 0 : greedy

Temperature 0.1 : "Le chat dort sur le canapé."
Temperature 1.0 : "Le chat dort sur le rebord de la fenêtre."
Temperature 2.0 : "Le chat rêve d'aventures galactiques."

top_k_logits, top_k_indices = logits.topk(k=50)
probs = softmax(top_k_logits)
next_token = top_k_indices[torch.multinomial(probs, 1)]

# Si p=0.9, on garde les tokens représentant 90% de la masse de probabilité
sorted_probs = probs.sort(descending=True)
cumsum = sorted_probs.cumsum()
mask = cumsum <= p

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1000,      # Limite de tokens générés
    temperature=0.7,      # Créativité (0-1)
    top_p=0.9,           # Nucleus sampling
    top_k=50,            # Top-k sampling
    stop_sequences=["###"],  # Arrêter si rencontré
)

Objectif : Prédire le token suivant (Causal Language Modeling)

Loss = -log P(token_t | tokens_1...t-1)

GPT-3 175B : ~3,640 petaflop/s-days
           ≈ 1000 GPUs pendant 1 mois
           ≈ 4.6 millions $ (cloud)

GPT-4 :     ~100× GPT-3 (estimé)
           ≈ 100+ millions $

Loss ∝ C^(-0.05)  où C = compute (FLOPs)

Loi de Chinchilla (2022) :
- Tokens optimaux ≈ 20 × Paramètres
- LLaMA 7B → 140B tokens minimum

Sans cache : recalculer attention pour tous les tokens à chaque étape
Avec cache : réutiliser les KV, ne calculer que pour le nouveau token

Mémoire KV Cache = 2 × layers × batch × seq_len × d_model × precision

Couches 1-10   : Syntaxe, grammaire
Couches 10-30  : Sémantique, sens des mots
Couches 30-60  : Raisonnement, logique
Couches 60+    : Tâches de haut niveau

# Extraire les activations d'une couche
hidden_states = model(input_ids, output_hidden_states=True)
layer_20 = hidden_states.hidden_states[20]

# Entraîner un classifieur simple pour détecter
# si le modèle encode une information (ex: sentiment)
probe = nn.Linear(d_model, 2)

LLM = Tokenizer + Embeddings + Transformer + Sampling

Pipeline :
1. Texte → Tokens (BPE/WordPiece)
2. Tokens → Embeddings + Position
3. Embeddings → N × Transformer Blocks
4. Output → Logits → Softmax → Probabilités
5. Sampling (temperature, top-p, top-k)
6. Répéter jusqu'à fin

Caractéristiques clés :
├── Autorégressif (token par token)
├── Masque causal (ne voit pas le futur)
├── Contexte limité (mais croissant)
└── Pré-entraîné sur texte massif