Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Implementacija predviđenih izlaza u Pythonu

Lekcija 7 od 16 Ažurirano 2. studenoga 2026. Napredno
Na ovoj stranici
  1. Od koncepta do produkcijskog koda
  2. Osnovna implementacija
  3. Pomoćna klasa za produkciju
  4. Benchmark: S predviđanjem naspram bez njega
  5. Rukovanje greškama
  6. Ograničenja koja trebaš znati
  7. Ključne točke

Od koncepta do produkcijskog koda

Razumiješ princip rada predviđenih izlaza (Predicted Outputs) i njihove slučajeve uporabe. Ova lekcija donosi kompletan Python kod spreman za integraciju u tvoje aplikacije, uključujući rukovanje greškama i mjerenje performansi.

Osnovna implementacija

Minimalni uzorak zahtijeva samo jedan parametar: prediction, u koji prosljeđuješ očekivani sadržaj. Sve ostalo u pozivu ostaje nepromijenjeno – isti model, iste poruke, isto rukovanje odgovorom. To znači da je značajku lako usvojiti, a jednako tako lako i ukloniti ako metrike ne potvrde dobit:

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ćna klasa za produkciju

Enkapsulacija ovdje nudi prednosti izvan čistog koda: centralizira odluku o omogućavanju ili onemogućavanju predviđanja. To je točno ona vrsta postavke koju želiš moći trenutno prebaciti. Ako deploy otkrije dosljedno netočna predviđanja, možeš ih onemogućiti na jednom mjestu umjesto da tražiš parametar kroz cijelu kodnu bazu:

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:
    """Uređivač sadržaja koji koristi predviđene izlaze."""

    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:
        """Uređuje sadržaj uz predviđanje izlaza."""
        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:
        """Prečac za uređivanje koda."""
        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:
        """Prečac za uređivanje teksta."""
        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."
            )
        )

Korištenje klase

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

# Uređivanje koda
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 predviđanjem naspram bez njega

Nemoj preskočiti ovaj korak. Dobit od predviđenih izlaza u potpunosti ovisi o točnosti tvojih predviđanja, što zauzvrat ovisi o tvojim podacima. Nijedna brojka iz dokumentacije ne zamjenjuje mjerenje na tvojim vlastitim primjerima. Ova skripta uspoređuje oba načina rada na istim ulazima i daje ti odgovor u nekoliko sekundi:

import statistics

def benchmark_prediction(
    client, model, messages, prediction_content, runs=5
):
    """Uspoređuje latenciju s predviđenim izlazom i bez njega."""
    times_normal = []
    times_predicted = []

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

        # S predviđanjem
        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
    }

Rukovanje greškama

Rukovanje greškama ovdje je jednostavno iz strukturnog razloga: netočno predviđanje nije greška. Model ga ignorira i generira odgovor normalno – gubiš dobit u latenciji, nikada kvalitetu. Pravi rubni slučajevi leže drugdje:

def safe_edit(editor, original, instruction):
    """Uređivanje s robusnim rukovanjem greškama."""
    try:
        result = editor.edit(original, instruction)

        # Provjera da odgovor nije prazan
        if not result.content or len(result.content.strip()) < 10:
            raise ValueError("Response too short or empty")

        return result

    except Exception as e:
        # Fallback: ponovni pokušaj bez predviđanja
        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
        )

Ograničenja koja trebaš znati

Prije deploya, integriraj tri točke u svoju reviziju koda. Prvo, parametar n (višestruka generiranja) nije kompatibilan s prediction. Ako tvoj pipeline zahtijeva više kompletiranja, moraš birati. Drugo, podudaranje između predviđanja i izlaza model obrađuje neovisno o položaju sadržaja u odgovoru – ne moraš pripremati nikakvo poravnanje. Konačno, i ovo je ono što značajku čini sigurnom za deploy: loše predviđanje nikada ne degradira kvalitetu odgovora; košta te samo dobit u latenciji. Najgori scenarij je jednostavan povratak na normalnu brzinu na dva kompatibilna modela (mistral-large-latest i codestral-latest).

Ključne točke

  • Parametar prediction jednostavno se dodaje pozivu chat.complete()
  • Enkapsuliraj logiku u klasu za višekratnu uporabu u produkciji
  • Sustavno mjeri dobit benchmarkom prije deploya
  • Planiraj fallback bez predviđanja u slučaju grešaka
  • Loše predviđanje ne degradira kvalitetu, već samo latenciju