Paramètres d'échantillonnage (Température, Top-p, Min-p)

1. Vue d'ensemble du concept et problématique système

Un modèle de langage ne génère pas directement un texte fini. À chaque étape autorégressive, la couche de sortie du transformer produit un tableau de valeurs brutes non normalisées — les logits pour chaque token d'un vocabulaire comptant plus de 100 000 éléments. La transformation de ces valeurs brutes en un token sélectionné spécifique est régie par l'algorithme de décodage.

Si l'on choisit systématiquement le token ayant la probabilité absolue la plus élevée (recherche gloutonne, Greedy Search), le modèle devient prévisible, sec et tombe souvent dans des boucles infinies de répétition des mêmes phrases. Inversement, si les mots sont choisis totalement au hasard, la génération se transforme en délire incohérent et en erreurs syntaxiques.

Les Sampling Parameters (paramètres d'échantillonnage) constituent un ensemble de régulateurs mathématiques qui modifient la forme de la distribution de probabilité avant la sélection du symbole. Comprendre leur mécanique interne permet à l'ingénieur d'équilibrer finement entre le déterminisme strict d'un compilateur et l'heuristique créative de recherche de solutions.

2. Taxonomie architecturale et modèle mental

Le pipeline de traitement des logits consiste en une série de filtres mathématiques séquentiels :

┌─────────────────────────────────────────────────────────────┐
│                 PIPELINE DE DÉCODAGE DES TOKENS             │
├─────────────────────────────────────────────────────────────┤
│ 1. Logits bruts z_i issus de la couche linéaire du Transformer│
├─────────────────────────────────────────────────────────────┤
│ 2. Modification par pénalités :                               │
│    • Pénalité de fréquence (réduction du poids selon le nombre de répétitions)│
│    • Pénalité de présence (pénalité unique pour les mots déjà mentionnés)│
├─────────────────────────────────────────────────────────────┤
│ 3. Mise à l'échelle par température : z'_i = z_i / T          │
│    T ➔ 0 : les pics s'affinent (déterminisme Argmax)         │
│    T > 1 : la distribution s'aplanit (haute entropie)        │
├─────────────────────────────────────────────────────────────┤
│ 4. Normalisation Softmax : P(w_i) = exp(z'_i) / Somme(exp(z'_j))│
├─────────────────────────────────────────────────────────────┤
│ 5. Filtres de troncature (Top-K ➔ Top-P ➔ Min-P)              │
│    Élimination de la longue « queue » des tokens peu probables et parasites│
├─────────────────────────────────────────────────────────────┤
│ 6. Tirage multinomial stochastique (choix final du token)     │
└─────────────────────────────────────────────────────────────┘

1. Température (Temperature, $T$) :
   • Diviseur de mise à l'échelle appliqué au vecteur de logits avant la fonction Softmax. Lorsque $T \to 0$, la différence entre le token le plus probable et les autres tend vers l'infini (déterminisme). À haute température ($T = 1.0–1.5$), les tokens peu probables obtiennent une chance réelle d'être sélectionnés.
2. Top-P (Nucleus Sampling) :
   • Seuil dynamique de probabilité cumulative. L'algorithme trie les tokens par ordre décroissant et ne conserve que le sous-ensemble minimal dont la somme des probabilités atteint $P$ (par exemple, 0.9 = 90 % de la masse de la distribution).
3. Min-P (Seuil dynamique) :
   • Filtre avancé moderne. Il élimine tous les tokens dont la probabilité individuelle est inférieure à $P_{\min} = \text{Min-P} \times P_{\max}$, où $P_{\max}$ est la probabilité du leader absolu. Si le leader a 80 % et Min-P = 0.05, toutes les options avec moins de 4 % de chance sont coupées.
4. Pénalités de répétition (Presence & Frequency Penalties) :
   • Réduisent les valeurs des logits des tokens déjà présents dans le texte généré, empêchant ainsi les boucles de répétition.

3. Pipeline technique et mécanique interne

Cycle de vie d'une étape de sélection probabiliste d'un token :

1. Obtention des logits : La dernière couche du réseau produit un vecteur brut de logits $z = [12.4, 8.1, 15.6, -3.2, \dots]$.
2. Application des pénalités de répétition : Si un mot est déjà apparu trois fois, son logit est réduit de $3 \times \text{frequency_penalty}$.
3. Division par la température : Chaque valeur du vecteur est divisée par la température : $z'_i = z_i / T$.
4. Calcul des probabilités via Softmax : Les logits sont convertis en probabilités normalisées comprises entre 0 et 1, dont la somme est strictement égale à 1.0.
5. Filtrage via Min-P : Le score le plus élevé $P_{\max} = 0.70$ est identifié. Avec $\text{Min-P} = 0.1$, le seuil est de $0.07$. Tous les tokens avec une probabilité inférieure à 7 % sont retirés du pool.
6. Tirage stochastique (Multinomial Sampling) : Un générateur de nombres pseudo-aléatoires (PRNG) effectue un tirage à partir du pool de probabilités conservé. Le token sélectionné est transmis à la sortie.

4. Scénarios d'ingénierie pratiques en production

01. Génération sans erreur de requêtes SQL et schémas de validation

Un service backend génère du code de migration sur la base d'un prompt utilisateur :

• Configuration : temperature: 0.0 (Greedy Search).
• Le modèle garantit la sélection des constructions syntaxiques les plus standard, excluant les erreurs accidentelles de virgule ou les mots-clés inexistantes.

02. Utilisation de Min-p pour un refactoring de haute qualité

Un agent refactorise un module algorithmique complexe :

• Configuration : temperature: 0.7, min_p: 0.05.
• Le modèle dispose d'une liberté créative dans le choix du pattern architectural, mais le mécanisme Min-P protège efficacement contre la sélection de fonctions hallucinées aléatoires.

03. Brainstorming exploratoire d'architecture (High Entropy Search)

Génération d'idées business non triviales et de scénarios de test :

• Configuration : temperature: 0.9, top_p: 0.95.
• Le modèle propose des cas limites inattendus, des scénarios de charge non standards et des hypothèses alternatives de défaillance système.

5. Pièges, erreurs courantes et sécurité

• Les pénalités de répétition cassent la syntaxe du code : Une frequency_penalty élevée (par exemple > 0.5) dans les tâches de programmation conduit à la catastrophe : le modèle tente d'éviter les répétitions naturelles de mots-clés (return, const, accolades fermantes }}), ce qui casse la compilation. Pour le code, les pénalités doivent être nulles.
• Température fixe dans les nouveaux modèles de raisonnement : Dans les modèles de type OpenAI o1 ou DeepSeek-R1, la chaîne de pensée interne a été entraînée sous une température strictement fixe (généralement $T=1.0$ ou $0.6$). Tenter de forcer $T=0$ via l'API est souvent interdit ou détruit le processus d'auto-correction du modèle.
• Conflit de filtres trop agressifs : Définir simultanément top_p: 0.1 et un min_p élevé peut réduire le pool à un seul token ou à zéro, provoquant un crash du moteur d'inférence.
• L'illusion de reproductibilité via Seed : Le paramètre seed fige l'état initial du générateur de nombres aléatoires, mais ne garantit pas un texte identique lors d'un changement de version du driver CUDA ou du nombre de threads parallèles dans un batch.