Implementarea ieșirilor prezise în Python
Pe această pagină
De la concept la cod de producție
Ați înțeles principiul din spatele ieșirilor prezise (Predicted Outputs) și cazurile lor de utilizare. Această lecție oferă cod Python complet, gata de integrare în aplicațiile dumneavoastră, inclusiv gestionarea erorilor și măsurarea performanței.
Implementare de bază
Modelul minimal necesită un singur parametru: prediction, prin care transmiteți conținutul așteptat. Restul apelului rămâne neschimbat—același model, aceleași mesaje, aceeași gestionare a răspunsului. Acest lucru face ca funcționalitatea să fie ușor de adoptat și la fel de ușor de eliminat dacă metricile nu confirmă câștigul:
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)
Clasă utilitară pentru producție
Encapsularea oferă aici avantaje dincolo de un cod curat: centralizează decizia de a activa sau dezactiva predicția. Acesta este exact genul de setare pe care doriți să o comutați instantaneu. Dacă o implementare relevă predicții constant incorecte, le puteți dezactiva într-un singur punct, în loc să căutați parametrul în întreaga bază de cod:
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 de conținut folosind ieșiri prezise."""
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:
"""Editează conținutul cu predicția ieșirii."""
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:
"""Scurtătură pentru editarea codului."""
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:
"""Scurtătură pentru editarea textului."""
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."
)
)
Utilizarea clasei
editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")
# Editare cod
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: Cu versus fără predicție
Nu săriți peste acest pas. Câștigul oferit de ieșirile prezise depinde în totalitate de acuratețea predicțiilor dumneavoastră, care la rândul lor depind de datele dumneavoastră. Nicio cifră din documentație nu înlocuiește măsurarea pe propriile exemple. Acest script compară ambele moduri pe aceleași intrări, oferindu-vă răspunsul în câteva secunde:
import statistics
def benchmark_prediction(
client, model, messages, prediction_content, runs=5
):
"""Compară latența cu și fără ieșire prezisă."""
times_normal = []
times_predicted = []
for _ in range(runs):
# Fără predicție
start = time.perf_counter()
client.chat.complete(model=model, messages=messages)
times_normal.append((time.perf_counter() - start) * 1000)
# Cu predicție
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
}
Gestionarea erorilor
Gestionarea erorilor este simplă aici dintr-un motiv structural: o predicție incorectă nu constituie o eroare. Modelul o ignoră și generează normal—pierdeți câștigul de latență, niciodată calitatea. Cazurile limită reale se află în altă parte:
def safe_edit(editor, original, instruction):
"""Editare cu gestionare robustă a erorilor."""
try:
result = editor.edit(original, instruction)
# Verifică dacă răspunsul nu este gol
if not result.content or len(result.content.strip()) < 10:
raise ValueError("Response too short or empty")
return result
except Exception as e:
# Fallback: reîncearcă fără predicție
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
)
Constrângeri de cunoscut
Înainte de implementare, integrați trei puncte în revizuirea codului dumneavoastră. În primul rând, parametrul n (generări multiple) este incompatibil cu prediction. Dacă pipeline-ul dumneavoastră solicită mai multe completări, trebuie să faceți o alegere. În al doilea rând, corespondența dintre predicție și ieșire este gestionată de model indiferent de poziția conținutului în răspuns—nu trebuie să pregătiți nicio aliniere. În final, și acesta este aspectul care face ca funcționalitatea să fie sigură pentru implementare: o predicție slabă nu degradează niciodată calitatea răspunsului; vă costă doar câștigul de latență. Scenariul cel mai defavorabil este pur și simplu o revenire la viteza normală pe cele două modele compatibile (mistral-large-latest și codestral-latest).
Puncte cheie
- Parametrul
predictionse adaugă pur și simplu apeluluichat.complete() - Encapsulați logica într-o clasă reutilizabilă pentru producție
- Măsurați sistematic câștigul cu un benchmark înainte de implementare
- Planificați o soluție de rezervă (fallback) fără predicție în caz de erori
- O predicție slabă nu degradează calitatea, ci doar latența