AI Prompt Engineering · Leçon

Quand affiner un modèle

Les signes indiquant que le prompting atteint ses limites.

Quand affiner un modèle est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Prompt Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Prompt Engineering comprend 4 leçons au total.

Le réglage fin se décide sur des preuves

Le réglage fin n’est justifié que lorsque vous pouvez montrer des données prouvant que la formulation d’instructions a atteint une limite. Le déclencheur n’est jamais une intuition : c’est une évaluation mise de côté où la meilleure instruction honnête atteint un plateau sous votre seuil de qualité malgré le parcours de l’échelle d’optimisation.

Le réglage fin échange la flexibilité contre la cohérence, un coût inférieur par appel et un comportement appris
Son coût comprend une chaîne de traitement des données, une infrastructure d’évaluation et de nouveaux réglages lors des changements du modèle de base
Vous devez pouvoir nommer précisément l’échec que la formulation d’instructions ne pouvait pas corriger

Signal 1 : Le plateau des instructions

Le signal le plus clair est un plateau sur un ensemble d’évaluation figé. Vous ajoutez des exemples, décomposez la tâche, ajoutez des vérificateurs — puis le score cesse de progresser tandis que les erreurs restent systématiques et non aléatoires.

Les erreurs résiduelles systématiques (le modèle gère constamment mal la même structure) signifient que le comportement est difficile à obtenir par instruction. C’est un problème appelant un réglage fin. Des erreurs aléatoires et dispersées signifient généralement que les instructions ou les données restent bruitées : continuez plutôt à itérer.

# Track eval score vs prompt-iteration; flat tail = plateau
scores = [0.62, 0.71, 0.78, 0.79, 0.795, 0.796]  # diminishing returns
def plateaued(scores, window=3, eps=0.01):
    tail = scores[-window:]
    return (max(tail) - min(tail)) < eps

print(plateaued(scores))  # True -> prompting has stalled

Signal 2 : La longueur des instructions devient le produit

Lorsque les instructions ont atteint des milliers de jetons d’exemples et de règles simplement pour maintenir la qualité, vous payez un coût de latence et d’argent à chaque appel pour simuler un comportement appris.

Si ces jetons encodent un comportement stable et répétitif (un format fixe, un style cohérent, une décision d’orientation), le réglage fin peut l’intégrer aux paramètres — réduisant les instructions d’un ordre de grandeur tout en conservant le comportement. C’est la distillation des instructions, le cas d’usage légitime le plus courant du réglage fin.

Signal 3 : Plancher strict de latence ou de coût

Si vous avez besoin qu’un modèle plus petit, plus rapide et moins cher reproduise le comportement d’un modèle plus grand sur une tâche étroite, le réglage fin est l’outil approprié. Vous distillez les sorties du grand modèle dans un petit modèle réglé finement.

Cela se justifie lorsque le volume est supérieur au seuil de rentabilité, que le budget de latence est serré et que la tâche est suffisamment étroite pour qu’un petit modèle puisse la maîtriser. En dehors de ces conditions, la surcharge d’ingénierie n’en vaut pas la peine.

# Distillation data: teacher (big model) labels -> student (small) trains
def make_distill_pair(prompt, teacher_fn):
    completion = teacher_fn(prompt)  # high-quality big-model output
    return {'messages': [
        {'role': 'user', 'content': prompt},
        {'role': 'assistant', 'content': completion},
    ]}

Signal 4 : Format ou style particulier

Certaines sorties sont si spécifiques que les décrire coûte plus cher que les démontrer à grande échelle : un DSL propriétaire, une voix rédactionnelle propre à l’entreprise comportant un millier de micro-règles, un schéma de domaine rigide avec d’innombrables champs conditionnels.

Lorsque le respect du format doit être quasi parfait et que les règles sont trop nombreuses pour être énumérées dans une instruction, des centaines d’exemples enseignent le modèle plus fiablement qu’un texte explicatif. Le réglage fin excelle à intégrer une structure implicite qui résiste aux instructions explicites.

Signal 5 : Comportement auquel le modèle résiste

Il arrive qu’un modèle résiste à une instruction : il continue d’ajouter des réserves que vous lui avez interdites, refuse une tâche inoffensive ou revient à un style par défaut sous charge. Si des instructions fermes et répétées ainsi que des exemples ne permettent pas de supprimer le comportement de manière fiable, cette résistance est un a priori inscrit dans les paramètres de base.

Le réglage fin peut remplacer ces a priori. Vérifiez toutefois d’abord que la résistance est réelle et ne vient pas d’un problème de clarté des instructions — une résistance mal attribuée entraîne des entraînements inutiles.

Signaux opposés : quand s’abstenir de régler finement (NOT)

Il est tout aussi important de reconnaître les fausses alertes. Le réglage fin est à éviter (NOT) lorsque :

La lacune concerne les connaissances — récupérez-les plutôt ; le réglage fin intègre des faits obsolètes et incomplets
La spécification change chaque semaine — vous devrez réentraîner le modèle sans cesse
Vous disposez de moins de quelques centaines d’exemples propres — le signal est trop faible et le risque de surapprentissage élevé
Les erreurs sont aléatoires et non systématiques — les données ou les instructions restent bruitées
Vous ne disposez pas d’un dispositif d’évaluation — vous ne pouvez pas savoir si le réglage fin a réellement aidé

Contrôle de préparation des données

La qualité du réglage fin est limitée par la qualité des données. Avant de vous engager, passez un contrôle de préparation : suffisamment d’exemples, répartis équitablement entre les cas qui vous intéressent, annotations cohérentes et absence de fuite de données susceptible de gonfler les scores d’évaluation.

Quelques centaines d’exemples soigneusement sélectionnés valent mieux que des dizaines de milliers d’exemples bruités. Si vos annotations se contredisent, le modèle apprendra le bruit.

def data_ready(examples, min_n=300, max_dupe_ratio=0.05):
    n = len(examples)
    texts = [e['messages'][0]['content'] for e in examples]
    dupe_ratio = 1 - (len(set(texts)) / n)
    return n >= min_n and dupe_ratio <= max_dupe_ratio

# Returns False until you have enough deduped, curated examples

Choisissez la méthode de réglage

Tout réglage ne consiste pas à entraîner tous les paramètres. Adaptez la méthode au signal :

LoRA / adaptateurs — peu coûteux, rapides et réversibles ; idéaux pour la distillation du style et du format
Réglage fin complet — plus lourd ; destiné aux changements comportementaux profonds sur des modèles ouverts performants
Réglage des préférences (style DPO) — lorsque vous disposez de jugements binaires bon/mauvais plutôt que de réponses de référence

Commencez par la méthode la plus légère requise par le signal. Les adaptateurs de type LoRA couvrent la majorité des cas de production pour une fraction du coût.

Protocole de préengagement

Avant de lancer un entraînement, verrouillez l’expérience afin que le résultat soit interprétable :

Figez un ensemble d’évaluation mis de côté que le modèle ne verra jamais pendant l’entraînement
Notez le meilleur score de référence obtenu avec les instructions seules sur cet ensemble
Énoncez à l’avance le gain cible et le plafond de coût
Définissez le retour arrière : si le modèle réglé ne dépasse pas la référence du gain cible, vous mettez les instructions en production

Sans référence et objectif définis à l’avance, vous ne pouvez pas prouver que le réglage fin a justifié son coût.

Regrouper les signaux

Combinez les signaux en un seul critère de décision. Le réglage fin ne commence que si la formulation des instructions a atteint un plateau (plateaued) AND si les données sont prêtes AND si l’écart concerne le comportement — jamais lorsqu’un seul signal se déclenche isolément.

def should_fine_tune(plateaued, data_ready, gap_is_behavior,
                     spec_stable, has_eval_harness):
    return all([
        plateaued,        # prompting stalled on frozen eval
        data_ready,       # enough clean, deduped examples
        gap_is_behavior,  # not a knowledge gap (else use RAG)
        spec_stable,      # task definition has settled
        has_eval_harness, # can measure the lift
    ])

print(should_fine_tune(True, True, True, True, True))  # True -> proceed

Vérification rapide

Sur un ensemble d’évaluation figé, les erreurs d’un modèle sont aléatoires et dispersées entre de nombreux types d’entrées, et le score progresse encore nettement lorsque vous modifiez les exemples. Qu’est-ce que cela indique sur la préparation au réglage fin ?

Récapitulatif

Effectuez un réglage fin sur la base de preuves, et non d’intuitions. Les signaux légitimes sont les suivants : un véritable plateau accompagné d’erreurs systématiques, une longueur d’instructions devenue le produit, un plancher strict de latence ou de coût, des formats particuliers ou un comportement auquel le modèle de base résiste.

Signaux opposés : lacunes de connaissances, spécifications changeantes, données insuffisantes, erreurs aléatoires, absence de dispositif d’évaluation
Passez un contrôle de préparation des données avant l’entraînement — la qualité limite le résultat
Choisissez la méthode la plus légère (d’abord un style LoRA) requise par le signal
Engagez-vous à l’avance sur une évaluation figée, une référence, un gain cible et un retour arrière
Ne poursuivez que lorsque le plateau AND les données prêtes AND l’écart comportemental sont tous présents

Questions Fréquemment Posées

La leçon « Quand affiner un modèle » est-elle gratuite ?

Oui — le texte complet de « Quand affiner un modèle » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Prompt Engineering, passe à CoddyKit PRO. Le cours AI Prompt Engineering comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Quand affiner un modèle » ?

Les signes indiquant que le prompting atteint ses limites. Tu pratiques AI Prompt Engineering avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Prompt Engineering ?

Aucune expérience préalable n'est requise. AI Prompt Engineering sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Quand affiner un modèle » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Prompt Engineering ?

Oui. Chaque leçon AI Prompt Engineering inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à AI Prompt Engineering