Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Few-shot via l'API

Lekce 10 z 16 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Enseigner par l’exemple
  2. Combien d’exemples fournir
  3. Deux usages qui transforment la sortie
  4. Few-shot dynamique
  5. Ce qui fait un bon jeu d’exemples
  6. Klíčové poznatky

Enseigner par l’exemple

Le prompting few-shot consiste à fournir au modèle quelques exemples d’entrée-sortie avant d’envoyer ta requête réelle. Avec l’API Chat Completions, ces exemples n’ont pas d’emplacement dédié : tu les injectes dans l’historique de conversation sous forme de paires de messages user/assistant fictives, comme si l’échange avait réellement eu lieu. Le modèle ne fait aucune différence entre un tour authentique et un tour fabriqué, et c’est précisément ce qui rend cette technique si efficace. Sans fine-tuning, c’est le moyen le plus fiable d’obtenir un format de sortie précis.

L’astuce réside dans une inversion : au lieu de décrire longuement le format attendu dans le prompt système, tu le montres. Pour une tâche de classification de sentiments, trois exemples suffisent pour que le modèle comprenne qu’il doit répondre avec une étiquette en majuscules et rien d’autre.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "You classify the sentiment of customer reviews."
        },
        # Example 1
        {"role": "user", "content": "Review: Fast delivery, product as described. Very satisfied!"},
        {"role": "assistant", "content": "POSITIVE"},
        # Example 2
        {"role": "user", "content": "Review: Package arrived damaged, customer service unreachable."},
        {"role": "assistant", "content": "NEGATIVE"},
        # Example 3
        {"role": "user", "content": "Review: The product is fine but a bit pricey for what it is."},
        {"role": "assistant", "content": "MIXED"},
        # Actual request
        {"role": "user", "content": "Review: Excellent quality, I highly recommend this store."}
    ],
    temperature=0.0
)

print(response.choices[0].message.content)
# POSITIVE

Le modèle a extrait le schéma — avis en entrée, étiquette en majuscules en sortie — et l’a appliqué à la nouvelle entrée. Aucune instruction de formatage n’a été explicitement rédigée : les trois paires ont suffi.

Combien d’exemples fournir

Le nombre d’exemples dépend de la difficulté de la tâche, et tu atteins rapidement des rendements décroissants.

NombreQuand l’utiliser
0 (zero-shot)Tâches simples, gérées naturellement par le modèle
1–2Format de sortie standard (JSON, étiquette)
3–5Classification avec plusieurs catégories
5–10Tâches complexes ou formats très spécifiques

Au-delà de dix exemples, tu consumes beaucoup de jetons d’entrée sans gain proportionnel : chaque requête traîne le même bloc d’exemples, facturé à chaque appel. À ce stade, le fine-tuning devient l’option économiquement sensée.

Deux usages qui transforment la sortie

L’extraction d’entités nommées montre ce que les exemples ajoutent par rapport à un schéma entièrement décrit. Ils verrouillent non seulement les clés JSON, mais aussi la gestion des catégories vides — le deuxième exemple montre explicitement des listes vides au lieu d’un champ manquant, ce qui empêche ton analyseur de rencontrer une structure inattendue.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "Extract named entities in JSON format."
        },
        # Example 1
        {
            "role": "user",
            "content": "Pierre Martin joined Google France in Paris in January 2025."
        },
        {
            "role": "assistant",
            "content": '{"personnes": ["Pierre Martin"], "organisations": ["Google France"], "lieux": ["Paris"], "dates": ["janvier 2025"]}'
        },
        # Example 2
        {
            "role": "user",
            "content": "The VivaTech conference organized by Publicis will take place in June."
        },
        {
            "role": "assistant",
            "content": '{"personnes": [], "organisations": ["Publicis"], "lieux": [], "dates": ["juin"]}'
        },
        # Actual request
        {
            "role": "user",
            "content": "Sophie Leclerc, director at Mistral AI, announced a partnership with Microsoft at the AI Paris show on March 15, 2026."
        }
    ],
    temperature=0.0
)

import json
result = json.loads(response.choices[0].message.content)
print(json.dumps(result, indent=2, ensure_ascii=False))

La transformation de texte suit une logique différente : tu ne transmets pas un schéma, mais un registre de langue. Un seul exemple de simplification — traduire l’architecture des transformateurs en une phrase accessible — enseigne au modèle le niveau d’abstraction souhaité, ce qu’aucune instruction du type « sois pédagogique » ne pourrait atteindre avec cette précision.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {
            "role": "system",
            "content": "Transform technical text into a layperson summary."
        },
        # Example
        {
            "role": "user",
            "content": "The model uses a transformer encoder-decoder architecture with multi-head attention and pre-layer RMS normalization."
        },
        {
            "role": "assistant",
            "content": "This AI system uses advanced technology that lets it understand and generate text by analyzing relationships between words in parallel and efficiently."
        },
        # Actual request
        {
            "role": "user",
            "content": "The API uses nucleus sampling with top_p to truncate the probability distribution of candidate tokens during autoregressive generation."
        }
    ]
)

print(response.choices[0].message.content)

Few-shot dynamique

En production, un jeu d’exemples fixe finit par nuire à la moitié de tes requêtes : des exemples techniques alourdissent inutilement une question de facturation. La solution consiste à constituer une base d’exemples par catégorie, puis à n’injecter que ceux qui correspondent au contexte détecté en amont. La fonction ci-dessous assemble le prompt système, les exemples pour la catégorie et la question réelle dans le bon ordre.

# Example base
EXAMPLES = {
    "technical": [
        {"user": "How do I configure a VPN?", "assistant": "Here are the steps..."},
        {"user": "My server is returning a 502 error.", "assistant": "Error 502..."},
    ],
    "sales": [
        {"user": "What are your rates?", "assistant": "Our plans start at..."},
        {"user": "Is there a trial period?", "assistant": "Yes, 14 days..."},
    ],
    "billing": [
        {"user": "I haven't received my invoice.", "assistant": "Check your..."},
        {"user": "How do I change plans?", "assistant": "Go to..."},
    ]
}

def build_messages(category: str, user_question: str) -> list:
    """Build messages with dynamic few-shot."""
    messages = [
        {"role": "system", "content": "Technical support assistant."}
    ]

    # Add examples for the category
    for ex in EXAMPLES.get(category, []):
        messages.append({"role": "user", "content": ex["user"]})
        messages.append({"role": "assistant", "content": ex["assistant"]})

    # Add the actual question
    messages.append({"role": "user", "content": user_question})
    return messages

# Usage
messages = build_messages("technical", "My Docker deployment is failing.")
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages
)

Ce qui fait un bon jeu d’exemples

Le few-shot échoue le plus souvent par manque de diversité : trois avis entièrement positifs et le modèle classera tout comme POSITIVE. Couvre les cas normaux et les cas limites, y compris un exemple de ce que le modèle ne doit PAS faire — montrer un refus est souvent plus efficace que de l’interdire par une règle. La cohérence de forme compte tout autant : si un exemple renvoie POSITIVE et un autre Positive, tu viens d’apprendre au modèle que la casse est libre.

Deux habitudes complètent l’exercice. Compte les jetons, car chaque exemple est facturé en entrée à chaque appel — un jeu de huit paires devient rapidement le principal poste de coût pour une API de classification à haut volume. Et teste d’abord sans exemples : les modèles récents gèrent en zero-shot des tâches qui nécessitaient cinq exemples il y a deux ans, et tu économiseras ce que tu n’avais pas besoin d’écrire.

Klíčové poznatky

  • Le few-shot injecte de fausses paires user/assistant avant la requête réelle
  • 3 à 5 exemples suffisent pour la plupart des tâches de classification et d’extraction
  • Utilise temperature=0 avec le few-shot pour maximiser la cohérence
  • Le few-shot dynamique sélectionne les exemples pertinents selon le contexte
  • Au-delà de 10 exemples, envisage le fine-tuning plutôt que le few-shot