Имплементиране на предвидени изходи в Python
На тази страница
От концепция до производствен код
Разбрахте принципа зад предвидените изходи (Predicted Outputs) и техните случаи на употреба. Този урок предоставя пълен Python код, готов за интеграция във Вашите приложения, включително обработка на грешки и измерване на производителността.
Основна имплементация
Минималният шаблон изисква само един параметър: prediction, където предавате очакваното съдържание. Всичко останало в извикването остава непроменено – същият модел, същите съобщения, същата обработка на отговора. Това прави функцията лесна за внедряване и също толкова лесна за премахване, ако метриките не потвърдят ползата:
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)
Утилитарен клас за продукция
Инкапсулацията тук предлага предимства извън чистия код: тя централизира решението за активиране или деактивиране на предвиждането. Това е точно видът настройка, която искате да превключвате мигновено. Ако внедряването разкрие последователно неправилни предвиждания, можете да ги деактивирате на едно място, вместо да търсите параметъра из цялата си кодова база:
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:
"""Редактор на съдържание, използващ предвидени изходи."""
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:
"""Редактира съдържание с предвиждане на изхода."""
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:
"""Бърз метод за редактиране на код."""
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:
"""Бърз метод за редактиране на текст."""
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."
)
)
Използване на класа
editor = PredictedEditor(api_key="your-api-key", model="codestral-latest")
# Редактиране на код
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)
Бенчмарк: С предвиждане срещу без предвиждане
Не пропускайте тази стъпка. Ползата от предвидените изходи зависи изцяло от точността на Вашите предвиждания, която от своя страна зависи от Вашите данни. Никоя фигура от документацията не замества измерването върху Вашите собствени примери. Този скрипт сравнява двата режима върху едни и същи входни данни, давайки Ви отговора за секунди:
import statistics
def benchmark_prediction(
client, model, messages, prediction_content, runs=5
):
"""Сравнява латентността с и без предвиден изход."""
times_normal = []
times_predicted = []
for _ in range(runs):
# Без предвиждане
start = time.perf_counter()
client.chat.complete(model=model, messages=messages)
times_normal.append((time.perf_counter() - start) * 1000)
# С предвиждане
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
}
Обработка на грешки
Обработката на грешки тук е проста поради структурна причина: неправилното предвиждане не е грешка. Моделът го игнорира и генерира нормално – губите печалбата в латентност, но никога качеството. Реалните гранични случаи са другаде:
def safe_edit(editor, original, instruction):
"""Редактиране с надеждна обработка на грешки."""
try:
result = editor.edit(original, instruction)
# Проверка дали отговорът не е празен
if not result.content or len(result.content.strip()) < 10:
raise ValueError("Response too short or empty")
return result
except Exception as e:
# Резервен вариант: повторен опит без предвиждане
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
)
Ограничения, които трябва да знаете
Преди внедряване, интегрирайте три точки във Вашето ревю на кода. Първо, параметърът n (множествени генерации) е несъвместим с prediction. Ако Вашият пайплайн изисква множество завършвания, трябва да изберете. Второ, съвпадението между предвиждането и изхода се обработва от модела независимо от позицията на съдържанието в отговора – не е необходимо да подготвяте никакво подравняване. Накрая, и това е което прави функцията безопасна за внедряване: лошото предвиждане никога не влошава качеството на отговора; то Ви струва само печалбата в латентност. Най-лошият сценарий е просто връщане към нормална скорост при двата съвместими модела (mistral-large-latest и codestral-latest).
Ключови изводи
- Параметърът
predictionпросто се добавя към извикването наchat.complete() - Инкапсулирайте логиката в многократен клас за продукция
- Системно измервайте печалбата с бенчмарк преди внедряване
- Планирайте резервен вариант без предвиждане в случай на грешки
- Лошото предвиждане не влошава качеството, а само латентността