Implementuoti numatytąją išvestį Python kalba
Šiame puslapyje
Nuo koncepcijos iki gamybinio kodo
Supranti „Predicted Outputs“ principą ir jo taikymo sritis. Šioje pamokoje pateikiamas pilnas Python kodas, paruoštas integruoti į tavo programas, įskaitant klaidų apdorojimą ir našumo matavimą.
Bazinis įgyvendinimas
Minimaliam šablonui reikia tik vieno parametro: prediction, kuriame perduodi numatomą turinį. Visa kita kvietime lieka nepakitusi – tas pats modelis, tie patys pranešimai, tas pats atsako apdorojimas. Dėl to šią funkciją lengva įdiegti ir taip pat lengva pašalinti, jei metrika nepatvirtina naudingo poveikio:
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)
Pagalbinė klasė gamybai
Čia inkapsuliacija suteikia pranašumų daugiau nei tik tvarkingą kodą: ji centralizuoja sprendimą įjungti arba išjungti numatymą. Būtent tokį nustatymą nori galėti perjungti akimirksniu. Jei diegimo metu paaiškėja, kad numatymai nuolat klaidingi, gali juos išjungti vienoje vietoje, užuot ieškojęs šio parametro visame savo kode:
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:
"""Turinio redaktorius, naudojantis „Predicted Outputs“."""
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:
"""Redaguoja turinį su išvesties numatymu."""
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:
"""Trumpinys kodo redagavimui."""
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:
"""Trumpinys teksto redagavimui."""
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."
)
)
Klasės naudojimas
editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")
# Redaguoti 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)
Lyginamasis testas: su numatymu ir be jo
Nepraleisk šio žingsnio. Nauda iš „Predicted Outputs“ visiškai priklauso nuo tavo numatymų tikslumo, o tai lemia tavo duomenys. Joks dokumentacijos skaičius nepakeis matavimų su tavo pačių pavyzdžiais. Šis scenarijus palygina abu režimus su tais pačiais įvesties duomenimis ir atsakymą pateikia per kelias sekundes:
import statistics
def benchmark_prediction(
client, model, messages, prediction_content, runs=5
):
"""Palygina delsą su „Predicted Output“ ir be jo."""
times_normal = []
times_predicted = []
for _ in range(runs):
# Be numatymo
start = time.perf_counter()
client.chat.complete(model=model, messages=messages)
times_normal.append((time.perf_counter() - start) * 1000)
# Su numatymu
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
}
Klaidų apdorojimas
Klaidų apdorojimas čia yra paprastas dėl struktūrinės priežasties: neteisingas numatymas nėra klaida. Modelis jį ignoruoja ir generuoja atsakymą įprastai – prarandi delsos sumažėjimo naudą, bet niekada – kokybę. Tikrosios kraštutinės situacijos slypi kitur:
def safe_edit(editor, original, instruction):
"""Redagavimas su patikimu klaidų apdorojimu."""
try:
result = editor.edit(original, instruction)
# Patikrinti, ar atsakas nėra tuščias
if not result.content or len(result.content.strip()) < 10:
raise ValueError("Response too short or empty")
return result
except Exception as e:
# Atsarginis variantas: kartoti be numatymo
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
)
Svarbios žinoti ribos
Prieš diegdami, įtraukite tris punktus į savo kodo peržiūrą. Pirma, parametras n (keli generavimai) yra nesuderinamas su prediction. Jei tavo procesas prašo kelių užbaigimų, turi rinktis. Antra, numatymo ir išvesties atitikimą tvarko modelis, nepaisant turinio pozicijos atsakyme – tau nereikia ruošti jokio lygiavimo. Galiausiai, ir būtent tai daro šią funkciją saugią diegti: blogas numatymas niekada nepablogina atsako kokybės; jis tik kainuoja tau delsos sumažėjimo naudą. Blogiausiu atveju tiesiog grįžtama prie įprasto greičio naudojant du suderinamus modelius (mistral-large-latest ir codestral-latest).
Svarbiausi punktai
- Parametras
predictiontiesiog papildomaschat.complete()kvietime - Inkapsuliuok logiką į pakartotinai naudojamą klasę gamybai
- Sistemingai išmatuok naudą su lyginamuoju testu prieš diegiant
- Numatyk atsarginį variantą be numatymo klaidų atveju
- Blogas numatymas nepablogina kokybės, tik delsą