Премини към основното съдържание
Български— Изберете език
Меню

Имплементиране на предвидени изходи в Python

Урок 7 от 16 Обновен 2 ноември 2026 г. Напреднало
На тази страница
  1. От концепция до производствен код
  2. Основна имплементация
  3. Утилитарен клас за продукция
  4. Бенчмарк: С предвиждане срещу без предвиждане
  5. Обработка на грешки
  6. Ограничения, които трябва да знаете
  7. Ключови изводи

От концепция до производствен код

Разбрахте принципа зад предвидените изходи (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()
  • Инкапсулирайте логиката в многократен клас за продукция
  • Системно измервайте печалбата с бенчмарк преди внедряване
  • Планирайте резервен вариант без предвиждане в случай на грешки
  • Лошото предвиждане не влошава качеството, а само латентността