Chapitre 2 : Histoire - Des RNN aux Transformers

Introduction

Le parcours vers les modèles de langage de grande taille modernes s'étend sur des décennies de recherche en réseaux neuronaux et en traitement du langage naturel. Comprendre cette histoire nous aide à apprécier pourquoi l'architecture Transformer a été une telle avancée.

L'ère pré-neuronale (années 1950-2000)

Systèmes basés sur des règles

Les premiers systèmes de traitement du langage naturel reposaient sur des règles conçues à la main :

SI l'entrée contient "météo" ET "demain"
ALORS rechercher dans la base de données météo pour demain
RETOURNER la réponse météo formatée

Limitations :

• Incapacité à gérer la variabilité du langage
• Nécessitait une ingénierie manuelle extensive
• Mauvaise généralisation

Modèles de langage statistiques

L'approche statistique modélisait le langage comme des distributions de probabilités :

$$P(w_1, w_2, ..., w_n) = \prod_{i=1}^{n} P(w_i | w_1, ..., w_{i-1})$$

Modèles N-gram :

# Exemple de modèle bigramme
bigram_counts = {
    ("le", "chat"): 100,
    ("le", "chien"): 80,
    ("chat", "assis"): 50,
}

# P("chat" | "le") = count("le chat") / count("le")

Limitations :

• Rareté des données pour des contextes plus longs
• Pas de compréhension sémantique
• Vocabulaire fixe

La révolution neuronale (années 2000-2017)

Modèles de langage neuronaux à propagation avant (2003)

Bengio et al. ont introduit les modèles de langage neuronaux :

[w_{t-3}] [w_{t-2}] [w_{t-1}]
    ↓         ↓         ↓
[Embedding] [Embedding] [Embedding]
         ↘     ↓     ↙
        [Hidden Layer]
              ↓
        [Softmax Output]
              ↓
           P(w_t)

Innovation clé : Représentations distribuées apprises (embeddings)

Réseaux neuronaux récurrents (RNN)

Les RNN ont introduit le concept de mémoire à travers la récurrence :

class SimpleRNN:
    def forward(self, x, h_prev):
        """
        x: entrée actuelle
        h_prev: état caché précédent
        """
        h_new = tanh(W_xh @ x + W_hh @ h_prev + b)
        return h_new

Architecture :

h_0 → [RNN] → h_1 → [RNN] → h_2 → [RNN] → h_3
        ↑            ↑            ↑
       x_1          x_2          x_3

Problèmes :

• Gradients évanescents : Les signaux diminuent sur de longues séquences
• Traitement séquentiel : Impossible de paralléliser l'entraînement

Mémoire à long court terme (LSTM) - 1997

Hochreiter & Schmidhuber ont conçu les LSTM pour résoudre les gradients évanescents :

class LSTMCell:
    def forward(self, x, h_prev, c_prev):
        # Porte d'oubli
        f = sigmoid(W_f @ [h_prev, x] + b_f)
        
        # Porte d'entrée
        i = sigmoid(W_i @ [h_prev, x] + b_i)
        
        # Valeurs candidates
        c_tilde = tanh(W_c @ [h_prev, x] + b_c)
        
        # Mettre à jour l'état de la cellule
        c = f * c_prev + i * c_tilde
        
        # Porte de sortie
        o = sigmoid(W_o @ [h_prev, x] + b_o)
        h = o * tanh(c)
        
        return h, c

Composants clés :

Porte	Objectif
Porte d'oubli	Ce qu'il faut retirer de la mémoire
Porte d'entrée	Quelles nouvelles informations stocker
Porte de sortie	Ce qu'il faut sortir de la mémoire

Séquence à séquence (2014)

Sutskever et al. ont introduit les architectures encodeur-décodeur :

Encodeur :                    Décodeur :
"Hello world" → [LSTM] → Vecteur de contexte → [LSTM] → "Bonjour monde"

Limitation : Goulot d'étranglement du vecteur de contexte unique

Mécanisme d'attention (2014-2015)

Bahdanau et al. ont introduit l'attention pour résoudre le goulot d'étranglement :

$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$

def attention(query, keys, values):
    """
    query: ce que nous recherchons
    keys: ce que chaque position offre
    values: contenu réel à chaque position
    """
    scores = query @ keys.T / sqrt(d_k)
    weights = softmax(scores)
    output = weights @ values
    return output

Idée clé : Permettre au modèle d'apprendre quelles parties de l'entrée sont pertinentes pour chaque sortie.

La révolution Transformer (2017)

"Attention Is All You Need"

Vaswani et al. ont proposé de supprimer entièrement la récurrence :

Article clé

"Attention Is All You Need" (2017)

• Auteurs : Vaswani, Shazeer, Parmar, Uszkoreit, Jones, Gomez, Kaiser, Polosukhin
• Introduction de l'architecture Transformer
• Permet une parallélisation massive
• Fondation de tous les LLM modernes

Aperçu de l'architecture Transformer

Tokens d'entrée
     ↓
[Embedding + Encodage positionnel]
     ↓
┌─────────────────────────────┐
│   Attention multi-têtes     │
│         ↓                   │
│   Ajouter & Normaliser      │
│         ↓                   │
│   Réseau à propagation avant│
│         ↓                   │
│   Ajouter & Normaliser      │
└─────────────────────────────┘ × N couches
     ↓
Probabilités de sortie

Pourquoi les Transformers ont gagné

Caractéristique	RNN/LSTM	Transformer
Parallélisation	Séquentiel	Entièrement parallèle
Dépendances à long terme	Difficile	Attention directe
Vitesse d'entraînement	Lente	Rapide
Évolutivité	Limitée	Excellente

L'ère GPT (2018-Présent)

GPT-1 (2018)

Premier "Generative Pre-trained Transformer" d'OpenAI :

• 117M paramètres
• Paradigme de pré-entraînement + ajustement fin
• Architecture uniquement décodeur

# Architecture GPT-1 (simplifiée)
class GPT1:
    def __init__(self):
        self.layers = 12
        self.heads = 12
        self.d_model = 768
        self.vocab_size = 40478

BERT (2018)

Approche bidirectionnelle de Google :

• 340M paramètres (BERT-Large)
• Architecture uniquement encodeur
• Modélisation de langage masqué

# Objectif de pré-entraînement BERT
def masked_lm_loss(input_ids, model):
    # Masquer aléatoirement 15% des tokens
    masked_input = mask_tokens(input_ids, mask_prob=0.15)
    
    # Prédire les tokens originaux
    predictions = model(masked_input)
    
    # Perte uniquement sur les positions masquées
    return cross_entropy(predictions[masked_positions], 
                        input_ids[masked_positions])

GPT-2 (2019)

Augmentation de l'échelle et démonstration de capacités émergentes :

• 1.5B paramètres
• Performance de tâche en zéro-shot
• Initialement retenu en raison de préoccupations d'utilisation abusive

GPT-3 (2020)

L'échelle qui a tout changé :

• 175B paramètres
• Apprentissage en contexte
• Prompting en few-shot

# Échelle GPT-3
gpt3_config = {
    "n_params": 175_000_000_000,
    "n_layers": 96,
    "d_model": 12288,
    "n_heads": 96,
    "context_length": 2048,
}

L'ère moderne (2022-Présent)

Modèle	Année	Paramètres	Innovation clé
ChatGPT	2022	~175B	RLHF pour l'alignement
GPT-4	2023	~1.8T*	Multimodal, MoE*
Claude 2/3	2023-24	Inconnu	IA constitutionnelle
Llama 2	2023	7B-70B	Poids ouverts
Mistral	2023	7B	Architecture efficace

*Estimé/non confirmé

Visualisation de la chronologie

Pourquoi l'histoire compte

Comprendre cette évolution nous aide à :

1. Apprécier les décisions de conception dans les architectures modernes
2. Reconnaître les schémas qui mènent aux percées
3. Anticiper les directions futures basées sur les tendances
4. Déboguer et améliorer les systèmes actuels

Points clés à retenir

Résumé

1. Les RNN ont introduit la modélisation de séquence mais ne pouvaient pas être parallélisés
2. Les LSTM ont résolu les gradients évanescents mais sont restés séquentiels
3. L'attention a permis de se concentrer sur les entrées pertinentes
4. Les Transformers ont supprimé la récurrence, permettant une échelle massive
5. L'échelle s'est avérée être un ingrédient clé pour l'émergence de capacités

Regard vers l'avenir

Dans le prochain chapitre, nous examinerons le paysage actuel des modèles de langage de grande taille, en explorant les principaux acteurs, leurs modèles, et le débat en cours entre les approches open-source et propriétaires.

---

← Chapitre 1 : Que sont les LLM ?

Chapitre 3 : Paysage des LLM →