Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Implementér forudsagte output i Python

Lektion 7 af 16 Opdateret 2. november 2026 Avanceret
På denne side
  1. Fra koncept til produktionskode
  2. Basisimplementering
  3. Hjælpeklasse til produktion
  4. Benchmark: Med kontra uden forudsigelse
  5. Fejlhåndtering
  6. Begrænsninger du skal kende
  7. Vigtige pointer

Fra koncept til produktionskode

Du forstår princippet bag forudsagte output og deres anvendelsestilfælde. Denne lektion giver dig komplet Python-kode, der er klar til integration i dine applikationer, inklusive fejlhåndtering og måling af ydeevne.

Basisimplementering

Det minimale mønster kræver kun én parameter: prediction, hvor du angiver det forventede indhold. Alt andet i kaldet forbliver uændret – samme model, samme beskeder, samme håndtering af svar. Det gør funktionen nem at tage i brug og lige så nem at fjerne, hvis målinger ikke bekræfter gevinsten:

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)

Hjælpeklasse til produktion

Her giver indkapsling fordele ud over ren kode: den centraliserer beslutningen om at aktivere eller deaktivere forudsigelse. Det er præcis den type indstilling, du ønsker at kunne skifte øjeblikkeligt. Hvis en udrulning afslører konsekvent forkerte forudsigelser, kan du deaktivere dem ét sted i stedet for at lede efter parameteren gennem hele din kodebase:

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:
    """Indholdsredigering ved hjælp af forudsagte output."""

    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:
        """Redigerer indhold med output-forudsigelse."""
        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:
        """Genvej til redigering af 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:
        """Genvej til redigering af tekst."""
        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."
            )
        )

Brug af klassen

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

# Rediger kode
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: Med kontra uden forudsigelse

Spring ikke dette trin over. Gevinsten ved forudsagte output afhænger udelukkende af nøjagtigheden af dine forudsigelser, hvilket igen afhænger af dine data. Ingen tal fra dokumentationen erstatter måling på dine egne eksempler. Dette script sammenligner begge tilstande på de samme input og giver dig svaret på få sekunder:

import statistics

def benchmark_prediction(
    client, model, messages, prediction_content, runs=5
):
    """Sammenligner ventetid med og uden forudsagt output."""
    times_normal = []
    times_predicted = []

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

        # Med forudsigelse
        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
    }

Fejlhåndtering

Fejlhåndtering er ligetil her af en strukturel årsag: En forkert forudsigelse er ikke en fejl. Modellen ignorerer den og genererer normalt – du mister gevinsten i ventetid, men aldrig kvaliteten. De reelle kanttilfælde ligger andre steder:

def safe_edit(editor, original, instruction):
    """Redigering med robust fejlhåndtering."""
    try:
        result = editor.edit(original, instruction)

        # Tjek at svaret ikke er tomt
        if not result.content or len(result.content.strip()) < 10:
            raise ValueError("Response too short or empty")

        return result

    except Exception as e:
        # Fallback: genforsøg uden forudsigelse
        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
        )

Begrænsninger du skal kende

Før udrulning skal du integrere tre punkter i din kodegennemgang. For det første er parameteren n (flere generationer) uforenelig med prediction. Hvis din pipeline anmoder om flere fuldførelser, skal du vælge. For det andet håndteres matchet mellem forudsigelse og output af modellen uanset indholdets position i svaret – du behøver ikke forberede nogen justering. Endelig, og det er det, der gør funktionen sikker at udrulle: En dårlig forudsigelse forringer aldrig svarets kvalitet; det koster dig kun gevinsten i ventetid. Værste tilfælde er simpelthen en tilbagevenden til normal hastighed på de to kompatible modeller (mistral-large-latest og codestral-latest).

Vigtige pointer

  • Parameteren prediction tilføjes blot til kaldet chat.complete()
  • Indkapsl logikken i en genanvendelig klasse til produktion
  • Mål systematisk gevinsten med et benchmark før udrulning
  • Planlæg en fallback uden forudsigelse i tilfælde af fejl
  • En dårlig forudsigelse forringer ikke kvaliteten, kun ventetiden