Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Implementuoti numatytąją išvestį Python kalba

Paskaita 7 iš 16 Atnaujinta 2026 m. lapkričio 2 d. Pažengusiems
Šiame puslapyje
  1. Nuo koncepcijos iki gamybinio kodo
  2. Bazinis įgyvendinimas
  3. Pagalbinė klasė gamybai
  4. Lyginamasis testas: su numatymu ir be jo
  5. Klaidų apdorojimas
  6. Svarbios žinoti ribos
  7. Svarbiausi punktai

Nuo koncepcijos iki gamybinio kodo

Supranti „Predicted Outputs“ principą ir jo taikymo sritis. Šioje pamokoje pateikiamas pilnas Python kodas, paruoštas integruoti į tavo programas, įskaitant klaidų apdorojimą ir našumo matavimą.

Bazinis įgyvendinimas

Minimaliam šablonui reikia tik vieno parametro: prediction, kuriame perduodi numatomą turinį. Visa kita kvietime lieka nepakitusi – tas pats modelis, tie patys pranešimai, tas pats atsako apdorojimas. Dėl to šią funkciją lengva įdiegti ir taip pat lengva pašalinti, jei metrika nepatvirtina naudingo poveikio:

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)

Pagalbinė klasė gamybai

Čia inkapsuliacija suteikia pranašumų daugiau nei tik tvarkingą kodą: ji centralizuoja sprendimą įjungti arba išjungti numatymą. Būtent tokį nustatymą nori galėti perjungti akimirksniu. Jei diegimo metu paaiškėja, kad numatymai nuolat klaidingi, gali juos išjungti vienoje vietoje, užuot ieškojęs šio parametro visame savo kode:

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:
    """Turinio redaktorius, naudojantis „Predicted Outputs“."""

    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:
        """Redaguoja turinį su išvesties numatymu."""
        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:
        """Trumpinys kodo redagavimui."""
        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:
        """Trumpinys teksto redagavimui."""
        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."
            )
        )

Klasės naudojimas

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

# Redaguoti 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)

Lyginamasis testas: su numatymu ir be jo

Nepraleisk šio žingsnio. Nauda iš „Predicted Outputs“ visiškai priklauso nuo tavo numatymų tikslumo, o tai lemia tavo duomenys. Joks dokumentacijos skaičius nepakeis matavimų su tavo pačių pavyzdžiais. Šis scenarijus palygina abu režimus su tais pačiais įvesties duomenimis ir atsakymą pateikia per kelias sekundes:

import statistics

def benchmark_prediction(
    client, model, messages, prediction_content, runs=5
):
    """Palygina delsą su „Predicted Output“ ir be jo."""
    times_normal = []
    times_predicted = []

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

        # Su numatymu
        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
    }

Klaidų apdorojimas

Klaidų apdorojimas čia yra paprastas dėl struktūrinės priežasties: neteisingas numatymas nėra klaida. Modelis jį ignoruoja ir generuoja atsakymą įprastai – prarandi delsos sumažėjimo naudą, bet niekada – kokybę. Tikrosios kraštutinės situacijos slypi kitur:

def safe_edit(editor, original, instruction):
    """Redagavimas su patikimu klaidų apdorojimu."""
    try:
        result = editor.edit(original, instruction)

        # Patikrinti, ar atsakas nėra tuščias
        if not result.content or len(result.content.strip()) < 10:
            raise ValueError("Response too short or empty")

        return result

    except Exception as e:
        # Atsarginis variantas: kartoti be numatymo
        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
        )

Svarbios žinoti ribos

Prieš diegdami, įtraukite tris punktus į savo kodo peržiūrą. Pirma, parametras n (keli generavimai) yra nesuderinamas su prediction. Jei tavo procesas prašo kelių užbaigimų, turi rinktis. Antra, numatymo ir išvesties atitikimą tvarko modelis, nepaisant turinio pozicijos atsakyme – tau nereikia ruošti jokio lygiavimo. Galiausiai, ir būtent tai daro šią funkciją saugią diegti: blogas numatymas niekada nepablogina atsako kokybės; jis tik kainuoja tau delsos sumažėjimo naudą. Blogiausiu atveju tiesiog grįžtama prie įprasto greičio naudojant du suderinamus modelius (mistral-large-latest ir codestral-latest).

Svarbiausi punktai

  • Parametras prediction tiesiog papildomas chat.complete() kvietime
  • Inkapsuliuok logiką į pakartotinai naudojamą klasę gamybai
  • Sistemingai išmatuok naudą su lyginamuoju testu prieš diegiant
  • Numatyk atsarginį variantą be numatymo klaidų atveju
  • Blogas numatymas nepablogina kokybės, tik delsą