Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Implementace předpovězených výstupů v Pythonu

Lekce 7 z 16 Aktualizováno 2. listopadu 2026 Pokročilý
Na této stránce
  1. Od konceptu k produkčnímu kódu
  2. Základní implementace
  3. Pomocná třída pro produkci
  4. Benchmark: S předpovědí vs. bez předpovědi
  5. Ošetření chyb
  6. Omezení, která musíš znát
  7. Klíčové poznatky

Od konceptu k produkčnímu kódu

Chápeš princip předpovězených výstupů (Predicted Outputs) i jejich případy použití. Tato lekce ti poskytne kompletní kód v Pythonu připravený k integraci do tvých aplikací, včetně ošetření chyb a měření výkonu.

Základní implementace

Minimální vzor vyžaduje pouze jeden parametr: prediction, kam předáš očekávaný obsah. Všechno ostatní ve volání zůstává stejné – stejný model, stejné zprávy, stejné zpracování odpovědi. Díky tomu je funkce snadno adoptovatelná a stejně snadno ji odstraníš, pokud metriky nepotvrdí přínos:

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á třída pro produkci

Zapouzdření zde nabízí výhody nad rámec čistého kódu: centralizuje rozhodnutí o povolení nebo zakázání předpovědi. Přesně toto nastavení chceš mít možnost okamžitě přepínat. Pokud nasazení odhalí soustavně nesprávné předpovědi, můžeš je vypnout na jediném místě, místo abys hledal tento parametr v celé kódové základně:

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ící předpovězené 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 předpovědí 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:
        """Zkratka pro ú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:
        """Zkratka pro ú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žití třídy

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 předpovědí vs. bez předpovědi

Tento krok nevynechávej. Přínos předpovězených výstupů závisí výhradně na přesnosti tvých předpovědí, což závisí na tvých datech. Žádné číslo z dokumentace nenahradí měření na tvých vlastních příkladech. Tento skript porovná oba režimy na stejných vstupech a odpověď získáš během vteřin:

import statistics

def benchmark_prediction(
    client, model, messages, prediction_content, runs=5
):
    """Porovná latenci s předpovězeným výstupem a bez něj."""
    times_normal = []
    times_predicted = []

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

        # S předpovědí
        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šetření chyb

Zde je ošetření chyb přímočaré z jednoho strukturálního důvodu: nesprávná předpověď není chyba. Model ji ignoruje a generuje normálně – přicházíš o zisk na latenci, nikdy však o kvalitu. Skutečné hraniční případy leží jinde:

def safe_edit(editor, original, instruction):
    """Úprava s robustním ošetřením chyb."""
    try:
        result = editor.edit(original, instruction)

        # Kontrola, zda odpověď není prázdná
        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í řešení: opakování bez předpovědi
        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
        )

Omezení, která musíš znát

Před nasazením integruj do code review tři body. Zaprvé, parametr n (více generací) je nekompatibilní s prediction. Pokud tvůj pipeline požaduje více dokončení, musíš si vybrat. Zadruhé, shodu mezi předpovědí a výstupem zpracovává model bez ohledu na pozici obsahu v odpovědi – nemusíš připravovat žádné zarovnání. A konečně, to je to, co činí tuto funkci bezpečnou pro nasazení: špatná předpověď nikdy nezhorší kvalitu odpovědi; stojí tě pouze zisk na latenci. Nejhorší scénář je prostě návrat k běžné rychlosti na dvou kompatibilních modelech (mistral-large-latest a codestral-latest).

Klíčové poznatky

  • Parametr prediction se jednoduše přidá k volání chat.complete()
  • Zapouzdři logiku do znovu použitelné třídy pro produkci
  • Před nasazením systematicky měř přínos pomocí benchmarku
  • Naplánuj záložní řešení bez předpovědi pro případ chyb
  • Špatná předpověď nezhoršuje kvalitu, pouze latenci