Cas d'Usage Concrets des Predicted Outputs

Trois familles de cas d’usage

Le critère qui unit les trois familles de cette leçon tient en une phrase : les Predicted Outputs sont rentables quand la majorité de la sortie est connue d’avance. Ce n’est pas la nature de la tâche qui compte — code, texte ou template — c’est la proportion du résultat que vous pouvez fournir comme prédiction. À 90 % de contenu inchangé, le gain est spectaculaire ; à 30 %, il devient négligeable, quel que soit le cas d’usage.

Gardez ce ratio en tête en parcourant les trois familles : elles ne sont que des situations où il est naturellement élevé. Dans cette leçon, vous découvrirez des exemples concrets pour chaque catégorie, avec les patterns à reproduire dans vos propres applications.

Cas 1 : Édition de code

C’est le cas d’usage le plus naturel, parce que le code maximise mécaniquement le ratio : un renommage de variable dans un fichier de 500 lignes laisse 498 lignes strictement identiques. Vous avez un fichier source existant et vous voulez y apporter une modification ciblée. Le modèle n’a besoin de régénérer que les lignes modifiées.

Renommer une variable

code_existant = """
def calculate_total(items):
    tax_rate = 0.20
    subtotal = sum(item.price for item in items)
    tax = subtotal * tax_rate
    total = subtotal + tax
    return total
"""

prompt = (
    "Renommez la variable 'tax_rate' en 'vat_rate' partout dans ce code. "
    "Répondez uniquement avec le code modifié."
)

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {"role": "user", "content": prompt},
        {"role": "user", "content": code_existant}
    ],
    prediction={"type": "content", "content": code_existant}
)

Le modèle sait que la structure du code reste identique. Il ne recalcule que les tokens affectés par le renommage.

Changer un import ou une dépendance

code_existant = """
from flask import Flask, request, jsonify
from flask_cors import CORS

app = Flask(__name__)
CORS(app)

@app.route('/api/predict', methods=['POST'])
def predict():
    data = request.get_json()
    result = model.predict(data['input'])
    return jsonify({'prediction': result})
"""

prompt = (
    "Migrez ce code de Flask vers FastAPI. "
    "Conservez la même logique métier. "
    "Répondez uniquement avec le code."
)

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {"role": "user", "content": prompt},
        {"role": "user", "content": code_existant}
    ],
    prediction={"type": "content", "content": code_existant}
)

Cas 2 : Modification de texte

Le texte suit la même logique que le code, avec une nuance qui mérite attention : les modifications textuelles sont souvent moins localisées qu’on ne le croit. Changer un chiffre dans un rapport peut entraîner la réécriture de la phrase qui le commente, du paragraphe de synthèse et de la conclusion. Le gain reste réel, mais mesurez-le sur vos documents réels plutôt que de le supposer équivalent à celui du code.

Mise à jour d’une section dans un rapport

rapport = """
# Rapport trimestriel Q4 2025

## Résumé exécutif
Le chiffre d'affaires a atteint 2,3M EUR au Q4 2025, en hausse de 15 %
par rapport au Q3. La marge opérationnelle s'établit à 22 %.

## Performances commerciales
L'équipe commerciale a signé 47 nouveaux contrats, dont 12 grands comptes.
Le panier moyen progresse de 8 % à 49 000 EUR.

## Perspectives Q1 2026
Nous anticipons une croissance de 10 % portée par le lancement du
produit Enterprise et l'expansion sur le marché allemand.
"""

prompt = (
    "Mettez à jour ce rapport pour le Q1 2026 avec les données suivantes : "
    "CA = 2,7M EUR (+17 %), marge = 24 %, 53 nouveaux contrats, "
    "panier moyen = 51 000 EUR (+4 %). "
    "Pour les perspectives Q2, mentionnez l'expansion au Benelux. "
    "Gardez exactement la même structure."
)

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": prompt},
        {"role": "user", "content": rapport}
    ],
    prediction={"type": "content", "content": rapport}
)

Cas 3 : Remplissage de templates

Quand vous avez un template fixe où seules quelques valeurs changent, la prédiction est quasi parfaite :

template_email = """
Bonjour {nom},

Suite à notre échange du {date}, je vous confirme les points suivants :

1. Le projet {projet} démarrera le {date_debut}
2. L'équipe sera composée de {nb_personnes} personnes
3. Le budget prévisionnel s'élève à {budget} EUR HT

Je reste à votre disposition pour toute question.

Cordialement,
{signataire}
"""

# Remplir partiellement le template pour la prédiction
prediction = template_email.replace("{nom}", "M. Dupont")
prediction = prediction.replace("{signataire}", "Marie Martin")

prompt = (
    "Complétez cet email avec les informations suivantes : "
    "date = 28 mars 2026, projet = Migration Cloud, "
    "date_debut = 15 avril 2026, nb_personnes = 5, "
    "budget = 85 000."
)

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[
        {"role": "user", "content": prompt},
        {"role": "user", "content": prediction}
    ],
    prediction={"type": "content", "content": prediction}
)

Mesurer le gain réel

Pour évaluer l’efficacité des Predicted Outputs dans votre cas d’usage, comparez systématiquement avec et sans prédiction :

import time

# Sans prédiction
start = time.time()
resp_normal = client.chat.complete(
    model="mistral-large-latest",
    messages=messages
)
time_normal = time.time() - start

# Avec prédiction
start = time.time()
resp_predicted = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    prediction={"type": "content", "content": contenu_predit}
)
time_predicted = time.time() - start

gain = (1 - time_predicted / time_normal) * 100
print(f"Sans prédiction : {time_normal:.2f}s")
print(f"Avec prédiction : {time_predicted:.2f}s")
print(f"Gain de latence  : {gain:.1f} %")

Le gain varie selon le pourcentage de contenu correctement prédit. Pour une modification de 5 % d’un fichier de 500 lignes, attendez-vous à un gain de 60 à 80 % sur la latence.

Points clés à retenir

• L’édition de code (renommage, migration, refactoring léger) est le cas d’usage principal
• La modification de texte (rapports, documents) profite de la structure stable
• Les templates avec quelques valeurs dynamiques offrent le meilleur ratio gain/effort
• Mesurez toujours le gain réel dans votre contexte avant de déployer en production