Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Implementácia predpovedaných výstupov v Pythone

Lekcia 7 z 16 Aktualizované 2. novembra 2026 Pokročilý
Na tejto strane
  1. Od konceptu po produkčný kód
  2. Základná implementácia
  3. Pomocná trieda pre produkciu
  4. Benchmark: S predikciou vs. bez predikcie
  5. Ošetrenie chýb
  6. Obmedzenia, ktoré treba poznať
  7. Kľúčové poznatky

Od konceptu po produkčný kód

Pochopil si princíp predpovedaných výstupov (Predicted Outputs) a ich prípady použitia. Táto lekcia ti poskytne kompletný kód v Pythone pripravený na integráciu do tvojich aplikácií, vrátane ošetrenia chýb a merania výkonu.

Základná implementácia

Minimálny vzor vyžaduje len jeden parameter: prediction, kam odovzdáš očakávaný obsah. Všetko ostatné v volaní zostáva nezmenené – rovnaký model, rovnaké správy, rovnaké spracovanie odpovede. Vďaka tomu je táto funkcia ľahko adoptovateľná a rovnako ľahko ju odstrániš, ak metriky nepotvrdia zisk:

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)

Pomocná trieda pre produkciu

Zapuzdrenie (encapsulation) tu prináša výhody nad rámec čistého kódu: centralizuje rozhodnutie o povolení alebo zakázaní predikcie. Presne toto je nastavenie, ktoré chceš mať možnosť okamžite prepínať. Ak nasadenie odhalí konzistentne nesprávne predpovede, môžeš ich vypnúť na jednom mieste, namiesto toho, aby si hľadal tento parameter v celej kódovej základni:

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:
    """Editor obsahu využívajúci predpovedané výstupy."""

    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:
        """Upraví obsah s predikciou výstupu."""
        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:
        """Skratka pre úpravu kódu."""
        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:
        """Skratka pre úpravu textu."""
        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."
            )
        )

Použitie triedy

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

# Úprava kódu
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)

Benchmark: S predikciou vs. bez predikcie

Tento krok nevynechávaj. Zisk z predpovedaných výstupov závisí výlučne od presnosti tvojich predpovedí, čo závisí od tvojich dát. Žiadna hodnota z dokumentácie nenahradí meranie na vlastných príkladoch. Tento skript porovnáva oba režimy na rovnakých vstupoch a odpoveď ti dá za pár sekúnd:

import statistics

def benchmark_prediction(
    client, model, messages, prediction_content, runs=5
):
    """Porovná latenciu s predpovedaným výstupom a bez neho."""
    times_normal = []
    times_predicted = []

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

        # S predikciou
        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
    }

Ošetrenie chýb

Ošetrenie chýb je tu priamočiare z štrukturálneho dôvodu: nesprávna predikcia nie je chybou. Model ju ignoruje a generuje odpoveď štandardným spôsobom – strácaš zisk na latencii, nikdy nie kvalitu. Skutočné hraničné prípady ležia inde:

def safe_edit(editor, original, instruction):
    """Úprava s robustným ošetrením chýb."""
    try:
        result = editor.edit(original, instruction)

        # Kontrola, či odpoveď nie je prázdna
        if not result.content or len(result.content.strip()) < 10:
            raise ValueError("Response too short or empty")

        return result

    except Exception as e:
        # Záložné riešenie: opakovanie bez predikcie
        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
        )

Obmedzenia, ktoré treba poznať

Pred nasadením si do code review zahrň tri body. Po prvé, parameter n (viacnásobné generovanie) nie je kompatibilný s prediction. Ak tvoj pipeline vyžaduje viacero dokončení, musíš si vybrať. Po druhé, zhodu medzi predikciou a výstupom rieši model bez ohľadu na pozíciu obsahu v odpovedi – nemusíš pripravovať žiadne zarovnanie. A nakoniec, a toto robí túto funkciu bezpečnou pre nasadenie: zlá predikcia nikdy nezhorší kvalitu odpovede; stojí ťa len zisk na latencii. Najhorší scenár je jednoducho návrat k bežnej rýchlosti na dvoch kompatibilných modeloch (mistral-large-latest a codestral-latest).

Kľúčové poznatky

  • Parameter prediction sa jednoducho pridá k volaniu chat.complete()
  • Zapuzdri logiku do opakovane použiteľnej triedy pre produkciu
  • Systematicky meraj zisk pomocou benchmarku pred nasadením
  • Naplánuj záložné riešenie bez predikcie pre prípad chýb
  • Zlá predikcia nezhoršuje kvalitu, ovplyvňuje len latenciu