Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Vorhersage von Ausgaben in Python implementieren

Lektion 7 von 16 Aktualisiert am 2. November 2026 Fortgeschritten
Auf dieser Seite
  1. Vom Konzept zur Produktionscode
  2. Grundlegende Implementierung
  3. Nutzenklasse für die Produktion
  4. Benchmark: Mit vs. ohne Vorhersage
  5. Fehlerbehandlung
  6. Einschränkungen, die Sie kennen müssen
  7. Kernaussagen

Vom Konzept zur Produktionscode

Sie verstehen das Prinzip hinter der Vorhersage von Ausgaben und deren Anwendungsfälle. Diese Lektion bietet vollständigen Python-Code, der bereit für die Integration in Ihre Anwendungen ist, einschließlich Fehlerbehandlung und Leistungsmessung.

Grundlegende Implementierung

Das minimale Muster erfordert nur einen Parameter: prediction, in den Sie den erwarteten Inhalt übergeben. Der Rest des Aufrufs bleibt unverändert – dasselbe Modell, dieselben Nachrichten, dieselbe Antwortverarbeitung. Dies macht die Funktion einfach zu übernehmen und ebenso einfach zu entfernen, wenn die Metriken keinen Gewinn bestätigen:

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 = (
    "Fügen Sie dem load_data-Funktion einen 'separator'-Parameter hinzu "
    "(Standardwert ',') und verwenden Sie ihn in read_csv. "
    "Antworten Sie nur mit dem vollständigen modifizierten 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)

Nutzenklasse für die Produktion

Die Kapselung bietet hier Vorteile über sauberen Code hinaus: Sie zentralisiert die Entscheidung, die Vorhersage zu aktivieren oder zu deaktivieren. Genau dies ist die Art von Einstellung, die Sie sofort umschalten möchten. Wenn eine Bereitstellung konsistent falsche Vorhersagen offenbart, können Sie diese an einer einzigen Stelle deaktivieren, anstatt nach dem Parameter in Ihrem gesamten Codebestand zu suchen:

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:
    """Inhaltredaktor unter Verwendung der Vorhersage von Ausgaben."""

    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:
        """Bearbeitet Inhalte mit Vorhersage der Ausgabe."""
        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:
        """Abkürzung für Codebearbeitung."""
        return self.edit(
            original=code,
            instruction=instruction,
            system_prompt=(
                "Sie sind ein Programmierassistent. "
                "Antworten Sie nur mit dem modifizierten Code, "
                "ohne Erklärung oder Markdown."
            )
        )

    def edit_text(self, text: str, instruction: str) -> PredictionResult:
        """Abkürzung für Textbearbeitung."""
        return self.edit(
            original=text,
            instruction=instruction,
            system_prompt=(
                "Sie sind ein professioneller Textredaktor. "
                "Wenden Sie die angeforderte Änderung an, während Sie "
                "den Stil und die Struktur des Originaltextes bewahren. "
                "Antworten Sie nur mit dem modifizierten Text."
            )
        )

Verwendung der Klasse

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

# Code bearbeiten
result = editor.edit_code(
    code=my_python_file,
    instruction="Ersetzen Sie alle print()-Aufrufe durch logging.info()-Aufrufe"
)

print(f"Latenz: {result.latency_ms} ms")
print(f"Tokens: {result.tokens_input} in / {result.tokens_output} out")
print(result.content)

Benchmark: Mit vs. ohne Vorhersage

Überspringen Sie diesen Schritt nicht. Der Gewinn durch die Vorhersage von Ausgaben hängt vollständig von der Genauigkeit Ihrer Vorhersagen ab, die wiederum von Ihren Daten abhängt. Keine Zahl aus der Dokumentation ersetzt eine Messung an Ihren eigenen Beispielen. Dieses Skript vergleicht beide Modi an denselben Eingaben und liefert Ihnen die Antwort in Sekunden:

import statistics

def benchmark_prediction(
    client, model, messages, prediction_content, runs=5
):
    """Vergleicht Latenz mit und ohne Vorhersageausgabe."""
    times_normal = []
    times_predicted = []

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

        # Mit Vorhersage
        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
    }

Fehlerbehandlung

Die Fehlerbehandlung ist hier aus strukturellen Gründen einfach: Eine falsche Vorhersage ist kein Fehler. Das Modell ignoriert sie und generiert normal – Sie verlieren den Latenzgewinn, niemals die Qualität. Die eigentlichen Grenzfälle liegen anderswo:

def safe_edit(editor, original, instruction):
    """Bearbeiten mit robuster Fehlerbehandlung."""
    try:
        result = editor.edit(original, instruction)

        # Prüfen, ob die Antwort nicht leer ist
        if not result.content or len(result.content.strip()) < 10:
            raise ValueError("Antwort zu kurz oder leer")

        return result

    except Exception as e:
        # Fallback: erneut versuchen, ohne Vorhersage
        print(f"Vorhersageausgabe fehlgeschlagen ({e}), Rückfall auf 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
        )

Einschränkungen, die Sie kennen müssen

Integrieren Sie vor der Bereitstellung drei Punkte in Ihren Code-Review. Erstens ist der n-Parameter (mehrere Generierungen) mit prediction inkompatibel. Wenn Ihre Pipeline mehrere Vollendungen anfordert, müssen Sie sich entscheiden. Zweitens wird die Übereinstimmung zwischen Vorhersage und Ausgabe vom Modell unabhängig von der Position des Inhalts in der Antwort verwaltet – Sie müssen keine Ausrichtung vorbereiten. Drittens und dies macht die Funktion sicher für die Bereitstellung: Eine schlechte Vorhersage verschlechtert niemals die Antwortqualität; sie kostet Sie nur den Latenzgewinn. Der Worst-Case-Szenario ist einfach ein Rückfall auf die normale Geschwindigkeit bei den beiden kompatiblen Modellen (mistral-large-latest und codestral-latest).

Kernaussagen

  • Der prediction-Parameter fügt lediglich dem chat.complete()-Aufruf hinzu
  • Kapseln Sie die Logik in einer wiederverwendbaren Klasse für die Produktion
  • Messen Sie systematisch den Gewinn mit einem Benchmark, bevor Sie bereitstellen
  • Planen Sie einen Fallback ohne Vorhersage für den Fall von Fehlern
  • Eine schlechte Vorhersage verschlechtert die Qualität nicht, nur die Latenz