Aller au contenu
Hacktion Wiki IA

Generative Pre-trained Transformer (GPT)

Ce que vous saurez dans 3 minutes

GPT (Generative Pre-trained Transformer) est l’architecture qui a fait passer le NLP (Traitement du Langage Naturel) de l’ère artisanale à l’ère industrielle. Contrairement à BERT qui cherche à comprendre le contexte global (Encodeur), GPT est un “perroquet stochastique” de génie : il ne regarde que le passé pour prédire le futur (Décodeur). Cette simplicité, couplée à une échelle massive, a donné naissance à ChatGPT.

1. Comprendre

Définition & Acronyme

L’Architecture “Decoder-Only”

Le Transformer original avait deux parties : un Encodeur (pour lire/traduire) et un Décodeur (pour générer). GPT a fait le pari radical de jeter l’Encodeur.

  • L’Intuition : Imaginez que vous lisiez un livre avec un cache qui masque tout ce qui suit le mot actuel. Vous devez deviner le mot suivant uniquement grâce aux mots précédents. C’est ce que fait GPT. C’est un modèle auto-régressif.
  • Masked Self-Attention : Le mécanisme clé qui empêche le modèle de “tricher” en regardant la fin de la phrase pendant l’entraînement.

La Saga des Versions (Mermaid)

timeline
    title Évolution de la Puissance de Calcul
    2018 : GPT-1 <br> (117 Millions params) <br> Preuve de concept
    2019 : GPT-2 <br> (1.5 Milliards params) <br> "Trop dangereux"
    2020 : GPT-3 <br> (175 Milliards params) <br> Few-Shot Learning
    2023 : GPT-4 <br> (1.76 Trillions params est.) <br> MoE + Multimodal

2. Appliquer

Les Mathématiques de la Prédiction

GPT modélise la probabilité d’une séquence de mots x = (x1, ..., xn) comme le produit des probabilités conditionnelles :

P(x) = \prod_{i=1}^{n} P(x_i | x_1, ..., x_{i-1})

Pour chaque mot xi, il regarde tout l’historique (x1 à xi-1) et calcule une distribution de probabilité sur tout le vocabulaire (environ 50 000 tokens) pour choisir le suivant.

Implémentation PyTorch (NanoGPT)

Voici le cœur d’un bloc GPT (Decoder Layer) simplifié. Remarquez le tril (mask) qui assure la causalité.

import torch
import torch.nn as nn
from torch.nn import functional as F


class CausalSelfAttention(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.c_attn = nn.Linear(config.n_embd, 3 * config.n_embd, bias=False)
        self.c_proj = nn.Linear(config.n_embd, config.n_embd, bias=False)
        # Le masque causal : empêche de voir le futur
        self.register_buffer("bias", torch.tril(torch.ones(config.block_size, config.block_size))
                                    .view(1, 1, config.block_size, config.block_size))


    def forward(self, x):
        B, T, C = x.size() # Batch, Time (Sequence Length), Channels (Embeddings)


        # Calcul Query, Key, Value
        q, k, v  = self.c_attn(x).split(config.n_embd, dim=2)


        # Attention Score avec Masking (Causalité)
        att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))
        att = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf')) # Le masque magique
        att = F.softmax(att, dim=-1)


        y = att @ v # Agrégation des valeurs
        return self.c_proj(y)

Le Pipeline d’Entraînement Moderne

Comment passe-t-on d’un modèle brut à ChatGPT ?

  1. Pré-entraînement (Pre-training)

    • Tâche : Prédire le mot suivant sur des téraoctets de texte (Common Crawl, Wikipedia, GitHub).
    • Résultat : Un “Base Model” très intelligent mais incontrôlable (il complète “La liste des courses :” par ”… est sur la table” ou par une liste, on ne sait pas).

  2. Supervised Fine-Tuning (SFT)

    • Tâche : On donne des exemples de questions/réponses de qualité écrits par des humains.
    • Résultat : Un modèle qui comprend le format “Instruction/Réponse”.

  3. RLHF (Reinforcement Learning from Human Feedback)

    • Tâche : Des humains classent plusieurs réponses du modèle de la meilleure à la pire. On entraîne un “Reward Model” pour simuler ce jugement.
    • Résultat : Un modèle “aligné”, poli et utile (type ChatGPT).

3. Aller plus loin

Le “Scaling Law”

La découverte majeure d’OpenAI (Kaplan et al., 2020) est la loi d’échelle : La performance (perte test) diminue (s’améliore) de manière prévisible en loi de puissance (power law) si on augmente :

  1. La taille du modèle (N)
  2. La taille du dataset (D)
  3. La puissance de calcul (C)

C’est cette équation qui a justifié les investissements de milliards de dollars dans GPT-4.

Limites de l’Architecture

  • Fenêtre de Contexte finie : Bien que portée à 128k (GPT-4) ou 1M (Gemini), l’attention quadratique (N²) rend le traitement de livres entiers très coûteux.
  • Hallucinations : Comme le modèle est probabiliste et n’a pas de concept de “vérité”, il invente des faits plausibles pour combler les trous.
  • Manque de rétro-action : Contrairement aux humains qui peuvent réfléchir avant de parler, GPT génère token par token sans pouvoir corriger une erreur passée (sauf via Chain-of-Thought).

Questions Fréquentes

GPT raisonne-t-il vraiment ?

C’est le grand débat. Techniquement, il ne fait que de la complétion statistique. Cependant, pour prédire correctement la fin d’un roman policier ou résoudre un problème de math, il semble construire une “représentation du monde” interne qui s’apparente à du raisonnement. On parle de capacités émergentes.

GPT vs BERT : Lequel choisir ?
  • Pour la génération de texte (Chatbot, Email, Code) -> GPT.
  • Pour la classification ou l’analyse (Sentiment, Extraction d’entités) -> BERT (car il lit le contexte gauche ET droite).

Notions Liées (Spider Web)

  • L’Inventeur : Transformer (L’architecture mère).
  • L’Alternative : BERT (Le cousin Encodeur).
  • La Technique : Few-Shot Learning (La capacité magique de GPT-3).
  • L’Entreprise : OpenAI.

Ressources Externes