Introduction aux LLM de bout en bout : de l'Architecture au Fine-Tuning

Introduction : Les LLM comme Moteurs de Développement

L'Intelligence Artificielle générative a dépassé le stade de la simple prouesse technique. En Afrique, elle représente un levier de développement massif. Qu'il s'agisse de déployer des diagnostics médicaux dans des déserts médicaux, de personnaliser l'éducation à grande échelle, ou de traduire des langues locales pour une inclusion numérique totale, les Large Language Models (LLM) sont l'infrastructure de demain.

Un LLM est un réseau de neurones profond paramétré avec des milliards de poids, conçu pour comprendre, générer et interagir avec le langage humain en prédisant de manière probabiliste la suite d'une séquence.

Pour transformer cette technologie en impact réel, il faut la maîtriser de bout en bout. Cet article déconstruit la complexité des LLM, de l'architecture fondamentale jusqu'à l'ajustement fin pour des cas d'usage métiers.

L'Architecture : La Révolution Transformer

L'écrasante majorité des LLM modernes (Llama, Mistral, GPT) reposent sur l'architecture Decoder-only du Transformer. Au lieu de traiter les données séquentiellement comme les anciens modèles RNN, le Transformer parallélise l'ingestion du contexte grâce au mécanisme d'Attention.

Mécanismes Mathématiques Internes

Au cœur du Transformer réside la Scaled Dot-Product Attention. Elle permet à chaque token de la séquence d'évaluer sa pertinence par rapport à tous les autres tokens précédents.

1. L'Attention

Les entrées sont projetées dans trois espaces vectoriels distincts : Query (Q), Key (K), et Value (V). L'attention est calculée par le produit scalaire entre Q et K, mis à l'échelle par la racine carrée de la dimension $d_k$, suivi d'une fonction d'activation.

Pour un token spécifique à la position $i$, la matrice d'attention pondère l'information tirée du vecteur de valeur $V_j$.

2. La fonction Softmax

La fonction Softmax transforme les scores bruts (logits) d'attention en une distribution de probabilité. Elle accentue les valeurs fortes et écrase les valeurs faibles.

Implémentation PyTorch (Multi-Head Attention)

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

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model: int, num_heads: int, dropout: float = 0.0):
        super().__init__()
        assert d_model % num_heads == 0
        self.d_model = d_model
        self.num_heads = num_heads
        self.d_k = d_model // num_heads

        self.W_qkv = nn.Linear(d_model, 3 * d_model, bias=False)
        self.out_proj = nn.Linear(d_model, d_model, bias=False)
        self.dropout = dropout

    def forward(self, x: torch.Tensor, mask: torch.Tensor = None) -> torch.Tensor:
        B, T, C = x.size()
        
        qkv = self.W_qkv(x).chunk(3, dim=-1)
        q, k, v = map(lambda t: t.view(B, T, self.num_heads, self.d_k).transpose(1, 2), qkv)

        y = F.scaled_dot_product_attention(
            q, k, v, 
            attn_mask=mask, 
            dropout_p=self.dropout if self.training else 0.0,
            is_causal=True if mask is None else False
        )

        y = y.transpose(1, 2).contiguous().view(B, T, C)
        return self.out_proj(y)
            

Le Cycle de Vie de l'Entraînement

Créer un modèle utile ne s'arrête pas à l'architecture. C'est un processus séquencé où l'on injecte la connaissance, puis on affine le comportement.

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

Le modèle ingère des téraoctets de données non structurées. L'objectif est simple : prédire le prochain token. Cette phase forge la compréhension du monde, la grammaire, et les bases logiques du modèle. La fonction d'optimisation utilisée est la Cross-Entropy Loss.

Où $V$ est la taille du vocabulaire, $y_c$ la distribution cible (one-hot), et $\hat{y}_c$ la probabilité prédite par le modèle.

2. CPT (Continual Pre-Training)

Phase critique pour l'impact. Un modèle générique pré-entraîné sur l'anglais manque de contexte pour le continent africain. Le CPT consiste à reprendre le pré-entraînement avec un corpus ciblé (ex: littérature médicale spécialisée, corpus linguistiques en Wolof, Swahili, Amharique). Cela spécialise les poids du modèle vers une utilité locale sans perdre ses capacités de raisonnement globales.

3. SFT (Supervised Fine-Tuning)

Un modèle pré-entraîné est un générateur de texte, pas un assistant. Le SFT aligne le modèle pour qu'il réponde à des instructions précises. On utilise des paires de données structurées (Prompt, Réponse) d'une grande qualité pour modifier la distribution de probabilité du modèle vers le format conversationnel attendu.

Implémentation de la Boucle SFT

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

def sft_training_step(
    model: torch.nn.Module,
    batch: dict[str, torch.Tensor],
    optimizer: AdamW,
    device: torch.device
) -> float:
    model.train()

    input_ids = batch['input_ids'].to(device)
    labels = batch['labels'].to(device)

    optimizer.zero_grad(set_to_none=True)

    logits = model(input_ids)

    shift_logits = logits[..., :-1, :].contiguous()
    shift_labels = labels[..., 1:].contiguous()

    loss = F.cross_entropy(
        shift_logits.view(-1, shift_logits.size(-1)), 
        shift_labels.view(-1), 
        ignore_index=-100 
    )

    loss.backward()
    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
    optimizer.step()

    return loss.item()
            

Conclusion

De l'élégance de la Scaled Dot-Product Attention jusqu'à la rigueur de l'alignement SFT, construire un LLM est un exercice d'ingénierie qui lie les mathématiques fondamentales à l'impact sociétal. L'enjeu technique d'aujourd'hui consiste à adapter ces immenses graphes de calculs pour résoudre les problèmes réels sur le terrain.