Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Implementeeri ennustatud väljundid Pythonis

Õppetund 7 / 16 Värskendatud 2. november 2026 Edasijõudnutele
Sellel lehel
  1. Kontseptsioonist tootmiskoodini
  2. Põhiimplementatsioon
  3. Utiliidiklass tootmiseks
  4. Võrdlustest: ennustusega vs ilma
  5. Veahaldus
  6. Teadaolevad piirangud
  7. Peamised punktid

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 prediction lisab lihtsalt chat.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