Chapitre 1 : Que sont les modèles de langage de grande taille ?

Introduction

Les modèles de langage de grande taille (LLM) représentent l'une des avancées les plus significatives en intelligence artificielle. Ces réseaux neuronaux massifs ont démontré des capacités remarquables dans la compréhension et la génération du langage humain, affichant souvent des comportements qui n'ont pas été explicitement programmés.

Définir les modèles de langage de grande taille

Le facteur d'échelle

Un modèle de langage de grande taille est un réseau neuronal entraîné sur d'énormes quantités de données textuelles, caractérisé par :

1. Nombre de paramètres : Des milliards à des trillions de paramètres entraînables
2. Données d'entraînement : Des téraoctets de texte provenant de sources diverses
3. Exigences de calcul : Des milliers d'heures GPU pour l'entraînement

# Comparaison des tailles de modèles (comptes de paramètres approximatifs)
model_sizes = {
    "BERT-base": "110M",
    "GPT-2": "1.5B", 
    "GPT-3": "175B",
    "GPT-4": "~1.8T (estimated)",
    "Llama-2-70B": "70B",
    "Claude-3": "Unknown (estimated >100B)"
}

Qu'est-ce qui les rend "grands" ?

Le terme "grand" se réfère à plusieurs dimensions :

Dimension	Petits modèles	Modèles de langage de grande taille
Paramètres	Millions	Milliards à Trillions
Données d'entraînement	Go	To à Po
Fenêtre de contexte	512 tokens	4K-128K+ tokens
Calcul d'entraînement	Jours GPU	Années GPU

Capacités principales

1. Génération de texte

Les LLM excellent dans la génération de texte cohérent et contextuellement approprié :

# Exemple : Complétion de texte
prompt = "L'architecture transformer a révolutionné le NLP parce que"
# LLM completion: "elle a permis le traitement parallèle des séquences 
# et capturé les dépendances à long terme plus efficacement que 
# les approches récurrentes."

2. Apprentissage en contexte

L'une des capacités les plus remarquables des LLM est l'apprentissage à partir d'exemples fournis dans le prompt :

# Exemple d'apprentissage par quelques exemples
prompt = """
Traduire l'anglais en français :
"Hello" -> "Bonjour"
"Thank you" -> "Merci"
"Good morning" -> """
# LLM output: "Bon matin" ou "Bonjour"

3. Raisonnement et résolution de problèmes

Les LLM modernes démontrent des capacités de raisonnement de base :

# Raisonnement en chaîne
prompt = """
Si un train voyage à 60 mph pendant 2,5 heures, 
quelle distance parcourt-il ?

Laissez-moi réfléchir étape par étape :
1. Distance = Vitesse × Temps
2. Vitesse = 60 mph
3. Temps = 2,5 heures
4. Distance = 60 × 2,5 = 150 miles

Réponse : 150 miles
"""

Capacités émergentes

Les capacités émergentes sont des capacités qui apparaissent uniquement lorsque les modèles atteignent une certaine échelle, absentes dans les modèles plus petits.

Exemples d'émergence

1. Raisonnement multi-étapes : Décomposer des problèmes complexes en étapes
2. Génération de code : Écrire des programmes fonctionnels à partir de descriptions
3. Traduction : Traduire entre les langues sans entraînement explicite
4. Suivi des instructions : Comprendre et exécuter des instructions complexes

L'hypothèse de l'échelle

La recherche a montré des relations prévisibles entre :

$$L(N) = \left(\frac{N_c}{N}\right)^{\alpha_N}$$

Où :

• $L$ = Perte (plus bas est mieux)
• $N$ = Nombre de paramètres
• $N_c, \alpha_N$ = Constantes déterminées empiriquement

Cela suggère que simplement augmenter l'échelle des modèles conduit à des améliorations prévisibles des capacités.

LLM vs. Modèles de langage traditionnels

Modèles de langage statistiques

Les modèles traditionnels estimaient les probabilités en utilisant des statistiques n-gram :

$$P(w_n | w_1, ..., w_{n-1}) \approx P(w_n | w_{n-k}, ..., w_{n-1})$$

Limitations :

• Fenêtre de contexte fixe
• Problèmes de données rares
• Pas de compréhension sémantique

Modèles de langage neuronaux (avant LLM)

Les approches neuronales antérieures utilisaient des RNN et des LSTM :

# Modèle de langage basé sur RNN (simplifié)
class RNNLanguageModel:
    def __init__(self, vocab_size, hidden_size):
        self.embedding = Embedding(vocab_size, hidden_size)
        self.rnn = RNN(hidden_size, hidden_size)
        self.output = Linear(hidden_size, vocab_size)
    
    def forward(self, x, hidden):
        embedded = self.embedding(x)
        output, hidden = self.rnn(embedded, hidden)
        return self.output(output), hidden

Limitations :

• Traitement séquentiel (entraînement lent)
• Gradients qui disparaissent
• Dépendances à long terme limitées

Modèles de langage de grande taille

Les LLM surmontent ces limitations grâce à :

1. Traitement parallèle : Les transformers traitent tous les tokens simultanément
2. Mécanisme d'attention : Connexions directes entre toutes les positions
3. Échelle : La capacité massive du modèle permet l'apprentissage de motifs complexes

Les éléments constitutifs des LLM

1. Tokenisation

Conversion du texte en représentations numériques :

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("gpt2")
text = "Les modèles de langage de grande taille sont fascinants !"
tokens = tokenizer.encode(text)
# [16902, 15417, 32329, 389, 21120, 0]

2. Embeddings

Représentations vectorielles denses des tokens :

# Chaque token est mappé à un vecteur de haute dimension
embedding_dim = 768  # Commun pour les modèles de base
# "The" -> [0.23, -0.45, 0.12, ..., 0.89]  # 768 valeurs

3. Couches de Transformer

Les unités de traitement principales :

Entrée → Embedding → [Bloc Transformer × N] → Sortie
                          ↓
                    Attention + FFN

4. Projection de sortie

Conversion des représentations internes en probabilités de vocabulaire :

$$P(w_i | context) = \text{softmax}(W_o \cdot h_i + b_o)$$

Exemple pratique : Comment les LLM génèrent du texte

def generate_text(model, tokenizer, prompt, max_tokens=50):
    """
    Génération de texte autoregressive simple
    """
    input_ids = tokenizer.encode(prompt, return_tensors="pt")
    
    for _ in range(max_tokens):
        # Obtenir les prédictions du modèle
        outputs = model(input_ids)
        next_token_logits = outputs.logits[:, -1, :]
        
        # Échantillonner le prochain token
        next_token = torch.argmax(next_token_logits, dim=-1)
        
        # Ajouter à la séquence
        input_ids = torch.cat([input_ids, next_token.unsqueeze(0)], dim=-1)
        
        # Arrêter si token EOS
        if next_token == tokenizer.eos_token_id:
            break
    
    return tokenizer.decode(input_ids[0])

Points clés à retenir

Points clés

1. Les LLM sont définis par l'échelle : milliards de paramètres, téraoctets de données d'entraînement
2. Les capacités émergentes apparaissent uniquement à une échelle suffisante
3. L'architecture Transformer permet un entraînement efficace et des dépendances à long terme
4. Génération autoregressive : Les LLM prédisent un token à la fois
5. Apprentissage en contexte : Les LLM peuvent apprendre à partir d'exemples dans le prompt

Perspectives

Dans le prochain chapitre, nous retracerons l'évolution historique des modèles de langage, des premiers réseaux neuronaux récurrents à l'architecture Transformer révolutionnaire qui a rendu possibles les LLM modernes.

---

← Aperçu du module

Chapitre 2 : Histoire →