Implementace předpovězených výstupů v Pythonu
Na této stránce
Od konceptu k produkčnímu kódu
Chápeš princip předpovězených výstupů (Predicted Outputs) i jejich případy použití. Tato lekce ti poskytne kompletní kód v Pythonu připravený k integraci do tvých aplikací, včetně ošetření chyb a měření výkonu.
Základní implementace
Minimální vzor vyžaduje pouze jeden parametr: prediction, kam předáš očekávaný obsah. Všechno ostatní ve volání zůstává stejné – stejný model, stejné zprávy, stejné zpracování odpovědi. Díky tomu je funkce snadno adoptovatelná a stejně snadno ji odstraníš, pokud metriky nepotvrdí přínos:
from mistralai.client import Mistral
client = Mistral(api_key="your-api-key")
source_code = """
import pandas as pd
def load_data(filepath):
df = pd.read_csv(filepath)
df['date'] = pd.to_datetime(df['date'])
df = df.dropna(subset=['value'])
return df
def compute_stats(df):
return {
'mean': df['value'].mean(),
'median': df['value'].median(),
'std': df['value'].std()
}
"""
prompt = (
"Add a 'separator' parameter to the load_data function "
"(default ',') and use it in read_csv. "
"Respond only with the complete modified code."
)
response = client.chat.complete(
model="codestral-latest",
messages=[
{"role": "user", "content": prompt},
{"role": "user", "content": source_code}
],
prediction={"type": "content", "content": source_code}
)
modified_code = response.choices[0].message.content
print(modified_code)
Pomocná třída pro produkci
Zapouzdření zde nabízí výhody nad rámec čistého kódu: centralizuje rozhodnutí o povolení nebo zakázání předpovědi. Přesně toto nastavení chceš mít možnost okamžitě přepínat. Pokud nasazení odhalí soustavně nesprávné předpovědi, můžeš je vypnout na jediném místě, místo abys hledal tento parametr v celé kódové základně:
from mistralai.client import Mistral
import time
from dataclasses import dataclass
@dataclass
class PredictionResult:
content: str
latency_ms: float
tokens_input: int
tokens_output: int
model: str
class PredictedEditor:
"""Editor obsahu využívající předpovězené výstupy."""
def __init__(self, api_key: str, model: str = "mistral-large-latest"):
self.client = Mistral(api_key=api_key)
self.model = model
def edit(
self,
original: str,
instruction: str,
system_prompt: str | None = None
) -> PredictionResult:
"""Upraví obsah s předpovědí výstupu."""
messages = []
if system_prompt:
messages.append({"role": "system", "content": system_prompt})
messages.extend([
{"role": "user", "content": instruction},
{"role": "user", "content": original}
])
start = time.perf_counter()
response = self.client.chat.complete(
model=self.model,
messages=messages,
prediction={"type": "content", "content": original}
)
latency = (time.perf_counter() - start) * 1000
choice = response.choices[0]
return PredictionResult(
content=choice.message.content,
latency_ms=round(latency, 1),
tokens_input=response.usage.prompt_tokens,
tokens_output=response.usage.completion_tokens,
model=self.model
)
def edit_code(self, code: str, instruction: str) -> PredictionResult:
"""Zkratka pro úpravu kódu."""
return self.edit(
original=code,
instruction=instruction,
system_prompt=(
"You are a programming assistant. "
"Respond only with the modified code, "
"without explanation or markdown."
)
)
def edit_text(self, text: str, instruction: str) -> PredictionResult:
"""Zkratka pro úpravu textu."""
return self.edit(
original=text,
instruction=instruction,
system_prompt=(
"You are a professional text editor. "
"Apply the requested modification while preserving "
"the style and structure of the original text. "
"Respond only with the modified text."
)
)
Použití třídy
editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")
# Úprava kódu
result = editor.edit_code(
code=my_python_file,
instruction="Replace all print() calls with logging.info() calls"
)
print(f"Latency: {result.latency_ms} ms")
print(f"Tokens: {result.tokens_input} in / {result.tokens_output} out")
print(result.content)
Benchmark: S předpovědí vs. bez předpovědi
Tento krok nevynechávej. Přínos předpovězených výstupů závisí výhradně na přesnosti tvých předpovědí, což závisí na tvých datech. Žádné číslo z dokumentace nenahradí měření na tvých vlastních příkladech. Tento skript porovná oba režimy na stejných vstupech a odpověď získáš během vteřin:
import statistics
def benchmark_prediction(
client, model, messages, prediction_content, runs=5
):
"""Porovná latenci s předpovězeným výstupem a bez něj."""
times_normal = []
times_predicted = []
for _ in range(runs):
# Bez předpovědi
start = time.perf_counter()
client.chat.complete(model=model, messages=messages)
times_normal.append((time.perf_counter() - start) * 1000)
# S předpovědí
start = time.perf_counter()
client.chat.complete(
model=model,
messages=messages,
prediction={"type": "content", "content": prediction_content}
)
times_predicted.append((time.perf_counter() - start) * 1000)
avg_normal = statistics.mean(times_normal)
avg_predicted = statistics.mean(times_predicted)
gain_pct = (1 - avg_predicted / avg_normal) * 100
return {
"without_prediction_ms": round(avg_normal, 1),
"with_prediction_ms": round(avg_predicted, 1),
"gain_percentage": round(gain_pct, 1),
"runs": runs
}
Ošetření chyb
Zde je ošetření chyb přímočaré z jednoho strukturálního důvodu: nesprávná předpověď není chyba. Model ji ignoruje a generuje normálně – přicházíš o zisk na latenci, nikdy však o kvalitu. Skutečné hraniční případy leží jinde:
def safe_edit(editor, original, instruction):
"""Úprava s robustním ošetřením chyb."""
try:
result = editor.edit(original, instruction)
# Kontrola, zda odpověď není prázdná
if not result.content or len(result.content.strip()) < 10:
raise ValueError("Response too short or empty")
return result
except Exception as e:
# Záložní řešení: opakování bez předpovědi
print(f"Predicted Output failed ({e}), falling back to standard...")
response = editor.client.chat.complete(
model=editor.model,
messages=[
{"role": "user", "content": instruction},
{"role": "user", "content": original}
]
)
return PredictionResult(
content=response.choices[0].message.content,
latency_ms=0,
tokens_input=response.usage.prompt_tokens,
tokens_output=response.usage.completion_tokens,
model=editor.model
)
Omezení, která musíš znát
Před nasazením integruj do code review tři body. Zaprvé, parametr n (více generací) je nekompatibilní s prediction. Pokud tvůj pipeline požaduje více dokončení, musíš si vybrat. Zadruhé, shodu mezi předpovědí a výstupem zpracovává model bez ohledu na pozici obsahu v odpovědi – nemusíš připravovat žádné zarovnání. A konečně, to je to, co činí tuto funkci bezpečnou pro nasazení: špatná předpověď nikdy nezhorší kvalitu odpovědi; stojí tě pouze zisk na latenci. Nejhorší scénář je prostě návrat k běžné rychlosti na dvou kompatibilních modelech (mistral-large-latest a codestral-latest).
Klíčové poznatky
- Parametr
predictionse jednoduše přidá k voláníchat.complete() - Zapouzdři logiku do znovu použitelné třídy pro produkci
- Před nasazením systematicky měř přínos pomocí benchmarku
- Naplánuj záložní řešení bez předpovědi pro případ chyb
- Špatná předpověď nezhoršuje kvalitu, pouze latenci