Implementera förutsägda utdata i Python
På denna sida
Från koncept till produktionskod
Du förstår principen bakom förutsägda utdata (Predicted Outputs) och deras användningsområden. Denna lektion ger dig komplett Python-kod redo att integreras i dina applikationer, inklusive felhantering och prestandamätning.
Grundläggande implementering
Det minimala mönstret kräver bara en parameter: prediction, där du anger det förväntade innehållet. Allt annat i anropet förblir oförändrat – samma modell, samma meddelanden, samma hantering av svar. Detta gör funktionen enkel att införa och lika enkel att ta bort om mätvärdena inte bekräftar någon vinst:
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älpklass för produktion
Kapsling här erbjuder fördelar utöver ren kod: den centraliserar beslutet att aktivera eller inaktivera förutsägelse. Det här är exakt den typ av inställning du vill kunna växla omedelbart. Om en distribution avslöjar konsekvent felaktiga förutsägelser kan du inaktivera dem på ett enda ställe istället för att leta efter parametern i hela din kodbas:
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:
"""Innehållsredigerare med förutsägda utdata."""
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:
"""Redigerar innehåll med utdataprognos."""
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:
"""Genväg för kodredigering."""
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:
"""Genväg för textredigering."""
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."
)
)
Använda klassen
editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")
# Redigera kod
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)
Prestandatest: Med kontra utan förutsägelse
Hoppa inte över detta steg. Vinsten med förutsägda utdata beror helt på noggrannheten i dina förutsägelser, vilket i sin tur beror på din data. Inga siffror från dokumentationen ersätter mätningar på dina egna exempel. Detta skript jämför båda lägena på samma indata och ger dig svaret på några sekunder:
import statistics
def benchmark_prediction(
client, model, messages, prediction_content, runs=5
):
"""Jämför latens med och utan förutsagt utdata."""
times_normal = []
times_predicted = []
for _ in range(runs):
# Utan förutsägelse
start = time.perf_counter()
client.chat.complete(model=model, messages=messages)
times_normal.append((time.perf_counter() - start) * 1000)
# Med förutsägelse
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
}
Felhantering
Felhanteringen är enkel här av en strukturell anledning: en felaktig förutsägelse är inte ett fel. Modellen ignorerar den och genererar normalt – du förlorar latensvinsten, men aldrig kvaliteten. De verkliga undantagsfallen finns någon annanstans:
def safe_edit(editor, original, instruction):
"""Redigering med robust felhantering."""
try:
result = editor.edit(original, instruction)
# Kontrollera att svaret inte är 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: försök igen utan förutsägelse
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änsningar att känna till
Innan du distribuerar bör du integrera tre punkter i din kodgranskning. För det första är parametern n (flera genereringar) inkompatibel med prediction. Om din pipeline begär flera kompletteringar måste du välja. För det andra hanteras matchningen mellan förutsägelse och utdata av modellen oavsett innehållets position i svaret – du behöver inte förbereda någon justering. Slutligen, och detta är vad som gör funktionen säker att distribuera: en dålig förutsägelse försämrar aldrig svarskvaliteten; den kostar dig bara latensvinsten. Värsta fall är helt enkelt en återgång till normal hastighet på de två kompatibla modellerna (mistral-large-latest och codestral-latest).
Viktiga punkter
- Parametern
predictionläggs helt enkelt till i anropetchat.complete() - Kapsla in logiken i en återanvändbar klass för produktion
- Mät vinsten systematiskt med ett prestandatest innan distribution
- Planera en fallback utan förutsägelse vid fel
- En dålig förutsägelse försämrar inte kvaliteten, bara latensen