Implementér forudsagte output i Python
På denne side
Fra koncept til produktionskode
Du forstår princippet bag forudsagte output og deres anvendelsestilfælde. Denne lektion giver dig komplet Python-kode, der er klar til integration i dine applikationer, inklusive fejlhåndtering og måling af ydeevne.
Basisimplementering
Det minimale mønster kræver kun én parameter: prediction, hvor du angiver det forventede indhold. Alt andet i kaldet forbliver uændret – samme model, samme beskeder, samme håndtering af svar. Det gør funktionen nem at tage i brug og lige så nem at fjerne, hvis målinger ikke bekræfter gevinsten:
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)
Hjælpeklasse til produktion
Her giver indkapsling fordele ud over ren kode: den centraliserer beslutningen om at aktivere eller deaktivere forudsigelse. Det er præcis den type indstilling, du ønsker at kunne skifte øjeblikkeligt. Hvis en udrulning afslører konsekvent forkerte forudsigelser, kan du deaktivere dem ét sted i stedet for at lede efter parameteren gennem hele din kodebase:
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:
"""Indholdsredigering ved hjælp af forudsagte output."""
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:
"""Redigerer indhold med output-forudsigelse."""
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:
"""Genvej til redigering af kode."""
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:
"""Genvej til redigering af tekst."""
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."
)
)
Brug af klassen
editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")
# Rediger kode
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: Med kontra uden forudsigelse
Spring ikke dette trin over. Gevinsten ved forudsagte output afhænger udelukkende af nøjagtigheden af dine forudsigelser, hvilket igen afhænger af dine data. Ingen tal fra dokumentationen erstatter måling på dine egne eksempler. Dette script sammenligner begge tilstande på de samme input og giver dig svaret på få sekunder:
import statistics
def benchmark_prediction(
client, model, messages, prediction_content, runs=5
):
"""Sammenligner ventetid med og uden forudsagt output."""
times_normal = []
times_predicted = []
for _ in range(runs):
# Uden forudsigelse
start = time.perf_counter()
client.chat.complete(model=model, messages=messages)
times_normal.append((time.perf_counter() - start) * 1000)
# Med forudsigelse
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
}
Fejlhåndtering
Fejlhåndtering er ligetil her af en strukturel årsag: En forkert forudsigelse er ikke en fejl. Modellen ignorerer den og genererer normalt – du mister gevinsten i ventetid, men aldrig kvaliteten. De reelle kanttilfælde ligger andre steder:
def safe_edit(editor, original, instruction):
"""Redigering med robust fejlhåndtering."""
try:
result = editor.edit(original, instruction)
# Tjek at svaret ikke er tomt
if not result.content or len(result.content.strip()) < 10:
raise ValueError("Response too short or empty")
return result
except Exception as e:
# Fallback: genforsøg uden forudsigelse
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
)
Begrænsninger du skal kende
Før udrulning skal du integrere tre punkter i din kodegennemgang. For det første er parameteren n (flere generationer) uforenelig med prediction. Hvis din pipeline anmoder om flere fuldførelser, skal du vælge. For det andet håndteres matchet mellem forudsigelse og output af modellen uanset indholdets position i svaret – du behøver ikke forberede nogen justering. Endelig, og det er det, der gør funktionen sikker at udrulle: En dårlig forudsigelse forringer aldrig svarets kvalitet; det koster dig kun gevinsten i ventetid. Værste tilfælde er simpelthen en tilbagevenden til normal hastighed på de to kompatible modeller (mistral-large-latest og codestral-latest).
Vigtige pointer
- Parameteren
predictiontilføjes blot til kaldetchat.complete() - Indkapsl logikken i en genanvendelig klasse til produktion
- Mål systematisk gevinsten med et benchmark før udrulning
- Planlæg en fallback uden forudsigelse i tilfælde af fejl
- En dårlig forudsigelse forringer ikke kvaliteten, kun ventetiden