Sorties prédites : des réponses plus rapides
På denna sida
Leçon mise à jour le 3 novembre 2026 sur la base du guide Predicted Outputs et de la page de dépréciation d’OpenAI : cette fonctionnalité existe uniquement dans Chat Completions (le paramètre
predictionn’est pas accepté par l’API Responses, donc la version précédente de cette leçon aurait échoué) et seulement avec les modèles GPT-4o, GPT-4o mini, GPT-4.1 et GPT-4.1 mini, qu’OpenAI retirera le 14 janvier 2027 (GPT-4.1 nano a été retiré le 23 octobre). Le guide ne liste aucun modèle plus récent compatible : ne construis pas de nouveaux produits sur cette fonctionnalité sans plan de sortie. Sources : Predicted Outputs · Deprecations.
Accélère les réponses quand tu connais déjà la structure
Les sorties prédites répondent à un scénario de production très courant : tu demandes au modèle de modifier un contenu existant et tu sais à l’avance que la majeure partie du résultat sera identique à l’entrée. Sans prédiction, le modèle régénère chaque jeton depuis zéro, y compris les lignes que personne ne lui a demandé de toucher. Avec la prédiction, tu fournis le texte attendu ; le modèle valide ce qui correspond et ne génère réellement que les parties qui diffèrent. La latence chute en conséquence.
Ce changement modifie particulièrement le profil des tâches d’édition. Un assistant qui réécrit un fichier de deux cents lignes pour changer la signature d’une fonction ne paie plus la génération du fichier entier, mais seulement celle des lignes touchées : la majeure partie du travail se réduit à une comparaison. Les cas pertinents se ressemblent tous : édition de code, où tu envoies le fichier complet pour une modification ciblée ; réécriture partielle, où seul un paragraphe d’un long document doit être reformulé ; complétion de modèle, où seuls les champs variables changent ; et mises à jour de données structurées, où deux ou trois valeurs dans un JSON évoluent tandis que le reste de la structure demeure. Dans chacun de ces cas, la réponse attendue existe déjà avec seulement de légères différences.
Un exemple d’édition de code
L’appel se construit comme un appel Chat Completions standard, augmenté d’un paramètre prediction contenant le contenu que tu anticipes.
import openai
client = openai.OpenAI()
code_original = """
def calculate_price(quantity, unit_price, vat=0.20):
subtotal = quantity * unit_price
total = subtotal * (1 + vat)
return total
def format_invoice(client, items):
lines = []
for item in items:
price = calculate_price(item["qty"], item["price"])
lines.append(f"{item['name']}: {price:.2f}€")
return "\n".join(lines)
"""
# Nous prédisons que la majeure partie du code reste identique
instruction = (
"Modifie la fonction calculate_price pour ajouter un paramètre discount "
"avec une valeur par défaut de 0. Applique la réduction avant la TVA. "
"Réponds uniquement avec du code."
)
completion = client.chat.completions.create(
model="gpt-4.1",
messages=[
{"role": "user", "content": instruction},
{"role": "user", "content": code_original},
],
prediction={
"type": "content",
"content": code_original, # La prédiction
},
)
print(completion.choices[0].message.content)
# Le modèle régénère uniquement les lignes modifiées — latence réduite
La fonction format_invoice n’est pas affectée par la demande : elle sera validée telle quelle, sans coût de génération. Seules les lignes de calculate_price qui intègrent le nouveau paramètre seront réellement produites.
Le mécanisme de validation
Comprendre ce qui se passe sous le capot évite deux malentendus courants. Le modèle compare sa propre génération, jeton par jeton, avec la prédiction que tu as fournie ; tant que les deux correspondent, les jetons sont validés instantanément, contournant le calcul complet de génération. Dès qu’ils divergent, la génération normale prend le relais. Le résultat final reste donc correct : la prédiction accélère les choses, elle ne force rien. Si ta prédiction est fausse, tu obtiens quand même la bonne réponse, simplement sans le gain de performance.
Le second malentendu concerne le prix. Les jetons de prédiction rejetés sont facturés, ce qui rend l’opération contre-productive lorsque la réponse attendue n’a rien à voir avec la prédiction. Par conséquent, mesure le taux d’acceptation avant de généraliser ce motif.
completion = client.chat.completions.create(
model="gpt-4.1",
messages=[
{"role": "user", "content": "Ajoute un paramètre discount à la fonction calculate_price."},
{"role": "user", "content": code_original},
],
prediction={
"type": "content",
"content": code_original,
},
)
usage = completion.usage
print(f"Jeton de sortie : {usage.completion_tokens}")
print(f"Jeton acceptés (prédiction) : "
f"{usage.completion_tokens_details.accepted_prediction_tokens}")
print(f"Jeton rejetés (prédiction) : "
f"{usage.completion_tokens_details.rejected_prediction_tokens}")
# Plus le ratio acceptés/total est élevé, plus le gain est important
Décider automatiquement
Puisque le gain dépend entièrement du type de demande, la décision d’activer ou non la prédiction doit être codifiée plutôt que laissée à chaque développeur. L’heuristique ci-dessous refuse la prédiction sur des textes trop courts, où la surcharge de l’envoi annule le bénéfice, et la réserve aux instructions exprimant une modification.
def should_use_prediction(original_text: str, instruction: str) -> bool:
"""Heuristique pour décider si les sorties prédites en valent la peine."""
# Le texte doit être assez long
if len(original_text) < 200:
return False
# L'instruction doit être une modification ciblée
edit_words = ["modify", "change", "replace", "add", "fix"]
is_edit = any(word in instruction.lower() for word in edit_words)
return is_edit
Le même raisonnement s’applique aux données structurées, où le rendement est encore meilleur : un JSON de configuration conserve ses clés, son indentation et son ordre, et seules les valeurs bougent.
import json
original_data = {
"company": "Corsen AI",
"employees": 42,
"departments": ["Engineering", "Sales", "Marketing"],
"address": {
"street": "123 Avenue de la République",
"city": "Paris",
"zip_code": "75011",
},
}
json_original = json.dumps(original_data, indent=2, ensure_ascii=False)
completion = client.chat.completions.create(
model="gpt-4.1",
messages=[
{"role": "user", "content": (
"Mets à jour le JSON suivant : change le nombre d'employés "
"à 58 et ajoute le département Data Science. Réponds uniquement avec du JSON."
)},
{"role": "user", "content": json_original},
],
prediction={
"type": "content",
"content": json_original,
},
)
Trois mises en garde avant le déploiement. Le streaming est compatible, et c’est même là que le gain de latence est le plus noticeable. Plusieurs paramètres ne le sont cependant pas : n supérieur à 1, logprobs, presence_penalty ou frequency_penalty positifs, l’audio, les modalités autres que le texte, max_completion_tokens, et les outils (appel de fonction). Enfin, la fonctionnalité est liée à des modèles en fin de vie : GPT-4o, GPT-4o mini, GPT-4.1 et GPT-4.1 mini s’arrêtent le 14 janvier 2027, et aucun modèle plus récent n’est annoncé comme compatible. Pour une édition rapide sur les modèles actuels, la voie durable consiste à demander au modèle un diff ou un patch plutôt que le fichier entier.
Viktiga punkter
- Les sorties prédites accélèrent les réponses quand tu connais la structure attendue — uniquement dans Chat Completions
- Idéal pour l’édition de code, les mises à jour JSON, la réécriture partielle
- Vérifie
accepted_prediction_tokenspour mesurer le gain réel - Les jetons de prédiction rejetés sont facturés : ne prédit pas au hasard
- Ne les utilise pas pour des générations entièrement nouvelles
- Les modèles compatibles (GPT-4o, GPT-4.1 et leurs versions mini) sont retirés le 14 janvier 2027 : prévois une alternative, comme la génération de diff