Implementeeri ennustatud väljundid Pythonis
Sellel lehel
Kontseptsioonist tootmiskoodini
Sa mõistad ennustatud väljundite (Predicted Outputs) põhimõtet ja nende kasutusvaldkondi. See tund annab sulle täieliku Pythoni koodi, mis on valmis rakendustesse integreerimiseks, kaasates veahalduse ja jõudluse mõõtmise.
Põhiimplementatsioon
Minimaalne muster nõuab vaid ühte parameetrit: prediction, kuhu edastad eeldatava sisu. Kõik muu väljakutses jääb samaks – sama mudel, samad sõnumid, sama vastuse käitlemine. See teeb funktsiooni hõlpsasti kasutuselevõetavaks ja sama lihtsasti eemaldatavaks, kui mõõdikud kasu ei kinnita:
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)
Utiliidiklass tootmiseks
Kapseldamine pakub siin eeliseid peale puhta koodi: see tsentraliseerib otsuse ennustuse lubamiseks või keelamiseks. See on täpselt selline seadistus, mida soovid koheselt lülitada. Kui kasutuselevõtt näitab järjekindlalt valesti ennustusi, saad need keelata ühest punktist, selle asemel et otsida parameetrit läbi kogu koodibaasi:
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:
"""Sisu redaktor, kasutades ennustatud väljundeid."""
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:
"""Redigeerib sisu väljundi ennustamisega."""
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:
"""Otsetee koodi redigeerimiseks."""
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:
"""Otsetee teksti redigeerimiseks."""
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."
)
)
Klassi kasutamine
editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")
# Koodi redigeerimine
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)
Võrdlustest: ennustusega vs ilma
Ära jäta seda sammu vahele. Ennustatud väljundite kasu sõltub täielikult sinu ennustuste täpsusest, mis omakorda sõltub sinu andmetest. Ükski dokumentatsiooni number ei asenda mõõtmist sinu enda näidetel. See skript võrdleb mõlemat režiimi samadel sisenditel, andes sulle vastuse sekunditega:
import statistics
def benchmark_prediction(
client, model, messages, prediction_content, runs=5
):
"""Võrdleb latentsust ennustusega ja ilma."""
times_normal = []
times_predicted = []
for _ in range(runs):
# Ilma ennustuseta
start = time.perf_counter()
client.chat.complete(model=model, messages=messages)
times_normal.append((time.perf_counter() - start) * 1000)
# Ennustusega
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
}
Veahaldus
Veahaldus on siin struktuursel põhjusel lihtne: vale ennustus ei ole viga. Mudel ignoreerib seda ja genereerib normaalselt – kaotad latentsuse võidu, mitte kunagi kvaliteeti. Tegelikkuses peituvad äärmuslikud juhtumid mujal:
def safe_edit(editor, original, instruction):
"""Redigeerimine robustse veahaldusega."""
try:
result = editor.edit(original, instruction)
# Kontrolli, et vastus poleks tühi
if not result.content or len(result.content.strip()) < 10:
raise ValueError("Response too short or empty")
return result
except Exception as e:
# Tagavara: korda ilma ennustuseta
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
)
Teadaolevad piirangud
Enne kasutuselevõttu lisa oma koodiülevaatesse kolm punkti. Esiteks, parameeter n (mitmikgeneratsioon) ei ühildu prediction-ga. Kui sinu torustik küsib mitut lõpetust, pead valima. Teiseks, ennustuse ja väljundi vastavust haldab mudel sõltumata sisu asukohast vastuses – sul pole vaja ette valmistada mingit joondamist. Lõpuks, ja see on see, mis teeb funktsiooni kasutuselevõtuks ohutuks: halb ennustus ei halventa kunagi vastuse kvaliteeti; see maksab sulle vaid latentsuse võidu. Halvim stsenaarium on lihtsalt naasmine tavakiirusele kahel ühilduval mudelil (mistral-large-latest ja codestral-latest).
Peamised punktid
- Parameeter
predictionlisab lihtsaltchat.complete()väljakutsele - Kapselda loogika tootmiseks uuestikasutatavasse klassi
- Mõõda kasu süstemaatiliselt võrdlustestiga enne kasutuselevõttu
- Planeeri tagavara ilma ennustuseta vigade korral
- Halb ennustus ei halventa kvaliteeti, vaid ainult latentsust