Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Toteuta ennustetut tulosteet Pythonilla

Oppitunti 7 / 16 Päivitetty 2. marraskuuta 2026 Edistynyt
Tällä sivulla
  1. Konseptista tuotantokoodiin
  2. Perustoteutus
  3. Hyötyluokka tuotantoon
  4. Vertailu: Ennusteen kanssa vs. ilman
  5. Virheenkäsittely
  6. Huomioitavat rajoitukset
  7. Keskeiset asiat

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 prediction lisätään yksinkertaisesti chat.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