0Pricing
AI Engineering Academy · Leçon

Quand l’ajustement fin est plus efficace que les invites

Identifiez les cas d’usage où l’ajustement fin est plus avantageux que l’ingénierie des invites : respect constant du style, connaissances propres à un domaine, réduction du coût des jetons grâce à des invites plus courtes et amélioration de la latence.

Quand l’ajustement fin est plus efficace que les invites est une leçon AI Engineering Academy gratuite sur CoddyKit. Ceci est la leçon 1 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 Engineering Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Engineering Academy comprend 4 leçons au total.

Le compromis fondamental

Lorsque vous avez besoin qu’un LLM se comporte d’une manière précise, deux options fondamentales s’offrent à vous : l’ingénierie des prompts (indiquer au modèle quoi faire au moment de l’inférence à l’aide de prompts soigneusement conçus) ou le réglage fin (enseigner au modèle de nouveaux comportements en l’entraînant sur des exemples). Les deux approches peuvent produire des résultats similaires pour de nombreuses tâches, mais elles diffèrent fortement par leur coût, leur rapidité, leur flexibilité et le niveau de qualité maximal qu’elles permettent d’atteindre.

Quand les prompts sont préférables

Les prompts constituent presque toujours le bon point de départ. Ils ne nécessitent aucune infrastructure d’entraînement, produisent des résultats en quelques heures, peuvent être mis à jour instantanément sans nouvel entraînement et fonctionnent bien pour les tâches que le modèle de base sait déjà traiter correctement. Commencez par les prompts pour les tâches où GPT-4o ou Claude produit déjà des résultats acceptables avec des instructions claires, lorsque les exigences évoluent rapidement, pour les cas d’utilisation à faible volume et dans les situations où vous explorez encore le domaine du problème.

# Prompting is sufficient for most well-defined tasks
system_prompt = '''
You are a customer support agent for TechCorp. Your tone is friendly but professional.
Always:
1. Acknowledge the customer's issue in the first sentence
2. Provide step-by-step solutions with numbered lists
3. End with 'Is there anything else I can help you with?'
Never: reveal pricing, discuss competitors, or make promises about future features.
'''

# With clear instructions, GPT-4o handles this well - no fine-tuning needed
# Before investing in fine-tuning, prove prompting is insufficient

Cohérence du style et respect du format

Le réglage fin est préférable lorsque vous avez besoin d’un format de sortie rigoureusement cohérent que les prompts ne permettent pas de produire de manière fiable. Si votre application exige une conformité à 100 % à un schéma JSON précis, un format de document structuré avec exactitude ou un style rédactionnel très spécifique qui diffère de la sortie naturelle du modèle, un réglage fin réalisé avec quelques centaines d’exemples peut assurer une cohérence presque parfaite, impossible à égaler même avec le prompt le plus soigneusement conçu.

# Problem: prompting gives 90% format compliance - 10% failures cause downstream errors
# Prompt approach (unreliable)
system = 'Always respond with JSON: {"category": "...", "priority": 1-5, "tags": [...]}'
# 1 in 10 responses adds explanation text, omits a field, or uses strings for priority

# Fine-tuned approach: train on 500 examples of perfect output
# Training example format:
train_example = {
    'messages': [
        {'role': 'system', 'content': 'Classify customer support tickets.'},
        {'role': 'user', 'content': 'My order is late and I need it for tomorrow.'},
        {'role': 'assistant', 'content': '{"category": "shipping", "priority": 4, "tags": ["late_delivery", "urgent"]}'}
    ]
}
# After fine-tuning: 99.5%+ format compliance with minimal system prompt

Connaissances propres à un domaine

Le réglage fin est le bon choix lorsque le modèle doit apprendre des connaissances absentes des données d’entraînement publiques : les conventions de programmation internes de votre entreprise, une taxonomie propriétaire pour classer les documents, une terminologie juridique ou médicale spécialisée dans un domaine de niche, ou encore les règles de ton et de style propres à votre marque. Ces connaissances ne peuvent pas être transmises efficacement par des exemples dans les prompts, car leur volume dépasse la capacité d’une fenêtre de contexte.

# Example: Internal code style with dozens of company-specific conventions
# Too many rules to fit in a prompt effectively:

# Company conventions (partial list of 200+):
# - Use AppException instead of RuntimeError
# - Repositories are named FooRepository not FooRepo
# - Service methods use handle_verb_noun naming not do_action
# - Config values go through AppConfig.get(), never os.environ directly
# - ... 196 more conventions

# Prompting: you can include ~20 conventions before the model starts ignoring them
# Fine-tuning: train on 1000 examples of compliant vs. non-compliant code
# Result: model learns ALL conventions and applies them automatically

Réduction du coût des jetons grâce à des prompts plus courts

Un argument économique majeur en faveur du réglage fin est la compression des prompts. Un prompt système complexe peut contenir 2 000 jetons. Si vous appelez l’API 10 millions de fois par jour, ces 2 000 jetons coûtent des dizaines de milliers de dollars par mois. Un modèle réglé finement peut être guidé par un prompt beaucoup plus court (50 à 100 jetons), car les instructions détaillées sont désormais intégrées à ses paramètres. À grande échelle, cela peut réduire les coûts liés aux jetons d’entrée de 90 % ou plus.

COST_PER_1K_TOKENS_INPUT = 0.0050  # gpt-4o
DAILY_REQUESTS = 10_000_000

# Base model with detailed prompt
base_prompt_tokens = 2000
daily_input_tokens_base = DAILY_REQUESTS * base_prompt_tokens
daily_cost_base = (daily_input_tokens_base / 1000) * COST_PER_1K_TOKENS_INPUT

# Fine-tuned model with short prompt
fine_tuned_prompt_tokens = 50
daily_input_tokens_ft = DAILY_REQUESTS * fine_tuned_prompt_tokens
daily_cost_ft = (daily_input_tokens_ft / 1000) * COST_PER_1K_TOKENS_INPUT

print(f'Base model daily input cost: ${daily_cost_base:,.2f}')
print(f'Fine-tuned model daily input cost: ${daily_cost_ft:,.2f}')
print(f'Monthly savings: ${(daily_cost_base - daily_cost_ft) * 30:,.2f}')
# Base: $100,000/day. Fine-tuned: $2,500/day. Savings: ~$2.9M/month

Amélioration de la latence

Les modèles réglés finement peuvent améliorer la latence de deux façons. Premièrement, des prompts plus courts signifient que le modèle traite moins de jetons d’entrée, ce qui réduit directement le délai avant le premier jeton. Deuxièmement, les modèles réglés finement convergent souvent plus rapidement vers le format correct (la réponse contient moins de jetons avant d’atteindre la réponse proprement dite), ce qui réduit le nombre total de jetons de sortie et le temps de génération. Pour les applications sensibles à la latence, ces deux effets se cumulent et produisent des améliorations significatives.

# Latency comparison (approximate)

# Base model with 2000-token prompt:
# - Input tokens processed: 2000 + 50 (user query) = 2050
# - Response: often starts with 'Sure! Here is...' (5-10 unnecessary tokens)
# - TTFT: ~800ms (more tokens to process)

# Fine-tuned model with 50-token prompt:
# - Input tokens processed: 50 + 50 (user query) = 100
# - Response: starts directly with the answer (no preamble)
# - TTFT: ~100ms (few tokens to process)

# For classification tasks (short outputs), this is a 5-8x latency improvement
# For generation tasks, improvement is less dramatic but still significant

print('Fine-tuning trades upfront training cost for per-request latency+cost savings')

Le volume minimal de données requis

Le réglage fin nécessite des données d’entraînement — et c’est souvent le principal obstacle pratique. En règle générale, il vous faut au moins 50 à 100 exemples de haute qualité pour observer une amélioration significative par rapport au modèle de base, 500 à 1 000 exemples pour obtenir un respect fiable du style et du format, et 1 000 à 10 000 exemples pour acquérir des connaissances importantes dans un domaine. En dessous de 50 exemples, l’utilisation des mêmes exemples dans le contexte du prompt (apprentissage à peu d’exemples) donnera généralement de meilleurs résultats que le réglage fin.

def estimate_fine_tuning_feasibility(num_examples: int, task_type: str) -> str:
    if num_examples < 50:
        return 'Insufficient data. Use few-shot prompting with these examples instead.'
    
    if task_type == 'format_adherence' and num_examples >= 100:
        return 'Fine-tuning recommended. Format consistency issues are hard to solve with prompting.'
    
    if task_type == 'style_matching' and num_examples >= 300:
        return 'Fine-tuning recommended. Consistent style requires enough examples to learn the distribution.'
    
    if task_type == 'domain_knowledge' and num_examples >= 500:
        return 'Fine-tuning recommended if knowledge is truly proprietary.'
    
    return 'Continue with advanced prompting (chain-of-thought, structured output) and revisit fine-tuning when you have more data.'

Les coûts cachés du réglage fin

Le réglage fin entraîne des coûts cachés importants au-delà de la facture de calcul. Vous avez besoin : d’une infrastructure pour exécuter l’entraînement (heures de GPU ou service géré), d’un processus de collecte et de contrôle de la qualité des données, d’une évaluation permettant de vérifier que le modèle réglé finement améliore réellement la métrique cible, d’un processus de déploiement pour le modèle personnalisé et d’un processus de maintenance continu pour relancer l’entraînement lorsque le modèle de base est mis à jour ou que vos exigences évoluent. Ces coûts sont réels et doivent être mis en balance avec les avantages.

fine_tuning_total_cost = {
    'data_collection_and_QA': '$5,000-$50,000',  # human annotation or LLM-generated
    'training_compute': '$50-$5,000',             # depends on model size and data volume
    'evaluation_pipeline': '$500-$2,000',         # building eval harness
    'deployment_infra': '$200-$2,000/month',      # serving the custom model
    'maintenance': '$1,000-$5,000/year',          # retraining when things change
    'opportunity_cost': 'weeks to months',        # time to build vs. prompt iteration
}

# Compare to prompting costs:
prompting_costs = {
    'data_needed': None,  # no training data required
    'infra': '$0 (uses existing API)',
    'maintenance': 'update prompts when needed',
    'time_to_production': 'hours to days'
}

Actualité des connaissances : RAG ou réglage fin

Le réglage fin ne peut pas mettre à jour les connaissances en temps réel. Les connaissances d’un modèle réglé finement sont figées au moment de l’entraînement. Pour les cas d’utilisation nécessitant des informations à jour (actualité, tarifs en temps réel, réglementations évolutives), le RAG est toujours préférable, car il peut récupérer des informations récentes au moment de la requête. Le réglage fin excelle pour les connaissances durables qui changent rarement : le style rédactionnel de votre entreprise, la taxonomie de catégorisation de vos produits ou le vocabulaire technique bien établi d’un domaine.

# Decision guide: RAG vs Fine-tuning vs Prompting

def choose_approach(requirements: dict) -> str:
    if requirements.get('knowledge_changes_frequently'):  # pricing, news, live data
        return 'RAG - knowledge must be updatable at query time'
    
    if requirements.get('needs_consistent_format') and requirements.get('high_volume'):
        return 'Fine-tuning - format adherence + cost savings at scale'
    
    if requirements.get('proprietary_domain_vocabulary'):
        return 'Fine-tuning - model needs to learn new terminology'
    
    if requirements.get('low_volume') or requirements.get('still_exploring'):
        return 'Prompting - fastest iteration, lowest cost'
    
    if requirements.get('combination_needed'):  # most production systems
        return 'Fine-tuning for style/format + RAG for dynamic knowledge'

Le cadre de décision idéal pour le réglage fin

Utilisez ce cadre de décision avant de vous engager dans un réglage fin. Premièrement, prouvez que le besoin existe : exécutez votre meilleur prompt sur 1 000 exemples réels et mesurez le taux d’échec. Deuxièmement, quantifiez le bénéfice : estimez le ROI résultant d’une meilleure précision, de coûts de jetons plus faibles ou d’une meilleure latence. Troisièmement, évaluez la faisabilité : disposez-vous d’au moins 500 exemples d’entraînement de haute qualité ? Enfin, comparez les solutions de remplacement : un modèle plus petit associé à un meilleur prompt pourrait-il atteindre les performances d’un modèle plus grand associé à un prompt complexe ?

Combiner prompts et réglage fin

Les meilleurs systèmes en production combinent souvent les deux approches. Utilisez le réglage fin pour les propriétés durables (format de sortie, ton, vocabulaire du domaine) qui changent rarement, et les prompts pour les propriétés dynamiques (contexte de la tâche, documents récupérés, préférences de l’utilisateur) qui varient à chaque requête. Cette combinaison vous offre la fiabilité et l’efficacité en matière de coûts du réglage fin sans sacrifier la flexibilité des prompts.

Vérification rapide

Vérifiez votre compréhension des situations où le réglage fin est préférable aux prompts à partir de cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que les prompts constituent presque toujours le bon point de départ grâce à leur coût plus faible et à l’itération plus rapide, que le réglage fin est préférable pour le respect cohérent du format, les connaissances propres à un domaine et la réduction du coût des jetons à grand volume, et que l’actualité des connaissances relève du domaine du RAG : le réglage fin ne peut pas mettre à jour ce que le modèle sait au moment de l’exécution. Nous allons maintenant préparer un jeu de données d’entraînement de haute qualité pour le réglage fin.

Questions Fréquemment Posées

La leçon « Quand l’ajustement fin est plus efficace que les invites » est-elle gratuite ?

Oui — le texte complet de « Quand l’ajustement fin est plus efficace que les invites » 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 Engineering Academy, passe à CoddyKit PRO. Le cours AI Engineering Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Quand l’ajustement fin est plus efficace que les invites » ?

Identifiez les cas d’usage où l’ajustement fin est plus avantageux que l’ingénierie des invites : respect constant du style, connaissances propres à un domaine, réduction du coût des jetons grâce à d… Tu pratiques AI Engineering Academy 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 Engineering Academy ?

Aucune expérience préalable n'est requise. AI Engineering Academy 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 1 sur 4.

Combien de temps prend la leçon « Quand l’ajustement fin est plus efficace que les invites » ?

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 Engineering Academy ?

Oui. Chaque leçon AI Engineering Academy 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

  1. Quand l’ajustement fin est plus efficace que les invites
  2. Préparer un jeu de données d’entraînement de haute qualité
  3. Ajustement fin LoRA avec Hugging Face PEFT
  4. Évaluer et déployer votre modèle ajusté
← Retour à AI Engineering Academy