Vorhersage von Ausgaben in Python implementieren
Auf dieser Seite
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 demchat.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