Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Implementēt prognozētās izvades Python valodā

Nodarbība 7 no 16 Atjaunota 2026. gada 2. novembris Augstākais
Šajā lapā
  1. No koncepcijas līdz ražošanas kodam
  2. Pamata implementācija
  3. Utilītklase ražošanas videi
  4. Salīdzinošais tests: ar prognozēšanu un bez tās
  5. Kļūdu apstrāde
  6. Ierobežojumi, kas jāzina
  7. Galvenās atziņas

No koncepcijas līdz ražošanas kodam

Tu saproti prognozēto izvadu principus un to pielietojuma gadījumus. Šajā nodarbībā atradīsi pilnu Python kodu, kas gatavs integrācijai tavās lietotnēs, tostarp kļūdu apstrādi un veiktspējas mērījumus.

Pamata implementācija

Minimālajam risinājumam nepieciešams tikai viens parametrs: prediction, kurā norādi sagaidāmo saturu. Pārējais izsaukumā paliek nemainīgs – tas pats modelis, tie paši ziņojumi, tāda pati atbilžu apstrāde. Tas padara funkciju viegli ieviešamu un tikpat viegli noņemamu, ja metrikas neapstiprina ieguvumu:

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)

Utilītklase ražošanas videi

Iekapsulēšana šeit sniedz priekšrocības, kas pārsniedz tīru kodu: tā centralizē lēmumu iespējot vai atspējot prognozēšanu. Tieši šādu iestatījumu vēlies spētu pārslēgt acumirklī. Ja izvēršanas laikā atklājas, ka prognozes konsekventi ir nepareizas, tās vari atspējot vienā punktā, nevis meklēt šo parametru visā koda bāzē:

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:
    """Satura redaktors, izmantojot prognozētās izvades."""

    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:
        """Rediģē saturu ar izvades prognozēšanu."""
        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:
        """Īsceļš koda rediģēšanai."""
        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:
        """Īsceļš teksta rediģēšanai."""
        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."
            )
        )

Klases izmantošana

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

# Koda rediģēšana
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)

Salīdzinošais tests: ar prognozēšanu un bez tās

Neizlaid šo soli. Ieguvums no prognozētajām izvādēm ir pilnībā atkarīgs no tavu prognožu precizitātes, kas savukārt ir atkarīga no taviem datiem. Neviens skaitlis dokumentācijā neaizstāj mērījumus ar taviem paša paraugiem. Šis skripts salīdzina abus režīmus vieniem un tiem pašiem ievades datiem, sniedzot atbildi dažu sekunžu laikā:

import statistics

def benchmark_prediction(
    client, model, messages, prediction_content, runs=5
):
    """Salīdzina latentumu ar prognozēto izvadi un bez tās."""
    times_normal = []
    times_predicted = []

    for _ in range(runs):
        # Bez prognozēšanas
        start = time.perf_counter()
        client.chat.complete(model=model, messages=messages)
        times_normal.append((time.perf_counter() - start) * 1000)

        # Ar prognozēšanu
        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
    }

Kļūdu apstrāde

Kļūdu apstrāde šeit ir vienkārša strukturāla iemesla dēļ: nepareiza prognoze nav kļūda. Modelis to ignorē un ģenerē atbildi parastajā režīmā – tu zaudē latentuma ieguvumu, bet nekad kvalitāti. Reālie robežgadījumi slēpjas citur:

def safe_edit(editor, original, instruction):
    """Rediģēšana ar robustu kļūdu apstrādi."""
    try:
        result = editor.edit(original, instruction)

        # Pārbauda, vai atbilde nav tukša
        if not result.content or len(result.content.strip()) < 10:
            raise ValueError("Response too short or empty")

        return result

    except Exception as e:
        # Rezerves risinājums: atkārtot bez prognozēšanas
        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
        )

Ierobežojumi, kas jāzina

Pirms izvēršanas integrē savā koda pārskatīšanā trīs punktus. Pirmkārt, parametrs n (vairāku ģenerāciju veikšana) nav savietojams ar prediction. Ja tava cauruļvada prasība ir vairākas pabeigšanas, tev ir jāizvēlas. Otrkārt, atbilstību starp prognozi un izvadi apstrādā modelis neatkarīgi no satura pozīcijas atbildē – tev nav jāsagatavo nekāda izlīdzināšana. Visbeidzot, un tieši tas padara funkciju drošu izvēršanai: slikta prognoze nekad nepasliktina atbildes kvalitāti; tā tikai liedz iegūt latentuma uzlabojumu. Sliktākais scenārijs ir vienkārši atgriešanās pie parastā ātruma abos savietojamajos modeļos (mistral-large-latest un codestral-latest).

Galvenās atziņas

  • Parametrs prediction vienkārši papildina chat.complete() izsaukumu
  • Iekapsulē loģiku atkārtoti izmantojamā klasē ražošanas videi
  • Sistemātiski mēri ieguvumu ar salīdzinošo testu pirms izvēršanas
  • Plāno rezerves risinājumu bez prognozēšanas kļūdu gadījumā
  • Slikta prognoze nepasliktina kvalitāti, tikai ietekmē latentumu