Implementácia predpovedaných výstupov v Pythone
Na tejto strane
Od konceptu po produkčný kód
Pochopil si princíp predpovedaných výstupov (Predicted Outputs) a ich prípady použitia. Táto lekcia ti poskytne kompletný kód v Pythone pripravený na integráciu do tvojich aplikácií, vrátane ošetrenia chýb a merania výkonu.
Základná implementácia
Minimálny vzor vyžaduje len jeden parameter: prediction, kam odovzdáš očakávaný obsah. Všetko ostatné v volaní zostáva nezmenené – rovnaký model, rovnaké správy, rovnaké spracovanie odpovede. Vďaka tomu je táto funkcia ľahko adoptovateľná a rovnako ľahko ju odstrániš, ak metriky nepotvrdia zisk:
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)
Pomocná trieda pre produkciu
Zapuzdrenie (encapsulation) tu prináša výhody nad rámec čistého kódu: centralizuje rozhodnutie o povolení alebo zakázaní predikcie. Presne toto je nastavenie, ktoré chceš mať možnosť okamžite prepínať. Ak nasadenie odhalí konzistentne nesprávne predpovede, môžeš ich vypnúť na jednom mieste, namiesto toho, aby si hľadal tento parameter v celej kódovej základni:
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 obsahu využívajúci predpovedané výstupy."""
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:
"""Upraví obsah s predikciou výstupu."""
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:
"""Skratka pre úpravu kódu."""
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:
"""Skratka pre úpravu textu."""
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."
)
)
Použitie triedy
editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")
# Úprava kódu
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 predikciou vs. bez predikcie
Tento krok nevynechávaj. Zisk z predpovedaných výstupov závisí výlučne od presnosti tvojich predpovedí, čo závisí od tvojich dát. Žiadna hodnota z dokumentácie nenahradí meranie na vlastných príkladoch. Tento skript porovnáva oba režimy na rovnakých vstupoch a odpoveď ti dá za pár sekúnd:
import statistics
def benchmark_prediction(
client, model, messages, prediction_content, runs=5
):
"""Porovná latenciu s predpovedaným výstupom a bez neho."""
times_normal = []
times_predicted = []
for _ in range(runs):
# Bez predikcie
start = time.perf_counter()
client.chat.complete(model=model, messages=messages)
times_normal.append((time.perf_counter() - start) * 1000)
# S predikciou
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
}
Ošetrenie chýb
Ošetrenie chýb je tu priamočiare z štrukturálneho dôvodu: nesprávna predikcia nie je chybou. Model ju ignoruje a generuje odpoveď štandardným spôsobom – strácaš zisk na latencii, nikdy nie kvalitu. Skutočné hraničné prípady ležia inde:
def safe_edit(editor, original, instruction):
"""Úprava s robustným ošetrením chýb."""
try:
result = editor.edit(original, instruction)
# Kontrola, či odpoveď nie je prázdna
if not result.content or len(result.content.strip()) < 10:
raise ValueError("Response too short or empty")
return result
except Exception as e:
# Záložné riešenie: opakovanie bez predikcie
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
)
Obmedzenia, ktoré treba poznať
Pred nasadením si do code review zahrň tri body. Po prvé, parameter n (viacnásobné generovanie) nie je kompatibilný s prediction. Ak tvoj pipeline vyžaduje viacero dokončení, musíš si vybrať. Po druhé, zhodu medzi predikciou a výstupom rieši model bez ohľadu na pozíciu obsahu v odpovedi – nemusíš pripravovať žiadne zarovnanie. A nakoniec, a toto robí túto funkciu bezpečnou pre nasadenie: zlá predikcia nikdy nezhorší kvalitu odpovede; stojí ťa len zisk na latencii. Najhorší scenár je jednoducho návrat k bežnej rýchlosti na dvoch kompatibilných modeloch (mistral-large-latest a codestral-latest).
Kľúčové poznatky
- Parameter
predictionsa jednoducho pridá k volaniuchat.complete() - Zapuzdri logiku do opakovane použiteľnej triedy pre produkciu
- Systematicky meraj zisk pomocou benchmarku pred nasadením
- Naplánuj záložné riešenie bez predikcie pre prípad chýb
- Zlá predikcia nezhoršuje kvalitu, ovplyvňuje len latenciu