Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Cas d'usage concrets pour les sorties prédites

Lekcija 6 od 16 Ažurirano 29. srpnja 2026. Napredno
Na ovoj stranici
  1. Trois familles de cas d’usage
  2. Cas d’usage 1 : Édition de code
  3. Cas d’usage 2 : Édition de texte
  4. Cas d’usage 3 : Remplissage de modèles
  5. Mesurer les gains réels
  6. Ključne točke

Trois familles de cas d’usage

Le fil conducteur de ces trois familles est simple : les sorties prédites sont rentables lorsque la majeure partie du résultat est connue à l’avance. La nature de la tâche — code, texte ou modèle — importe moins que la proportion du résultat que tu peux fournir en tant que prédiction. Avec 90 % de contenu inchangé, le gain est spectaculaire ; à 30 %, il devient négligeable, quel que soit le cas d’usage.

Garde ce ratio en tête en explorant les trois familles ci-dessous. Elles représentent des scénarios où ce ratio est naturellement élevé. Dans cette leçon, tu verras des exemples concrets pour chaque catégorie, ainsi que des motifs que tu pourras répliquer dans tes propres applications.

Cas d’usage 1 : Édition de code

C’est l’adéquation la plus naturelle car le code maximise mécaniquement le ratio : renommer une variable dans un fichier de 500 lignes laisse 498 lignes strictement identiques. Tu pars d’un fichier source existant et souhaites apporter une modification ciblée. Le modèle n’a besoin de régénérer que les lignes modifiées.

Renommer une variable

existing_code = """
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 = (
    "Rename the variable 'tax_rate' to 'vat_rate' throughout this code. "
    "Reply with only the modified code."
)

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

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

Changer une importation ou une dépendance

existing_code = """
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 = (
    "Migrate this code from Flask to FastAPI. "
    "Keep the same business logic. "
    "Reply with only the code."
)

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

Cas d’usage 2 : Édition de texte

Le texte suit la même logique que le code, avec une nuance importante : les modifications de texte sont souvent moins localisées qu’on ne le pense. Changer un chiffre dans un rapport peut déclencher la réécriture de la phrase qui le commente, du paragraphe de résumé et de la conclusion. Le gain est réel, mais mesure-le sur tes documents réels plutôt que de supposer qu’il égale celui observé avec le code.

Mettre à jour une section d’un rapport

report = """
# Q4 2025 Quarterly Report

## Executive Summary
Revenue reached €2.3M in Q4 2025, up 15%
from Q3. Operating margin stands at 22%.

## Sales Performance
The sales team signed 47 new contracts, including 12 key accounts.
Average deal size grew 8% to €49,000.

## Q1 2026 Outlook
We anticipate 10% growth driven by the launch of the
Enterprise product and expansion into the German market.
"""

prompt = (
    "Update this report for Q1 2026 with the following data: "
    "Revenue = €2.7M (+17%), margin = 24%, 53 new contracts, "
    "average deal size = €51,000 (+4%). "
    "For the Q2 outlook, mention expansion into the Benelux region. "
    "Keep the exact same structure."
)

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

Cas d’usage 3 : Remplissage de modèles

Lorsque tu disposes d’un modèle fixe où seules quelques valeurs changent, la prédiction est quasi parfaite :

email_template = """
Hello {name},

Following up on our conversation on {date}, I confirm the following points:

1. The {project} project will start on {start_date}
2. The team will consist of {num_people} people
3. The estimated budget is €{budget} (excl. tax)

I remain at your disposal for any questions.

Best regards,
{signatory}
"""

# Partially fill the template for prediction
prediction = email_template.replace("{name}", "Mr. Dupont")
prediction = prediction.replace("{signatory}", "Marie Martin")

prompt = (
    "Complete this email with the following information: "
    "date = March 28, 2026, project = Cloud Migration, "
    "start_date = April 15, 2026, num_people = 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 les gains réels

Pour évaluer l’efficacité des sorties prédites pour ton cas d’usage, compare systématiquement les exécutions avec et sans prédiction :

import time

# Without prediction
start = time.time()
resp_normal = client.chat.complete(
    model="mistral-large-latest",
    messages=messages
)
time_normal = time.time() - start

# With prediction
start = time.time()
resp_predicted = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    prediction={"type": "content", "content": predicted_content}
)
time_predicted = time.time() - start

gain = (1 - time_predicted / time_normal) * 100
print(f"Without prediction: {time_normal:.2f}s")
print(f"With prediction: {time_predicted:.2f}s")
print(f"Latency gain     : {gain:.1f}%")

Le gain varie selon le pourcentage de contenu correctement prédit. Pour une modification de 5 % dans un fichier de 500 lignes, attends-toi à une réduction de latence de 60 % à 80 %.

Ključne točke

  • L’édition de code (renommage, migration, refactoring léger) est le cas d’usage principal
  • L’édition de texte (rapports, documents) bénéficie d’une structure stable
  • Les modèles avec quelques valeurs dynamiques offrent le meilleur rapport gain/effort
  • Mesure toujours le gain réel dans ton contexte avant de déployer en production