Salt la conținutul principal
Română— Alege o limbă
Meniu

Implementarea ieșirilor prezise în Python

Lecția 7 din 16 Actualizată 2 noiembrie 2026 Avansat
Pe această pagină
  1. De la concept la cod de producție
  2. Implementare de bază
  3. Clasă utilitară pentru producție
  4. Benchmark: Cu versus fără predicție
  5. Gestionarea erorilor
  6. Constrângeri de cunoscut
  7. Puncte cheie

De la concept la cod de producție

Ați înțeles principiul din spatele ieșirilor prezise (Predicted Outputs) și cazurile lor de utilizare. Această lecție oferă cod Python complet, gata de integrare în aplicațiile dumneavoastră, inclusiv gestionarea erorilor și măsurarea performanței.

Implementare de bază

Modelul minimal necesită un singur parametru: prediction, prin care transmiteți conținutul așteptat. Restul apelului rămâne neschimbat—același model, aceleași mesaje, aceeași gestionare a răspunsului. Acest lucru face ca funcționalitatea să fie ușor de adoptat și la fel de ușor de eliminat dacă metricile nu confirmă câștigul:

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)

Clasă utilitară pentru producție

Encapsularea oferă aici avantaje dincolo de un cod curat: centralizează decizia de a activa sau dezactiva predicția. Acesta este exact genul de setare pe care doriți să o comutați instantaneu. Dacă o implementare relevă predicții constant incorecte, le puteți dezactiva într-un singur punct, în loc să căutați parametrul în întreaga bază de cod:

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:
    """Editor de conținut folosind ieșiri prezise."""

    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:
        """Editează conținutul cu predicția ieșirii."""
        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:
        """Scurtătură pentru editarea codului."""
        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:
        """Scurtătură pentru editarea textului."""
        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."
            )
        )

Utilizarea clasei

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

# Editare cod
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)

Benchmark: Cu versus fără predicție

Nu săriți peste acest pas. Câștigul oferit de ieșirile prezise depinde în totalitate de acuratețea predicțiilor dumneavoastră, care la rândul lor depind de datele dumneavoastră. Nicio cifră din documentație nu înlocuiește măsurarea pe propriile exemple. Acest script compară ambele moduri pe aceleași intrări, oferindu-vă răspunsul în câteva secunde:

import statistics

def benchmark_prediction(
    client, model, messages, prediction_content, runs=5
):
    """Compară latența cu și fără ieșire prezisă."""
    times_normal = []
    times_predicted = []

    for _ in range(runs):
        # Fără predicție
        start = time.perf_counter()
        client.chat.complete(model=model, messages=messages)
        times_normal.append((time.perf_counter() - start) * 1000)

        # Cu predicție
        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
    }

Gestionarea erorilor

Gestionarea erorilor este simplă aici dintr-un motiv structural: o predicție incorectă nu constituie o eroare. Modelul o ignoră și generează normal—pierdeți câștigul de latență, niciodată calitatea. Cazurile limită reale se află în altă parte:

def safe_edit(editor, original, instruction):
    """Editare cu gestionare robustă a erorilor."""
    try:
        result = editor.edit(original, instruction)

        # Verifică dacă răspunsul nu este gol
        if not result.content or len(result.content.strip()) < 10:
            raise ValueError("Response too short or empty")

        return result

    except Exception as e:
        # Fallback: reîncearcă fără predicție
        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
        )

Constrângeri de cunoscut

Înainte de implementare, integrați trei puncte în revizuirea codului dumneavoastră. În primul rând, parametrul n (generări multiple) este incompatibil cu prediction. Dacă pipeline-ul dumneavoastră solicită mai multe completări, trebuie să faceți o alegere. În al doilea rând, corespondența dintre predicție și ieșire este gestionată de model indiferent de poziția conținutului în răspuns—nu trebuie să pregătiți nicio aliniere. În final, și acesta este aspectul care face ca funcționalitatea să fie sigură pentru implementare: o predicție slabă nu degradează niciodată calitatea răspunsului; vă costă doar câștigul de latență. Scenariul cel mai defavorabil este pur și simplu o revenire la viteza normală pe cele două modele compatibile (mistral-large-latest și codestral-latest).

Puncte cheie

  • Parametrul prediction se adaugă pur și simplu apelului chat.complete()
  • Encapsulați logica într-o clasă reutilizabilă pentru producție
  • Măsurați sistematic câștigul cu un benchmark înainte de implementare
  • Planificați o soluție de rezervă (fallback) fără predicție în caz de erori
  • O predicție slabă nu degradează calitatea, ci doar latența