Toteuta ennustetut tulosteet Pythonilla
Tällä sivulla
Konseptista tuotantokoodiin
Ymmärrät nyt ennustettujen tulosteiden (Predicted Outputs) periaatteen ja niiden käyttötarkoitukset. Tämä oppitunti tarjoaa valmista Python-koodia, jonka voit integroida suoraan sovelluksiisi. Koodi sisältää virheenkäsittelyn ja suorituskyvyn mittauksen.
Perustoteutus
Minimaalinen malli vaatii vain yhden parametrin: prediction, johon syötät odotetun sisällön. Muu kutsu pysyy ennallaan – sama malli, samat viestit, sama vastauksen käsittely. Tämä tekee ominaisuuden omaksumisesta helppoa, ja sen poistaminen on yhtä vaivatonta, jos mittarit eivät vahvista hyötyä:
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)
Hyötyluokka tuotantoon
Kapselointi tarjoaa tässä siistin koodin lisäksi muita etuja: se keskittää päätöksen ennusteen käyttöönotosta tai poistamisesta. Tämä on juuri sellainen asetus, jonka haluat voivan kytkeä päälle ja pois välittömästi. Jos käyttöönotto paljastaa jatkuvasti virheellisiä ennusteita, voit poistaa ne käytöstä yhdestä pisteestä sen sijaan, että joutuisit metsästämään parametria koko koodikannastasi:
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:
"""Sisällön muokkaus ennustettujen tulosteiden avulla."""
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:
"""Muokkaa sisältöä käyttäen tulosteen ennustamista."""
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:
"""Pikatoiminto koodin muokkaamiseen."""
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:
"""Pikatoiminto tekstin muokkaamiseen."""
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."
)
)
Luokan käyttö
editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")
# Muokkaa koodia
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)
Vertailu: Ennusteen kanssa vs. ilman
Älä ohita tätä vaihetta. Ennustettujen tulosteiden hyöty riippuu täysin ennusteidesi tarkkuudesta, joka puolestaan riippuu datastasi. Mikään dokumentaation luku ei korvaa mittausta omilla esimerkeilläsi. Tämä skripti vertaa molempia tiloja samoilla syötteillä ja antaa vastauksen sekunneissa:
import statistics
def benchmark_prediction(
client, model, messages, prediction_content, runs=5
):
"""Vertaa latenssia ennusteen kanssa ja ilman."""
times_normal = []
times_predicted = []
for _ in range(runs):
# Ilman ennustetta
start = time.perf_counter()
client.chat.complete(model=model, messages=messages)
times_normal.append((time.perf_counter() - start) * 1000)
# Ennusteen kanssa
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
}
Virheenkäsittely
Virheenkäsittely on tässä suoraviivaista rakenteellisesta syystä: virheellinen ennuste ei ole virhe. Malli ignoroii sen ja generoi normaalisti – menetät latenssihyödyn, mutta et koskaan laatua. Todelliset reunatapaukset löytyvät muualta:
def safe_edit(editor, original, instruction):
"""Muokkaus robustilla virheenkäsittelyllä."""
try:
result = editor.edit(original, instruction)
# Tarkista, ettei vastaus ole tyhjä
if not result.content or len(result.content.strip()) < 10:
raise ValueError("Response too short or empty")
return result
except Exception as e:
# Varasuunnitelma: yritä uudelleen ilman ennustetta
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
)
Huomioitavat rajoitukset
Ennen käyttöönottoa sisällytä koodikatselmukseesi kolme kohtaa. Ensinnäkin parametri n (useita generointeja) ei ole yhteensopiva parametrin prediction kanssa. Jos putkesi pyytää useita täydennyksiä, sinun on tehtävä valinta. Toiseksi malli hoitaa ennusteen ja tulosteen vastaavuuden riippumatta sisällön sijainnista vastauksessa – sinun ei tarvitte valmistella mitään kohdistusta. Lopuksi, ja tämä tekee ominaisuudesta turvallisen ottaa käyttöön: huono ennuste ei heikennä vastauksen laatua, se maksaa sinulle vain latenssihyödyn. Pahin mahdollinen skenaario on yksinkertaisesti paluu normaaliin nopeuteen kahdella yhteensopivalla mallilla (mistral-large-latest ja codestral-latest).
Keskeiset asiat
- Parametri
predictionlisätään yksinkertaisestichat.complete()-kutsuun - Kapseloi logiikka uudelleenkäytettävään luokkaan tuotantoa varten
- Mittaa hyöty systemaattisesti vertailutestillä ennen käyttöönottoa
- Suunnittele varasuunnitelma ilman ennustetta virhetilanteiden varalle
- Huono ennuste ei heikennä laatua, ainoastaan latenssia