Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Υλοποίηση Προβλεπόμενων Εξόδων σε Python

Μάθημα 7 / 16 Ενημερώθηκε 2 Νοεμβρίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Από την Έννοια στον Κώδικα Παραγωγής
  2. Βασική Υλοποίηση
  3. Κλάση Βοηθητικών Λειτουργιών για Παραγωγή
  4. Benchmark: Με vs. Χωρίς Πρόβλεψη
  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)

Benchmark: Με vs. Χωρίς Πρόβλεψη

Μην παραλείψετε αυτό το βήμα. Το όφελος από τις Προβλεπόμενες Εξόδους εξαρτάται εξ ολοκλήρου από την ακρίβεια των προβλέψεών σας, η οποία με τη σειρά της εξαρτάται από τα δεδομένα σας. Κανένας αριθμός από την τεκμηρίωση δεν αντικαθιστά τη μέτρηση στα δικά σας παραδείγματα. Αυτό το σενάριο συγκρίνει και τις δύο λειτουργίες στις ίδιες εισόδους, δίνοντάς σας την απάντηση σε δευτερόλεπτα:

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):
    """Επεξεργασία με robust διαχείριση σφαλμάτων."""
    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:
        # Fallback: επανάληψη χωρίς πρόβλεψη
        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()
  • Ενθυλακώστε τη λογική σε μια επαναχρησιμοποιήσιμη κλάση για παραγωγή
  • Μετράτε συστηματικά το όφελος με ένα benchmark πριν την ανάπτυξη
  • Σχεδιάστε ένα fallback χωρίς πρόβλεψη σε περίπτωση σφαλμάτων
  • Μια κακή πρόβλεψη δεν υποβαθμίζει την ποιότητα, μόνο τον χρόνο απόκρισης