Implementacija predviđenih izlaza u Pythonu
Na ovoj stranici
Od koncepta do produkcijskog koda
Razumiješ princip rada predviđenih izlaza (Predicted Outputs) i njihove slučajeve uporabe. Ova lekcija donosi kompletan Python kod spreman za integraciju u tvoje aplikacije, uključujući rukovanje greškama i mjerenje performansi.
Osnovna implementacija
Minimalni uzorak zahtijeva samo jedan parametar: prediction, u koji prosljeđuješ očekivani sadržaj. Sve ostalo u pozivu ostaje nepromijenjeno – isti model, iste poruke, isto rukovanje odgovorom. To znači da je značajku lako usvojiti, a jednako tako lako i ukloniti ako metrike ne potvrde dobit:
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ćna klasa za produkciju
Enkapsulacija ovdje nudi prednosti izvan čistog koda: centralizira odluku o omogućavanju ili onemogućavanju predviđanja. To je točno ona vrsta postavke koju želiš moći trenutno prebaciti. Ako deploy otkrije dosljedno netočna predviđanja, možeš ih onemogućiti na jednom mjestu umjesto da tražiš parametar kroz cijelu kodnu bazu:
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:
"""Uređivač sadržaja koji koristi predviđene izlaze."""
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:
"""Uređuje sadržaj uz predviđanje izlaza."""
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:
"""Prečac za uređivanje koda."""
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:
"""Prečac za uređivanje teksta."""
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."
)
)
Korištenje klase
editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")
# Uređivanje koda
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 predviđanjem naspram bez njega
Nemoj preskočiti ovaj korak. Dobit od predviđenih izlaza u potpunosti ovisi o točnosti tvojih predviđanja, što zauzvrat ovisi o tvojim podacima. Nijedna brojka iz dokumentacije ne zamjenjuje mjerenje na tvojim vlastitim primjerima. Ova skripta uspoređuje oba načina rada na istim ulazima i daje ti odgovor u nekoliko sekundi:
import statistics
def benchmark_prediction(
client, model, messages, prediction_content, runs=5
):
"""Uspoređuje latenciju s predviđenim izlazom i bez njega."""
times_normal = []
times_predicted = []
for _ in range(runs):
# Bez predviđanja
start = time.perf_counter()
client.chat.complete(model=model, messages=messages)
times_normal.append((time.perf_counter() - start) * 1000)
# S predviđanjem
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
}
Rukovanje greškama
Rukovanje greškama ovdje je jednostavno iz strukturnog razloga: netočno predviđanje nije greška. Model ga ignorira i generira odgovor normalno – gubiš dobit u latenciji, nikada kvalitetu. Pravi rubni slučajevi leže drugdje:
def safe_edit(editor, original, instruction):
"""Uređivanje s robusnim rukovanjem greškama."""
try:
result = editor.edit(original, instruction)
# Provjera da odgovor nije prazan
if not result.content or len(result.content.strip()) < 10:
raise ValueError("Response too short or empty")
return result
except Exception as e:
# Fallback: ponovni pokušaj bez predviđanja
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
)
Ograničenja koja trebaš znati
Prije deploya, integriraj tri točke u svoju reviziju koda. Prvo, parametar n (višestruka generiranja) nije kompatibilan s prediction. Ako tvoj pipeline zahtijeva više kompletiranja, moraš birati. Drugo, podudaranje između predviđanja i izlaza model obrađuje neovisno o položaju sadržaja u odgovoru – ne moraš pripremati nikakvo poravnanje. Konačno, i ovo je ono što značajku čini sigurnom za deploy: loše predviđanje nikada ne degradira kvalitetu odgovora; košta te samo dobit u latenciji. Najgori scenarij je jednostavan povratak na normalnu brzinu na dva kompatibilna modela (mistral-large-latest i codestral-latest).
Ključne točke
- Parametar
predictionjednostavno se dodaje pozivuchat.complete() - Enkapsuliraj logiku u klasu za višekratnu uporabu u produkciji
- Sustavno mjeri dobit benchmarkom prije deploya
- Planiraj fallback bez predviđanja u slučaju grešaka
- Loše predviđanje ne degradira kvalitetu, već samo latenciju