Predicted Outputs : réponses accélérées

Accélérer les réponses quand vous connaissez déjà la structure

Les Predicted Outputs répondent à une situation très fréquente en production : vous demandez au modèle de modifier un contenu existant, et vous savez d’avance que l’essentiel du résultat sera identique à l’entrée. Sans prédiction, le modèle régénère chaque token depuis zéro, y compris les lignes que personne ne lui a demandé de toucher. Avec une prédiction, vous lui fournissez le texte attendu, il valide ce qui correspond et ne génère réellement que les parties qui diffèrent. La latence baisse d’autant.

Cette bascule change surtout le profil des tâches d’édition. Un assistant qui réécrit un fichier de deux cents lignes pour changer une signature de fonction ne paie plus la génération de tout le fichier, mais seulement celle des lignes touchées : l’essentiel du travail se réduit à une comparaison. Les cas concernés se ressemblent tous : l’édition de code, où vous envoyez le fichier complet pour une modification ciblée ; la réécriture partielle, où un seul paragraphe d’un document long doit être reformulé ; la complétion de templates, dont seuls les champs variables changent ; et la mise à jour de données structurées, où deux ou trois valeurs d’un JSON évoluent pendant que le reste de la structure demeure. Dans chacun de ces cas, la réponse attendue existe déjà à quelques différences près.

Un exemple d’édition de code

L’appel se construit comme un appel ordinaire, augmenté d’un paramètre prediction qui porte le contenu que vous anticipez.

import openai

client = openai.OpenAI()

code_original = """
def calculer_prix(quantite, prix_unitaire, tva=0.20):
    sous_total = quantite * prix_unitaire
    total = sous_total * (1 + tva)
    return total

def formater_facture(client, articles):
    lignes = []
    for article in articles:
        prix = calculer_prix(article["qte"], article["prix"])
        lignes.append(f"{article[nom]}: {prix:.2f}€")
    return "\n".join(lignes)
"""

# On prédit que la majeure partie du code reste identique
response = client.responses.create(
    model="gpt-5.6-terra",
    input=(
        "Modifiez la fonction calculer_prix pour ajouter un paramètre "
        "de remise (discount) avec une valeur par défaut de 0. "
        "Appliquez la remise avant la TVA."
    ),
    prediction={
        "type": "content",
        "content": code_original,  # La prédiction
    },
)

print(response.output_text)
# Le modèle ne régénère que les lignes modifiées — latence réduite

La fonction formater_facture n’est pas concernée par la demande : elle sera validée telle quelle, sans coût de génération. Seules les lignes de calculer_prix qui accueillent 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, token par token, avec la prédiction que vous avez fournie ; tant que les deux coïncident, les tokens sont validés instantanément, sans passer par le calcul de génération complet. Dès qu’ils divergent, la génération normale reprend la main. Le résultat final reste donc toujours correct : la prédiction accélère, elle ne force rien. Si votre prédiction est mauvaise, vous obtenez la bonne réponse malgré tout, simplement sans gain.

Le second malentendu concerne le prix. Les tokens 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. Mesurez donc le taux d’acceptation avant de généraliser le pattern.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Ajoutez un paramètre discount à la fonction calculer_prix.",
    prediction={
        "type": "content",
        "content": code_original,
    },
)

usage = response.usage
print(f"Tokens de sortie : {usage.output_tokens}")
print(f"Tokens acceptés (prédiction) : "
      f"{usage.output_tokens_details.accepted_prediction_tokens}")
print(f"Tokens rejetés (prédiction) : "
      f"{usage.output_tokens_details.rejected_prediction_tokens}")

# Plus le ratio accepté/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 gagne à être codifiée plutôt que laissée à chaque développeur. L’heuristique ci-dessous refuse la prédiction sur les textes trop courts, où le surcoût d’envoi annule le bénéfice, et la réserve aux instructions qui expriment une modification.

def doit_utiliser_prediction(texte_original: str, instruction: str) -> bool:
    """Heuristique pour décider si les Predicted Outputs valent le coup."""
    # Le texte doit être suffisamment long
    if len(texte_original) < 200:
        return False

    # L'instruction doit être une modification ciblée
    mots_edition = ["modifiez", "changez", "remplacez", "ajoutez", "corrigez"]
    est_edition = any(mot in instruction.lower() for mot in mots_edition)

    return est_edition

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

donnees_originales = {
    "entreprise": "Corsen AI",
    "employes": 42,
    "departements": ["Engineering", "Sales", "Marketing"],
    "adresse": {
        "rue": "123 Avenue de la République",
        "ville": "Paris",
        "code_postal": "75011",
    },
}

json_original = json.dumps(donnees_originales, indent=2, ensure_ascii=False)

response = client.responses.create(
    model="gpt-5.6-terra",
    input=(
        f"Mettez à jour le JSON suivant : changez le nombre d'employés "
        f"à 58 et ajoutez le département Data Science.\n\n{json_original}"
    ),
    prediction={
        "type": "content",
        "content": json_original,
    },
)

Deux réserves avant de déployer. La compatibilité avec le streaming de tokens n’est pas garantie dans tous les cas : testez votre configuration exacte plutôt que de supposer. Et la compatibilité des modèles se vérifie : les modèles de raisonnement dédiés de la génération précédente, o3-pro et o4-mini, ne supportaient pas les Predicted Outputs, donc consultez la documentation officielle pour le modèle que vous utilisez réellement.

Points clés à retenir

• Les Predicted Outputs accélèrent les réponses quand vous connaissez la structure attendue
• Idéal pour l’édition de code, la mise à jour de JSON, la réécriture partielle
• Vérifiez accepted_prediction_tokens pour mesurer le gain réel
• Les tokens de prédiction rejetés sont facturés : ne prédisez pas au hasard
• Ne les utilisez pas pour des générations entièrement nouvelles