Implementēt prognozētās izvades Python valodā
Šajā lapā
No koncepcijas līdz ražošanas kodam
Tu saproti prognozēto izvadu principus un to pielietojuma gadījumus. Šajā nodarbībā atradīsi pilnu Python kodu, kas gatavs integrācijai tavās lietotnēs, tostarp kļūdu apstrādi un veiktspējas mērījumus.
Pamata implementācija
Minimālajam risinājumam nepieciešams tikai viens parametrs: prediction, kurā norādi sagaidāmo saturu. Pārējais izsaukumā paliek nemainīgs – tas pats modelis, tie paši ziņojumi, tāda pati atbilžu apstrāde. Tas padara funkciju viegli ieviešamu un tikpat viegli noņemamu, ja metrikas neapstiprina ieguvumu:
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)
Utilītklase ražošanas videi
Iekapsulēšana šeit sniedz priekšrocības, kas pārsniedz tīru kodu: tā centralizē lēmumu iespējot vai atspējot prognozēšanu. Tieši šādu iestatījumu vēlies spētu pārslēgt acumirklī. Ja izvēršanas laikā atklājas, ka prognozes konsekventi ir nepareizas, tās vari atspējot vienā punktā, nevis meklēt šo parametru visā koda bāzē:
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:
"""Satura redaktors, izmantojot prognozētās izvades."""
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:
"""Rediģē saturu ar izvades prognozēšanu."""
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:
"""Īsceļš koda rediģēšanai."""
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:
"""Īsceļš teksta rediģēšanai."""
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."
)
)
Klases izmantošana
editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")
# Koda rediģēšana
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)
Salīdzinošais tests: ar prognozēšanu un bez tās
Neizlaid šo soli. Ieguvums no prognozētajām izvādēm ir pilnībā atkarīgs no tavu prognožu precizitātes, kas savukārt ir atkarīga no taviem datiem. Neviens skaitlis dokumentācijā neaizstāj mērījumus ar taviem paša paraugiem. Šis skripts salīdzina abus režīmus vieniem un tiem pašiem ievades datiem, sniedzot atbildi dažu sekunžu laikā:
import statistics
def benchmark_prediction(
client, model, messages, prediction_content, runs=5
):
"""Salīdzina latentumu ar prognozēto izvadi un bez tās."""
times_normal = []
times_predicted = []
for _ in range(runs):
# Bez prognozēšanas
start = time.perf_counter()
client.chat.complete(model=model, messages=messages)
times_normal.append((time.perf_counter() - start) * 1000)
# Ar prognozēšanu
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
}
Kļūdu apstrāde
Kļūdu apstrāde šeit ir vienkārša strukturāla iemesla dēļ: nepareiza prognoze nav kļūda. Modelis to ignorē un ģenerē atbildi parastajā režīmā – tu zaudē latentuma ieguvumu, bet nekad kvalitāti. Reālie robežgadījumi slēpjas citur:
def safe_edit(editor, original, instruction):
"""Rediģēšana ar robustu kļūdu apstrādi."""
try:
result = editor.edit(original, instruction)
# Pārbauda, vai atbilde nav tukša
if not result.content or len(result.content.strip()) < 10:
raise ValueError("Response too short or empty")
return result
except Exception as e:
# Rezerves risinājums: atkārtot bez prognozēšanas
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
)
Ierobežojumi, kas jāzina
Pirms izvēršanas integrē savā koda pārskatīšanā trīs punktus. Pirmkārt, parametrs n (vairāku ģenerāciju veikšana) nav savietojams ar prediction. Ja tava cauruļvada prasība ir vairākas pabeigšanas, tev ir jāizvēlas. Otrkārt, atbilstību starp prognozi un izvadi apstrādā modelis neatkarīgi no satura pozīcijas atbildē – tev nav jāsagatavo nekāda izlīdzināšana. Visbeidzot, un tieši tas padara funkciju drošu izvēršanai: slikta prognoze nekad nepasliktina atbildes kvalitāti; tā tikai liedz iegūt latentuma uzlabojumu. Sliktākais scenārijs ir vienkārši atgriešanās pie parastā ātruma abos savietojamajos modeļos (mistral-large-latest un codestral-latest).
Galvenās atziņas
- Parametrs
predictionvienkārši papildinachat.complete()izsaukumu - Iekapsulē loģiku atkārtoti izmantojamā klasē ražošanas videi
- Sistemātiski mēri ieguvumu ar salīdzinošo testu pirms izvēršanas
- Plāno rezerves risinājumu bez prognozēšanas kļūdu gadījumā
- Slikta prognoze nepasliktina kvalitāti, tikai ietekmē latentumu