Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Implementacija napovedanih izhodov v Pythonu

Lekcija 7 od 16 Posodobljeno 2. november 2026 Napredni
Na tej strani
  1. Od koncepta do produkcijske kode
  2. Osnovna implementacija
  3. Pomožni razred za produkcijsko okolje
  4. Merjenje zmogljivosti: z napovedjo in brez nje
  5. Obravnava napak
  6. Omejitve, ki jih moraš poznati
  7. Ključne ugotovitve

Od koncepta do produkcijske kode

Razumeš načelo delovanja napovedanih izhodov in njihove primere uporabe. Ta lekcija ti ponuja popolno kodo v Pythonu, pripravljeno za integracijo v tvoje aplikacije, vključno z obravnavo napak in merjenjem zmogljivosti.

Osnovna implementacija

Najenostavnejši vzorec zahteva le en parameter: prediction, kamor podaš pričakovano vsebino. Vse ostalo v klicu ostane nespremenjeno – isti model, ista sporočila, enako obravnavanje odgovora. To omogoča enostavno uvedbo funkcije in prav tako enostavno odstranitev, če metrike ne potrdijo izboljšav:

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)

Pomožni razred za produkcijsko okolje

Zapiranje kode v razred prinaša prednosti, ki presegajo zgolj čisto kodo: centralizira odločitev o vklopu ali izklopu napovedovanja. To je točno tista vrsta nastavitve, ki jo želiš takoj preklopiti. Če uvedba razkrije dosledno napačne napovedi, jih lahko onemogočiš na enem samem mestu, namesto da bi parameter lovili po celotni kodi:

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:
    """Urejevalnik vsebine z uporabo napovedanih izhodov."""

    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:
        """Uredi vsebino z napovedjo izhoda."""
        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:
        """Bližnjica za urejanje kode."""
        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:
        """Bližnjica za urejanje besedila."""
        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."
            )
        )

Uporaba razreda

editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")

# Uredi kodo
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)

Merjenje zmogljivosti: z napovedjo in brez nje

Tega koraka ne preskoči. Dobitek od napovedanih izhodov je v celoti odvisen od natančnosti tvojih napovedi, kar je odvisno od tvojih podatkov. Nobena številka iz dokumentacije ne more nadomestiti merjenja na tvojih lastnih primerih. Ta skripta primerja oba načina na istih vhodnih podatkih in ti odgovor poda v nekaj sekundah:

import statistics

def benchmark_prediction(
    client, model, messages, prediction_content, runs=5
):
    """Primerja latenco z napovedanim izhodom in brez njega."""
    times_normal = []
    times_predicted = []

    for _ in range(runs):
        # Brez napovedi
        start = time.perf_counter()
        client.chat.complete(model=model, messages=messages)
        times_normal.append((time.perf_counter() - start) * 1000)

        # Z napovedjo
        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
    }

Obravnava napak

Obravnava napak je tu preprosta zaradi strukturnega razloga: napačna napoved ni napaka. Model jo ignorira in generira odgovor normalno – izgubiš pridobitev pri latenci, nikoli pa ne kakovosti. Pravi robni primeri se skrivajo drugje:

def safe_edit(editor, original, instruction):
    """Urejanje z robustno obravnavo napak."""
    try:
        result = editor.edit(original, instruction)

        # Preveri, ali odgovor ni prazen
        if not result.content or len(result.content.strip()) < 10:
            raise ValueError("Response too short or empty")

        return result

    except Exception as e:
        # Nadomestilo: ponovni poskus brez napovedi
        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
        )

Omejitve, ki jih moraš poznati

Pred uvedbo v svojo kodo vključi tri ključne točke. Prvič, parameter n (več generacij) ni združljiv s prediction. Če tvoja cevovodna obdelava zahteva več zaključkov, se moraš odločiti za enega. Drugič, ujemanje med napovedjo in izhodom obravnava model ne glede na položaj vsebine v odgovoru – ni treba pripravljati nobenega poravnavanja. Nazadnje, in to je tisto, zaradi česar je funkcija varna za uvedbo: slaba napoved nikoli ne poslabša kakovosti odgovora; stane te le izgubo pri latenci. Najslabši scenarij je preprosto vrnitev na običajno hitrost pri dveh združljivih modelih (mistral-large-latest in codestral-latest).

Ključne ugotovitve

  • Parameter prediction preprosto dodaš klicu chat.complete()
  • Logiko zapri v ponovno uporaben razred za produkcijsko okolje
  • Pred uvedbo sistematično izmeri pridobitek z merjenjem zmogljivosti
  • Načrtuj nadomestilo brez napovedi za primer napak
  • Slaba napoved ne poslabša kakovosti, vpliva le na latenco