Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Optimisation de bout en bout : du prompt au réseau

Paskaita 2 iš 20 Atnaujinta 2026 m. lapkričio 3 d. Pažengusiems
Šiame puslapyje
  1. L’optimisation est un système, pas un paramètre
  2. Optimise le prompt
  3. Optimise les paramètres de l’API
  4. Optimise le réseau
  5. Optimise le post-traitement
  6. Svarbiausi punktai

Leçon mise à jour le 3 novembre 2026 sur la base de la documentation OpenAI : temperature et top_p ne sont acceptés qu’avec un effort de raisonnement de none, tandis que les modèles GPT-5.6 raisonnent par défaut (medium). Les appels définissant ces paramètres doivent donc spécifier reasoning={"effort": "none"} (API Responses) ou reasoning_effort="none" (Chat Completions). Sources : Utilisation de GPT-6 · GPT-5.6 Terra.

L’optimisation est un système, pas un paramètre

Réduire la latence et les coûts d’une application LLM ne consiste pas seulement à choisir un modèle plus rapide. C’est une chaîne d’optimisations s’étendant du prompt à la configuration réseau, où le maillon faible dicte la performance de l’ensemble. Une équipe qui divise par deux la taille de son prompt système mais laisse son serveur ouvrir une nouvelle connexion TLS pour chaque requête perdra en surcharge réseau ce qu’elle a économisé en tokens.

L’ordre dans lequel tu abordes ces leviers compte. Commence par le prompt, car il impacte à la fois le coût et la latence sans nécessiter de changements d’infrastructure. Viennent ensuite les paramètres de l’API, puis la configuration réseau, et enfin la manière dont ton application consomme la réponse. Cette leçon te guide à travers chaque levier dans cet ordre.

Optimise le prompt

Chaque token d’entrée coûte du temps et de l’argent, et la plupart des prompts de production traînent des bagages de leur phase de prototypage : des instructions ajoutées une par une, chacune reformulant la précédente. Ton premier réflexe doit être de réécrire le prompt de manière dense, en supprimant les formes d’adresse et les répétitions sans toucher aux contraintes réelles transmises au modèle.

# ❌ Prompt verbeux
prompt_long = """
You are an expert financial analysis assistant. You must always
respond in a professional and structured manner. You must use
numerical data when possible. You must avoid unnecessary jargon.
You must be concise but complete.
Analyze the following quarterly report: ...
"""

# ✅ Prompt optimisé (même résultat, moins de tokens)
prompt_court = """Role: Senior financial analyst.
Constraints: Structured, numerical, concise.
Task: Analyze this quarterly report: ..."""

Les deux versions transmettent exactement les mêmes cinq contraintes ; la seconde le fait sans les cinq phrases « You must » qui n’apportent rien au modèle. Sur un service traitant dix mille rapports par jour, cette réécriture de trente secondes est rentabilisée quotidiennement.

Choisis le bon modèle pour la tâche

Le deuxième levier repose sur le fait que chaque appel ne nécessite pas le même modèle. Router une tâche d’extraction de champ vers un modèle à haut raisonnement signifie payer pour une capacité que la tâche n’utilise pas et attendre plus longtemps pour un résultat identique.

Type de tâcheModèle recommandéRaison
Classification / extractiongpt-5.6-lunaRapide, économique
Raisonnement complexegpt-5.6-terra avec raisonnement mediumMeilleur rapport qualité/coût
Tâches critiquesgpt-5.6-sol avec raisonnement highQualité maximale, plus lent
Haut volumegpt-5.6-luna via Batch API-50 % de coût

En pratique, codifie ce choix dans une fonction de routage plutôt que de le laisser à la discrétion des développeurs ; sinon, le modèle par défaut l’emportera toujours :

import openai

client = openai.OpenAI()

def route_model(task: str, complexity: str) -> str:
    """Sélectionne le modèle optimal en fonction de la tâche."""
    if complexity == "low":
        return "gpt-5.6-luna"
    elif task in ("reasoning", "math", "code"):
        return "gpt-5.6-terra"
    elif complexity == "critical":
        return "gpt-5.6-sol"
    return "gpt-5.6-terra"

def optimized_call(prompt: str, task: str, complexity: str) -> str:
    model = route_model(task, complexity)
    response = client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

Optimise les paramètres de l’API

Une réponse trop longue gaspille du temps de génération que personne ne lira. Spécifie toujours max_output_tokens : c’est une limite stricte qui protège à la fois ta facture et ton interface, empêchant un prompt mal formulé de dériver vers une digression de deux mille mots.

response = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # temperature nécessite effort none
    input="Summarize this text in one sentence.",
    max_output_tokens=100,  # Limite stricte
    temperature=0.0,         # Déterministe = plus rapide
)

Les paramètres d’échantillonnage vont dans le même sens. Définir temperature=0 rend les réponses déterministes et légèrement plus rapides, ce qui est exactement ce que tu veux pour les tâches d’extraction ou de classification où la créativité est une source de variance, pas un atout. Réduire top_p à 0,1 restreint l’espace de recherche et accélère la génération ; réserve ce réglage aux tâches où une seule formulation est acceptable, et conserve les valeurs par défaut lorsque la richesse de la réponse fait partie du produit.

Optimise le réseau

Le coût du voyage des paquets s’additionne à chaque appel, pourtant il reste invisible dans tes métriques d’application. L’API OpenAI est principalement hébergée sur la côte est des États-Unis : placer ton serveur d’application dans la même région que le point de terminaison peut offrir un gain potentiel de 50 à 150 millisecondes de latence réseau. Pour une application conversationnelle, cela représente une fraction significative du temps jusqu’au premier token (TTFT).

Le second gain provient de la réutilisation des connexions. Sans pool, chaque requête rejoue la poignée de main TLS, ajoutant plusieurs allers-retours avant que toute donnée utile ne circule. Configurer un client HTTP une fois pour toutes résout ce problème :

import httpx

# Client avec pool de connexions persistantes
client_http = httpx.Client(
    base_url="https://api.openai.com/v1",
    timeout=60.0,
    limits=httpx.Limits(
        max_connections=20,
        max_keepalive_connections=10,
    ),
)

Optimise le post-traitement

Le dernier maillon est souvent celui que l’on oublie : une application qui reçoit une réponse en streaming mais attend la fin pour l’afficher annule tous les bénéfices du streaming. Traite la réponse au fur et à mesure plutôt qu’après réception complète.

async def progressive_processing(prompt: str):
    """Traite chaque chunk dès son arrivée."""
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True,
    )

    buffer = ""
    for event in stream:
        if event.type == "response.output_text.delta":
            buffer += event.delta
            # Traitement par phrase complète
            if buffer.endswith((".", "!", "?")):
                yield buffer.strip()
                buffer = ""

La découpe par phrase complète est un compromis délibéré : émettre chaque token produit un affichage saccadé, tandis qu’attendre tout le paragraphe recrée la sensation d’attente. La phrase est l’unité que les lecteurs consomment naturellement. Réutilise ce motif chaque fois que ton interface doit afficher, lire à voix haute ou diffuser en continu ce que le modèle produit.

Svarbiausi punktai

  • Optimise d’abord le prompt : moins de tokens = moins de latence et de coût
  • Route vers le bon modèle selon la complexité de la tâche
  • Limite max_output_tokens et utilise temperature=0 quand c’est possible
  • Réutilise les connexions HTTP et traite les réponses via le streaming