Foundation Models

Un foundation model (modèle de fondation) est un grand réseau de neurones entraîné sur une énorme quantité de données générales (texte du web, livres, code, parfois images et audio), avec un objectif très simple et sans étiquettes humaines, puis adapté à de nombreuses tâches. Le terme vient d'un rapport du centre CRFM de Stanford (2021). GPT, Llama, Claude, Mistral, Gemini sont des foundation models.

Trois idées résument tout le domaine, et ce cours les déroule dans l'ordre :

1. Une architecture générale et parallélisable : le Transformer (Parties II à IV).
2. Un objectif auto-supervisé appliqué à grande échelle : prédire le token suivant d'un texte. C'est le pretraining (Partie V). Les étiquettes sont gratuites : le texte lui-même fournit la « bonne réponse ».
3. Une adaptation du modèle de base vers un usage : fine-tuning supervisé, RLHF, DPO, LoRA (Partie VII).

Prérequis : ce qu'il faut savoir avant de commencer

Comment travailler ce cours

Chaque bloc indique ses prérequis internes (les blocs à avoir lus avant). Lisez le cours, regardez les deux schémas, refaites l'exemple du cours à la main, puis l'exemple inventé, puis faites le TP sans regarder la solution. Cochez le bloc quand le TP fonctionne : votre progression est gardée dans ce navigateur.

Environnement : Python 3.10 ou plus, puis pip install numpy torch matplotlib. Un GPU n'est pas nécessaire : le mini-GPT du TP final tourne sur un CPU en une quinzaine de minutes.

GPT-3 (OpenAI, 2020) est l'exemple de référence. Ses chiffres permettent de situer l'échelle :

• 175 milliards de paramètres ($1,75\times {10}^{11}$), 96 couches Transformer, dimension cachée 12 288.
• Environ 300 milliards de tokens d'entraînement.
• Calcul total environ $6\times N\times D=6\times 1,75\cdot {10}^{11}\times 3\cdot {10}^{11}\approx 3,15\cdot {10}^{23}$ opérations flottantes (la formule $6ND$ est démontrée au bloc 5.2).

Le même modèle, sans réentraînement, savait traduire, résumer ou répondre à des questions simplement en recevant quelques exemples dans son prompt. C'est cette polyvalence acquise par le seul pretraining qui justifie le mot « fondation ».

Imaginez un modèle entraîné uniquement à compléter des partitions : on lui montre des millions de morceaux, note par note, et on lui demande à chaque fois « quelle note vient ensuite ? ». Personne ne lui explique l'harmonie. Pourtant, pour bien prédire, il doit apprendre que telle note appartient à la gamme, qu'une cadence se résout sur la tonique, qu'un refrain revient. Ce modèle est un « foundation model musical » : on peut ensuite l'adapter pour harmoniser une mélodie, proposer une ligne de basse ou générer une batterie, avec très peu de données supplémentaires. C'est exactement le principe des LLM, appliqué au texte.

Objectif : vérifier l'environnement et vos prérequis.

1. Installez les paquets puis exécutez le script ci-dessous. Il doit afficher les versions et un tenseur.
2. Sans ordinateur : calculez $\ln (e^3)$, ${\log }_{2}8$, la dérivée de $3x^2+2x$, et $\sum _{i=1}^4{i}^2$.
3. Écrivez une fonction Python moyenne(liste) sans utiliser sum.

import sys, numpy as np, torch
print("Python", sys.version.split()[0], "| numpy", np.__version__, "| torch", torch.__version__)
x = torch.arange(6, dtype=torch.float32).reshape(2, 3)
print(x, x.shape)
print("GPU disponible :", torch.cuda.is_available())

def moyenne(liste):
    total = 0.0
    for v in liste:
        total += v
    return total / len(liste)

print(moyenne([2, 4, 9]))  # 5.0

Un modèle de type GPT (« decoder-only ») est l'empilement suivant :

1. Entrée : indices de tokens $(B,T)$.
2. Embeddings : $E[\text{ids}]$ $(B,T,d)$, plus l'embedding de position (appris dans GPT-2) ; avec RoPE, rien n'est ajouté ici.
3. $L$ blocs Transformer (bloc DL 23.2), avec masque causal.
4. Normalisation finale.
5. Unembedding : logits $(B,T,V)$, souvent avec poids partagés $W_U=E^{\mathrm{\top }}$.
6. Perte à l'entraînement : cross-entropy entre les logits de la position $t$ et le token $x_{t+1}$ (bloc 3.2). Génération : on ne garde que les logits de la dernière position, on tire un token, on l'ajoute, on recommence (bloc 9.2).

Comptage des paramètres

Les lois d'échelle (bloc 5.2) utilisent souvent $N$ hors embeddings, soit $12L{d}^2$.

Comptage du calcul

Un paramètre utilisé dans un produit matriciel coûte 2 FLOPs par token (une multiplication, une addition). Donc :

(Le terme d'attention $2LTd$ provient des $4Td$ par bloc du bloc DL 23.2 comptés sur la moitié causale ; il est négligeable tant que $T\ll 6d$.) Le facteur 3 vient de la passe arrière qui coûte deux fois la passe avant (bloc DL 11.3). D'où la formule fondamentale du coût d'entraînement sur $D$ tokens : $\boxed{{\displaystyle C\approx 6ND}}$.

Quelques configurations réelles

Remarque : $d$ augmente avec $L$, et la dimension par tête reste souvent 64 ou 128.