LLM : Guide Complet des Grands Modèles de Langage

Résumé

Les LLM (Large Language Models, ou Grands Modèles de Langage) représentent l’une des avancées les plus spectaculaires de l’intelligence artificielle contemporaine. Ces modèles, entraînés sur des volumes colossaux de données textuelles, sont capables de générer du texte cohérent, de répondre à des questions complexes, de résumer des documents, de traduire entre des langues et d’exécuter de nombreuses tâches linguistiques sans entraînement spécifique supplémentaire. Ce guide complet explore l’architecture transformer sous-jacente, les mécanismes d’entraînement, le fine-tuning par RLHF, et fournit une implémentation Python concrète avec Hugging Face pour que vous puissiez expérimenter par vous-même. Que vous soyez développeur, chercheur ou simplement curieux des technologies d’IA, ce guide vous donnera une compréhension approfondie de ce qu’est vraiment un LLM.

Principe Mathématique

Architecture Transformer Decoder-Only

Les LLM modernes reposent sur l’architecture transformer decoder-only, une évolution du transformer original proposé par Vaswani et al. en 2017. Contrairement au transformer encodeur-décodeur conçu initialement pour la traduction automatique, les LLM de nouvelle génération (GPT-3, GPT-4, LLaMA, Claude, PaLM) utilisent uniquement la partie décodeur, optimisée pour la génération séquentielle de texte.

Le mécanisme central est l’attention causale (ou attention masquée). À chaque position i de la séquence, le modèle ne peut regarder que les tokens précédents (positions 1 à i-1). Mathématiquement, pour une séquence d’entrée X = (x₁, x₂, …, xₙ), l’attention causale se calcule ainsi :

Attention(Q, K, V) = softmax(QKᵀ / √dₖ + M) · V

où M est une matrice de masquage triangulaire inférieure remplie de −∞ au-dessus de la diagonale, garantissant que la prédiction au temps t ne dépend que des tokens antérieurs. Cette contrainte causale est fondamentale : elle empêche le modèle de « tricher » en regardant les tokens futurs pendant l’entraînement.

Chaque couche du transformer contient :

• Multi-Head Self-Attention : plusieurs têtes d’attention calculées en parallèle, chaque tête apprenant des motifs relationnels différents entre les tokens.
• Feed-Forward Network (FFN) : un réseau à deux couches linéaires avec activation non linéaire (généralement GELU ou SwiGLU), appliqué indépendamment à chaque position.
• Layer Normalization et connexions résiduelles : stabilisent l’entraînement en profondeur, permettant des modèles de centaines de couches.

Pré-Entraînement : Prédiction du Token Suivant

L’objectif d’entraînement est conceptuellement simple : prédire le token suivant. Étant donné une séquence de tokens (t₁, t₂, …, tₙ), le modèle maximise la vraisemblance de chaque token compte tenu de ses prédécesseurs :

L(θ) = −Σᵢ log P(tᵢ | t₁, …, tᵢ₋₁; θ)

Cette fonction de coût est la cross-entropie entre la distribution prédite par le modèle et la distribution réelle (one-hot sur le token cible). Les données d’entraînement comprennent des billions de tokens — Common Crawl, Wikipédia, livres, articles scientifiques, forums, code source — permettant au modèle d’acquérir une connaissance encyclopédique implicite.

Le vocabulaire utilise le Byte Pair Encoding (BPE), un algorithme de sous-mots qui décompose les mots rares en unités plus fréquentes, réduisant la taille du vocabulaire à environ 30 000 à 100 000 tokens tout en couvrant n’importe quel texte, y compris dans des langues peu représentées.

Scaling Laws

Les travaux de Kaplan et al. (2020) puis de Hoffmann et al. (2022) ont révélé des lois d’échelle prédictives pour les performances des LLM. La relation fondamentale suit une loi de puissance :

Performance ∝ (compute)^(0,047) × (data)^(0,107) × (params)^(0,339)

Cela signifie que :

• Doubler les paramètres (taille du modèle) améliore la performance d’environ 26 % (2^0,339 ≈ 1,26)
• Doubler les données d’entraînement n’apporte qu’environ 8 % d’amélioration
• Doubler le compute total apporte environ 3 % d’amélioration

Ces résultats ont des implications majeures : il est plus efficace d’augmenter la taille du modèle que la quantité de données. Les Chinchilla Laws ultérieures ont nuancé ce résultat en montrant qu’il existe un ratio optimal entre taille du modèle et quantité de données d’entraînement, mais le principe fondamental demeure : la taille compte, et elle compte plus qu’on ne le pensait initialement.

RLHF : Fine-Tuning par Reinforcement Learning from Human Feedback

Le pré-entraînement seul produit un modèle capable de générer du texte, mais pas nécessairement du texte utile, honnête et inoffensif. Le RLHF ajoute une étape cruciale de post-entraînement en trois phases :

1. Fine-tuning supervisé (SFT) : le modèle est réentraîné sur un petit ensemble de démonstrations de haute qualité rédigées par des annotateurs humains, lui apprenant à suivre des instructions plutôt qu’à simplement continuer du texte.
2. Entraînement du modèle de récompense (RM) : des annotateurs classent plusieurs réponses du modèle par préférence. Un modèle de récompense distinct est entraîné pour prédire quelle réponse un humain préférerait, en utilisant une fonction de perte de type Bradley-Terry :

L_RM(φ) = −E[(x,y_w,y_l)] ~ D [log σ(r_φ(x, y_w) − r_φ(x, y_l))]

3. Optimisation par PPO (Proximal Policy Optimization) : le modèle de langage est optimisé via reinforcement learning pour maximiser la récompense prédite, tout en maintenant une régularisation KL vers le modèle original pour éviter la dégradation :

L_PPO = E[r_φ(x, y) − β · KL(π_θ || π_ref)]

Ce processus transforme un modèle brut, parfois toxique ou inutile, en un assistant compétent et poli.

Intuition : Le Bibliothécaire et le Critique Littéraire

Pour comprendre ce qu’est un LLM sans se perdre dans les équations, imaginez un bibliothécaire qui aurait lu absolument tous les livres du monde. Ce bibliothécaire ne connaît pas la vérité au sens philosophique — il n’a jamais expérimenté le monde, il n’a jamais senti le vent ni goûté un fruit. Mais il connaît les patterns du langage comme personne d’autre. Quand vous lui posez une question, il ne cherche pas une réponse dans sa mémoire : il prédit ce qui sonne juste, en s’appuyant sur les milliards de phrases qu’il a lues pendant son pré-entraînement.

C’est à la fois puissant et limitatif. Le LLM ne « sait » rien au sens où nous comprenons le savoir : il produit du texte statistiquement plausible, pas nécessairement vrai. Ses hallucinations ne sont pas des mensonges délibérés — ce sont des extrapolations confiantes d’un système qui ne fait que continuer des patterns linguistiques.

Le RLHF, dans cette analogie, c’est comme si on ajoutait un critique littéraire exigeant à côté du bibliothécaire. Ce critique ne change pas ce que le bibliothécaire a lu, mais il lui apprend le bon goût, la politesse, la nuance. Il lui dit : « Ne sois pas vulgaire. Sois utile. Admets quand tu ne sais pas. » Le résultat est un modèle qui semble plus intelligent, mais dont la base computationnelle reste inchangée — seule la politique de génération a été affinée.

Implémentation Python

1. Pipeline de Génération avec Hugging Face

Le moyen le plus simple d’utiliser un LLM est le pipeline text-generation de la bibliothèque transformers de Hugging Face :

from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
import torch

# Chargement du modèle (ici un petit modèle open-source)
model_name = "meta-llama/Llama-2-7b-chat-hf"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

# Pipeline de génération
generator = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    device_map="auto"
)

# Génération simple
prompt = "Explique-moi le concept de l'attention dans les transformers en français."
result = generator(prompt, max_new_tokens=256, temperature=0.7, top_p=0.9)
print(result[0]["generated_text"])

2. Prompting Few-Shot

Le prompting few-shot consiste à fournir quelques exemples dans le prompt pour guider le comportement du modèle sans modifier ses poids :

def few_shot_prompt():
    prompt = """Classifie le sentiment de chaque phrase en positif, neutre ou négatif.

Phrase : « J'adore ce nouveau logiciel, il est incroyable ! »
Sentiment : positif

Phrase : « Le service était correct, rien de spécial. »
Sentiment : neutre

Phrase : « Ce produit est une déception totale, je ne recommande pas. »
Sentiment : négatif

Phrase : """
    return prompt

# Avec le modèle chargé précédemment
new_text = few_shot_prompt() + "« L'interface est magnifique, mais la batterie ne tient pas. »\nSentiment : "
result = generator(new_text, max_new_tokens=16, temperature=0.1)
print(result[0]["generated_text"])
# Résultat attendu : « négatif » ou « neutre »

3. Fine-Tuning avec PEFT/LoRA

L’adaptation Low-Rank (LoRA) permet de fine-tuner un gros modèle en ne modifiant qu’une infime fraction des paramètres (souvent moins de 1 %) :

from peft import LoraConfig, get_peft_model, TaskType
from transformers import AutoModelForCausalLM, TrainingArguments, Trainer, default_data_collator
from datasets import load_dataset

# Configuration LoRA
lora_config = LoraConfig(
    r=16,                    # Rang de la décomposition
    lora_alpha=32,           # Facteur d'échelle
    target_modules=["q_proj", "v_proj"],  # Couches à adapter
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM
)

# Chargement du modèle de base
base_model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-v0.1",
    torch_dtype=torch.float16,
    device_map="auto"
)

# Application de LoRA
model = get_peft_model(base_model, lora_config)
model.print_trainable_parameters()
# Résultat : "trainable params: 0.15% of total params"

# Préparation des données d'entraînement
dataset = load_dataset("csv", data_files="mon_dataset.csv", split="train")

# Arguments d'entraînement
training_args = TrainingArguments(
    output_dir="./llm-lora-finetune",
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    num_train_epochs=3,
    fp16=True,
    logging_steps=50,
    save_strategy="epoch",
    optim="adamw_torch",
    lr_scheduler_type="cosine",
    warmup_ratio=0.03,
)

# Fine-tuning
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    data_collator=default_data_collator,
)

trainer.train()
model.save_pretrained("./mon-model-lora")

4. Évaluation du Modèle

L’évaluation d’un LLM nécessite plusieurs métriques complémentaires :

from transformers import pipeline
import json

def evaluer_llm(model_path, test_prompts):
    """Évalue un modèle LLM sur un ensemble de prompts de test."""
    pipe = pipeline("text-generation", model=model_path, device_map="auto")
    resultats = []

    for prompt in test_prompts:
        resultat = pipe(
            prompt,
            max_new_tokens=128,
            temperature=0.7,
            do_sample=True
        )
        resultats.append({
            "prompt": prompt,
            "reponse": resultat[0]["generated_text"][len(prompt):],
            "longueur": len(resultat[0]["generated_text"])
        })

    # Sauvegarde des résultats
    with open("evaluation_resultats.json", "w", encoding="utf-8") as f:
        json.dump(resultats, f, ensure_ascii=False, indent=2)

    return resultats

# Exemple d'utilisation
test_prompts = [
    "Résume en trois phrases : qu'est-ce que la photosynthèse ?",
    "Écris un poème sur l'automne en quatre vers.",
    "Quelle est la différence entre un LLM et un réseau de neurones classique ?",
    "Traduis en anglais : 'Le développement durable est essentiel.'",
]

resultats = evaluer_llm("./mon-model-lora", test_prompts)
for r in resultats:
    print(f"\nPrompt : {r['prompt']}")
    print(f"Réponse ({r['longueur']} tokens) : {r['reponse']}")

Hyperparamètres de Génération

Les hyperparamètres de décodage contrôlent la façon dont le modèle génère du texte. Les comprendre est essentiel pour obtenir des résultats cohérents et adaptés à votre cas d’usage.

Temperature

La température contrôle le caractère aléatoire des prédictions. Mathématiquement, elle divise les logits avant le softmax :

Pᵢ = exp(logitᵢ / T) / Σⱼ exp(logitⱼ / T)

• T → 0 : le modèle devient déterministe, choisissant toujours le token le plus probable (greedy decoding). Le texte est cohérent mais peut être répétitif et ennuyeux.
• T = 0,7 : bon compromis pour la plupart des tâches génératives. Le texte reste cohérent tout en étant varié.
• T → 1,0 : le modèle est plus créatif, mais risque de produire du texte incohérent ou hors-sujet.
• T > 1,0 : déconseillé pour les LLM, cela introduit trop d’aléa et dégrade significativement la qualité.

Top-p (Nucleus Sampling)

Le top-p (ou nucleus sampling) limite la sélection aux tokens dont la probabilité cumulée atteint un seuil p. Par exemple, avec top_p = 0,9, on ne considère que les tokens les plus probables dont la somme des probabilités atteint 90 %.

L’avantage par rapport au top-k (qui prend les k tokens les plus probables) est que le nombre de candidats s’adapte dynamiquement : quand le modèle est très confiant, peu de tokens sont considérés ; quand il est incertain, plus de tokens entrent dans le noyau.

max_new_tokens

Contrôle la longueur maximale de la réponse générée (excluant le prompt). Attention : ce n’est pas une garantie de longueur, le modèle peut s’arrêter avant s’il génère un token de fin de séquence (EOS).

repetition_penalty

Pénalise les tokens déjà générés précédemment, réduisant la répétition. Une valeur de 1,0 désactive la pénalité. Des valeurs typiques sont 1,1 à 1,3 — au-delà, le modèle peut refuser de répéter des mots nécessaires, ce qui dégrade la lisibilité.

num_return_sequences

Génère plusieurs réponses indépendantes pour un même prompt, utile pour l’exploration ou pour sélectionner la meilleure réponse via un scoring ultérieur. Chaque séquence est échantillonnée indépendamment.

# Exemple combinant plusieurs hyperparamètres
result = generator(
    prompt,
    max_new_tokens=512,
    temperature=0.8,
    top_p=0.92,
    repetition_penalty=1.15,
    num_return_sequences=3,
    do_sample=True
)
for i, seq in enumerate(result):
    print(f"--- Séquence {i+1} ---")
    print(seq["generated_text"])

Avantages et Limites des LLM

Avantages

• Polyvalence remarquable : un seul modèle peut répondre à des questions, rédiger du code, traduire, résumer, analyser et bien plus — sans fine-tuning spécifique pour chaque tâche.
• Capacités émergentes : au-delà d’un certain seuil de taille (typiquement plusieurs dizaines de milliards de paramètres), des capacités non présentes dans les petits modèles apparaissent : raisonnement en chaîne (chain of thought), compréhension du code, raisonnement mathématique élémentaire.
• Transfert zero-shot : les LLM peuvent accomplir des tâches qu’ils n’ont jamais explicitement vues pendant l’entraînement, simplement grâce à la richesse de leurs représentations internes.
• Interface naturelle : l’interaction se fait en langage naturel, le moyen de communication le plus intuitif pour les humains.
• Écosystème mature : Hugging Face, LangChain, Ollama et d’autres outils rendent les LLM accessibles même aux développeurs non-spécialistes.

Limites

• Hallucinations : les LLM peuvent inventer des faits avec une confiance absolue. Ils ne distinguent pas la vérité de la plausibilité linguistique.
• Biais : les modèles reflètent et amplifient les biais présents dans leurs données d’entraînement (stéréotypes de genre, de race, culturels).
• Coût computationnel : l’inférence d’un LLM de grande taille nécessite des GPU puissants, et l’entraînement de zéro coûte des millions de dollars.
• Fenêtre de contexte limitée : même les modèles les plus récents ont une limite de contexte (32K à 128K tokens pour les meilleurs), ce qui restreint la quantité d’information qu’ils peuvent traiter en une seule passe.
• Connaissances figées : les connaissances du modèle sont limitées aux données d’entraînement, avec une date de coupure. Sans outils externes (ReAct, RAG), le modèle ne peut pas accéder à des informations récentes.
• Manque de raisonnement profond : malgré les apparences, les LLM ne raisonnent pas au sens logique du terme. Ils excellent dans la reconnaissance de patterns mais échouent sur des tâches nécessitant une déduction rigoureuse ou une planification à long terme.

Quatre Cas d’Usage Concrets

1. Assistant de Rédaction Intelligente

Un LLM peut assister les rédacteurs en générant des brouillons, en suggérant des reformulations, en adaptant le ton et le style. Un journal numérique pourrait utiliser un LLM fine-tuné sur son propre corpus pour produire des ébauches d’articles que les journalistes n’ont plus qu’à peaufiner. Le gain de productivité est estimé à 30 à 50 % selon les études récentes sur l’impact des IA génératives dans les métiers de la rédaction.

2. Chatbot de Support Client

Intégrer un LLM dans un système de support client permet de traiter automatiquement des demandes complexes qui dépassaient les capacités des chatbots basés sur des règles. Le LLM comprend l’intention du client, consulte une base de connaissances via RAG (Retrieval-Augmented Generation), et formule une réponse précise et personnalisée, tout en escaladant vers un agent humain si nécessaire. Cette approche réduit drastiquement les temps d’attente et améliore la satisfaction client.

3. Analyse de Documents Juridiques

Dans le domaine juridique, les LLM peuvent analyser des contrats, identifier des clauses à risque, comparer des documents et extraire des informations structurées. Un cabinet d’avocats pourrait utiliser un LLM spécialisé pour pré-analyser des centaines de pages de documents, ne laissant aux avocats que la vérification et la stratégie. Le fine-tuning sur du corpus juridique spécifique est ici essentiel pour la précision terminologique et la compréhension des nuances contractuelles.

4. Génération et Explication de Code

Les LLM spécialisés en code (comme Codex, StarCoder ou CodeLlama) peuvent générer des fonctions complètes à partir de descriptions en langage naturel, expliquer du code legacy, détecter des bugs, écrire des tests unitaires et même refactorer des bases de code entières. C’est probablement le cas d’usage où le rapport coût-bénéfice est le plus favorable, car le code est un domaine où la vérification automatique est possible (exécution, tests, linting). Les développeurs rapportent un gain de productivité de 20 à 55 % selon les études menées par GitHub et des cabinets indépendants.

Voir Aussi

• Énumérer les Sous-masques d’un Bitmask en Python : Guide Complet et Astuces Pratiques
• Maîtriser les Intersections en Python : Techniques et Astuces pour Optimiser vos Algorithmes