Implementacija napovedanih izhodov v Pythonu
Na tej strani
Od koncepta do produkcijske kode
Razumeš načelo delovanja napovedanih izhodov in njihove primere uporabe. Ta lekcija ti ponuja popolno kodo v Pythonu, pripravljeno za integracijo v tvoje aplikacije, vključno z obravnavo napak in merjenjem zmogljivosti.
Osnovna implementacija
Najenostavnejši vzorec zahteva le en parameter: prediction, kamor podaš pričakovano vsebino. Vse ostalo v klicu ostane nespremenjeno – isti model, ista sporočila, enako obravnavanje odgovora. To omogoča enostavno uvedbo funkcije in prav tako enostavno odstranitev, če metrike ne potrdijo izboljšav:
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)
Pomožni razred za produkcijsko okolje
Zapiranje kode v razred prinaša prednosti, ki presegajo zgolj čisto kodo: centralizira odločitev o vklopu ali izklopu napovedovanja. To je točno tista vrsta nastavitve, ki jo želiš takoj preklopiti. Če uvedba razkrije dosledno napačne napovedi, jih lahko onemogočiš na enem samem mestu, namesto da bi parameter lovili po celotni kodi:
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:
"""Urejevalnik vsebine z uporabo napovedanih izhodov."""
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:
"""Uredi vsebino z napovedjo izhoda."""
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:
"""Bližnjica za urejanje 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:
"""Bližnjica za urejanje besedila."""
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."
)
)
Uporaba razreda
editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")
# Uredi kodo
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)
Merjenje zmogljivosti: z napovedjo in brez nje
Tega koraka ne preskoči. Dobitek od napovedanih izhodov je v celoti odvisen od natančnosti tvojih napovedi, kar je odvisno od tvojih podatkov. Nobena številka iz dokumentacije ne more nadomestiti merjenja na tvojih lastnih primerih. Ta skripta primerja oba načina na istih vhodnih podatkih in ti odgovor poda v nekaj sekundah:
import statistics
def benchmark_prediction(
client, model, messages, prediction_content, runs=5
):
"""Primerja latenco z napovedanim izhodom in brez njega."""
times_normal = []
times_predicted = []
for _ in range(runs):
# Brez napovedi
start = time.perf_counter()
client.chat.complete(model=model, messages=messages)
times_normal.append((time.perf_counter() - start) * 1000)
# Z napovedjo
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
}
Obravnava napak
Obravnava napak je tu preprosta zaradi strukturnega razloga: napačna napoved ni napaka. Model jo ignorira in generira odgovor normalno – izgubiš pridobitev pri latenci, nikoli pa ne kakovosti. Pravi robni primeri se skrivajo drugje:
def safe_edit(editor, original, instruction):
"""Urejanje z robustno obravnavo napak."""
try:
result = editor.edit(original, instruction)
# Preveri, ali odgovor ni prazen
if not result.content or len(result.content.strip()) < 10:
raise ValueError("Response too short or empty")
return result
except Exception as e:
# Nadomestilo: ponovni poskus brez napovedi
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
)
Omejitve, ki jih moraš poznati
Pred uvedbo v svojo kodo vključi tri ključne točke. Prvič, parameter n (več generacij) ni združljiv s prediction. Če tvoja cevovodna obdelava zahteva več zaključkov, se moraš odločiti za enega. Drugič, ujemanje med napovedjo in izhodom obravnava model ne glede na položaj vsebine v odgovoru – ni treba pripravljati nobenega poravnavanja. Nazadnje, in to je tisto, zaradi česar je funkcija varna za uvedbo: slaba napoved nikoli ne poslabša kakovosti odgovora; stane te le izgubo pri latenci. Najslabši scenarij je preprosto vrnitev na običajno hitrost pri dveh združljivih modelih (mistral-large-latest in codestral-latest).
Ključne ugotovitve
- Parameter
predictionpreprosto dodaš klicuchat.complete() - Logiko zapri v ponovno uporaben razred za produkcijsko okolje
- Pred uvedbo sistematično izmeri pridobitek z merjenjem zmogljivosti
- Načrtuj nadomestilo brez napovedi za primer napak
- Slaba napoved ne poslabša kakovosti, vpliva le na latenco