Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Implementera förutsägda utdata i Python

Lektion 7 av 16 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Från koncept till produktionskod
  2. Grundläggande implementering
  3. Hjälpklass för produktion
  4. Prestandatest: Med kontra utan förutsägelse
  5. Felhantering
  6. Begränsningar att känna till
  7. Viktiga punkter

Från koncept till produktionskod

Du förstår principen bakom förutsägda utdata (Predicted Outputs) och deras användningsområden. Denna lektion ger dig komplett Python-kod redo att integreras i dina applikationer, inklusive felhantering och prestandamätning.

Grundläggande implementering

Det minimala mönstret kräver bara en parameter: prediction, där du anger det förväntade innehållet. Allt annat i anropet förblir oförändrat – samma modell, samma meddelanden, samma hantering av svar. Detta gör funktionen enkel att införa och lika enkel att ta bort om mätvärdena inte bekräftar någon vinst:

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älpklass för produktion

Kapsling här erbjuder fördelar utöver ren kod: den centraliserar beslutet att aktivera eller inaktivera förutsägelse. Det här är exakt den typ av inställning du vill kunna växla omedelbart. Om en distribution avslöjar konsekvent felaktiga förutsägelser kan du inaktivera dem på ett enda ställe istället för att leta efter parametern i hela din kodbas:

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:
    """Innehållsredigerare med förutsägda utdata."""

    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:
        """Redigerar innehåll med utdataprognos."""
        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:
        """Genväg för kodredigering."""
        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:
        """Genväg för textredigering."""
        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."
            )
        )

Använda klassen

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

# Redigera kod
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)

Prestandatest: Med kontra utan förutsägelse

Hoppa inte över detta steg. Vinsten med förutsägda utdata beror helt på noggrannheten i dina förutsägelser, vilket i sin tur beror på din data. Inga siffror från dokumentationen ersätter mätningar på dina egna exempel. Detta skript jämför båda lägena på samma indata och ger dig svaret på några sekunder:

import statistics

def benchmark_prediction(
    client, model, messages, prediction_content, runs=5
):
    """Jämför latens med och utan förutsagt utdata."""
    times_normal = []
    times_predicted = []

    for _ in range(runs):
        # Utan förutsägelse
        start = time.perf_counter()
        client.chat.complete(model=model, messages=messages)
        times_normal.append((time.perf_counter() - start) * 1000)

        # Med förutsägelse
        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
    }

Felhantering

Felhanteringen är enkel här av en strukturell anledning: en felaktig förutsägelse är inte ett fel. Modellen ignorerar den och genererar normalt – du förlorar latensvinsten, men aldrig kvaliteten. De verkliga undantagsfallen finns någon annanstans:

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

        # Kontrollera att svaret inte är 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: försök igen utan förutsägelse
        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änsningar att känna till

Innan du distribuerar bör du integrera tre punkter i din kodgranskning. För det första är parametern n (flera genereringar) inkompatibel med prediction. Om din pipeline begär flera kompletteringar måste du välja. För det andra hanteras matchningen mellan förutsägelse och utdata av modellen oavsett innehållets position i svaret – du behöver inte förbereda någon justering. Slutligen, och detta är vad som gör funktionen säker att distribuera: en dålig förutsägelse försämrar aldrig svarskvaliteten; den kostar dig bara latensvinsten. Värsta fall är helt enkelt en återgång till normal hastighet på de två kompatibla modellerna (mistral-large-latest och codestral-latest).

Viktiga punkter

  • Parametern prediction läggs helt enkelt till i anropet chat.complete()
  • Kapsla in logiken i en återanvändbar klass för produktion
  • Mät vinsten systematiskt med ett prestandatest innan distribution
  • Planera en fallback utan förutsägelse vid fel
  • En dålig förutsägelse försämrar inte kvaliteten, bara latensen