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

Създаване на персонализирани оценки

Урок 16 от 20 Обновен 3 ноември 2026 г. Напреднало
На тази страница
  1. Адаптирайте оценките към вашата област
  2. Превърнете бизнес изискването в рубрика
  3. Когато машината съди по-добре от човека
  4. Направете оценката повторяема
  5. Ключови изводи

Урокът е актуализиран на 3 ноември 2026 г. въз основа на документацията на OpenAI: параметрите temperature и top_p се приемат само при усилие за разсъждение (reasoning effort) от none, докато моделите GPT-5.6 разсъждават по подразбиране (medium). Заявките, които задават тези параметри, следователно трябва да уточняват reasoning={"effort": "none"} (API Responses) или reasoning_effort="none" (Chat Completions). Източници: Използване на GPT-6 · GPT-5.6 Terra.

Актуализация от 2 ноември 2026 г. — Платформа Evals. OpenAI обяви края на своята платформа Evals: съществуващите оценки са само за четене от 31 октомври 2026 г., а както таблото за управление, така и API, включително оценителите (graders), ще бъдат затворени на 30 ноември 2026 г. OpenAI публикува ръководство за миграция към Promptfoo. Принципите на оценяване в този урок остават валидни; променя се единствено инструментът.

Адаптирайте оценките към вашата област

Общите оценители не са достатъчни, за да преценят качеството във вашата специфична област. Медицински чатбот, юридически асистент и инструмент за маркетингово писане имат различни критерии за качество и тези критерии не просто са по-многочислени, а са приоритизирани по различен начин. Несъответствие в тона на информационен бюлетин е досадно; същото приблизително тълкуване в инструкция за дозиране е сериозна грешка. Един общ оценител третира и двете по един и същи начин, което се равнява на това изобщо да не оценявате нищо.

Ето защо се нуждаете от персонализирани оценки, базирани на ясна рубрика, която превръща вашите бизнес приоритети във тежести. Това е рубриката, която ще изградим.

Превърнете бизнес изискването в рубрика

Рубриката е списък с претеглени критерии, чиято сума е равна на 1. Най-полезното упражнение не е кодирането на структурата, което отнема около петнадесет реда, а нейното попълване: решението, че ползите за клиента тежат 0,25, докато дължината тежи само 0,10, принуждава към ясен разговор със собствениците на продукта. Крайният резултат е споделена дефиниция за „добър отговор“, която никой не може да оспори впоследствие.

from dataclasses import dataclass

@dataclass
class Critere:
    nom: str
    description: str
    poids: float  # 0 to 1, sum of weights = 1

@dataclass
class Rubrique:
    nom: str
    criteres: list[Critere]

    def valider(self) -> bool:
        total = sum(c.poids for c in self.criteres)
        return abs(total - 1.0) < 0.01

# Example: rubric for a marketing writing assistant
rubrique_marketing = Rubrique(
    nom="Qualité rédaction marketing",
    criteres=[
        Critere("ton", "Le ton est professionnel et engageant", 0.20),
        Critere("cta", "Contient un appel à l'action clair", 0.15),
        Critere("benefices", "Met en avant les bénéfices client", 0.25),
        Critere("longueur", "Respecte la longueur demandée", 0.10),
        Critere("grammaire", "Aucune faute de grammaire ou orthographe", 0.15),
        Critere("marque", "Respecte les guidelines de la marque", 0.15),
    ],
)

Методът valider заслужава да бъде извикван в тестовете, а не просто да бъде написан. Рубриките еволюират: добавяте критерий за съответствие, премахвате такъв, който вече не е полезен, и сумата се отклонява до 1,15, без нищо да сигнализира за аномалията. Резултатите остават изчислими, просто са грешни, и при сравнение между версиите ще Ви доведат до погрешни изводи.

След това оценителят превръща рубриката в подкана (prompt), иска оценка от 0 до 5 за всеки критерий и рекомбинира претеглен глобален резултат. Всяка оценка идва с кратък коментар: това е, което ще Ви позволи, когато преглеждате лоши случаи, да разберете дали моделът е отговорил зле, или дали Вашият критерий е бил формулиран лошо.

import openai
import json

client = openai.OpenAI()

def evaluer_multi_criteres(
    question: str,
    reponse: str,
    rubrique: Rubrique,
) -> dict:
    """Evaluates a response against a multi-criteria rubric."""

    criteres_texte = "\n".join(
        f"- {c.nom} (poids: {c.poids}): {c.description}"
        for c in rubrique.criteres
    )

    prompt = (
        "Évaluez cette réponse selon les critères suivants.\n"
        "Pour chaque critère, donnez un score de 0 à 5.\n\n"
        f"Question posée : {question}\n"
        f"Réponse à évaluer : {reponse}\n\n"
        f"Critères :\n{criteres_texte}\n\n"
        "Répondez en JSON avec un objet scores contenant pour chaque critère "
        "un score (0-5) et un commentaire court."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=prompt,
        temperature=0.0,
    )

    try:
        resultat = json.loads(response.output_text)
        scores = resultat.get("scores", {})

        # Calculate weighted score
        score_pondere = 0
        for critere in rubrique.criteres:
            if critere.nom in scores:
                score_brut = scores[critere.nom]["score"] / 5.0
                score_pondere += score_brut * critere.poids

        return {
            "score_global": score_pondere,
            "scores_details": scores,
            "rubrique": rubrique.nom,
        }
    except (json.JSONDecodeError, KeyError):
        return {"score_global": 0, "erreur": "Parsing échoué"}

Внимавайте с цикъла за изчисление: критерий, липсващ в отговора на съдията, се игнорира мълчаливо и допринася с нула за претегления резултат. Един отличен отговор следователно може да бъде ограничен до 0,75 просто защото съдията е пропуснал ключов елемент. Ако резултатите Ви изглеждат заседнали под необясним таван, проверете scores_details, преди да обвинявате оценявания модел.

Когато машината съди по-добре от човека

Използването на LLM за оценяване на код е скъп компромис: единствената присъда, която има значение, е изпълнението. Оценителят по-долу конкатенира генерирания код и тест, записва ги във временен файл, изпълнява ги и брои успехите. Полученият резултат не се нуждае от тълкуване — един тест или минава, или не.

import subprocess
import tempfile

def evaluer_code_python(
    code_genere: str,
    tests: list[str],
) -> dict:
    """Evaluates Python code by executing it against tests."""
    resultats_tests = []

    for i, test in enumerate(tests):
        code_complet = f"{code_genere}\n\n{test}"

        with tempfile.NamedTemporaryFile(
            mode="w", suffix=".py", delete=False
        ) as f:
            f.write(code_complet)
            f.flush()

            try:
                resultat = subprocess.run(
                    ["python3", f.name],
                    capture_output=True,
                    text=True,
                    timeout=10,
                )
                succes = resultat.returncode == 0
                resultats_tests.append({
                    "test": i,
                    "succes": succes,
                    "sortie": resultat.stdout[:200],
                    "erreur": resultat.stderr[:200] if not succes else "",
                })
            except subprocess.TimeoutExpired:
                resultats_tests.append({
                    "test": i,
                    "succes": False,
                    "erreur": "Timeout (10s)",
                })

    nb_succes = sum(1 for r in resultats_tests if r["succes"])
    return {
        "score": nb_succes / len(tests) if tests else 0,
        "tests_passes": nb_succes,
        "tests_total": len(tests),
        "details": resultats_tests,
    }

Параметърът timeout=10 не е мярка за комфорт: моделът редовно произвежда безкрайни цикли и без тази граница Вашата кампания за оценяване ще заседне на първия неуспешен случай. Също така помнете, че изпълнявате код, който не сте написали Вие — извън изолирана среда за разработка тази функция изисква пясъчник (sandbox).

Обобщението илюстрира смесен случай, при който част от преценката е механична, а част не е. Дължината е измерима: изчисленият коефициент наказва както резюме, което е твърде кратко, така и такова, което е твърде дълго, симетрично, което избягва трика на модела да копира изходния текст, за да не пропусне нищо. Верността, от друга страна, не може да се измери чрез правило и се връща към LLM съдията, с директен въпрос за измислена информация.

def evaluer_resume(
    texte_original: str,
    resume: str,
    longueur_cible: int = 100,
) -> dict:
    """Evaluates summary quality."""
    mots_resume = len(resume.split())
    ratio_longueur = min(
        mots_resume / longueur_cible,
        longueur_cible / max(mots_resume, 1),
    )

    # Fidelity via LLM
    response = client.responses.create(
        model="gpt-5.6-terra",
        input=(
            f"Le résumé suivant est-il fidèle au texte original ? "
            f"Contient-il des informations inventées ?\n\n"
            f"Texte original (extrait) : {texte_original[:2000]}\n\n"
            f"Résumé : {resume}\n\n"
            f"Répondez en JSON avec les clés : fidélité (0-5), "
            f"hallucinations (oui/non), commentaire (court)."
        ),
        temperature=0.0,
    )

    try:
        fidelite = json.loads(response.output_text)
    except json.JSONDecodeError:
        fidelite = {"fidelite": 0, "hallucinations": "inconnu"}

    return {
        "score_longueur": ratio_longueur,
        "score_fidelite": fidelite.get("fidelite", 0) / 5.0,
        "hallucinations": fidelite.get("hallucinations", "inconnu"),
        "mots_resume": mots_resume,
        "longueur_cible": longueur_cible,
    }

Направете оценката повторяема

Оценка, която повтаряте ръчно, в крайна сметка спира да бъде повтаряна. Тръбопроводът encapsulates рубриката и пази история на кампаниите, превръщайки еднократно измерване във времеви ред: виждате, че средният резултат е спаднал от 0,81 на 0,79 след промяната в подканата (prompt) във вторник, информация, която нито едно изолирано изпълнение не би могло да Ви даде.

class PipelineEval:
    """Reusable evaluation pipeline."""

    def __init__(self, nom: str, rubrique: Rubrique):
        self.nom = nom
        self.rubrique = rubrique
        self.historique: list[dict] = []

    def evaluer_batch(
        self,
        dataset: list[dict],
        modele: str,
        prompt_systeme: str,
    ) -> dict:
        """Evaluates a full batch and returns metrics."""
        resultats = []

        for cas in dataset:
            response = client.responses.create(
                model=modele,
                instructions=prompt_systeme,
                input=cas["input"],
            )

            eval_result = evaluer_multi_criteres(
                cas["input"],
                response.output_text,
                self.rubrique,
            )
            resultats.append(eval_result)

        scores = [r["score_global"] for r in resultats]
        rapport = {
            "pipeline": self.nom,
            "modele": modele,
            "nb_cas": len(dataset),
            "score_moyen": sum(scores) / len(scores),
            "score_min": min(scores),
            "score_max": max(scores),
        }

        self.historique.append(rapport)
        return rapport

Един съвет за начало: изградете първата си рубрика върху само двадесет случая, накарайте я да бъде оценена паралелно от LLM съдията и от експерт в областта, след което сравнете двете серии. Разминаванията ще Ви кажат кои критерии са описани лошо много преди да Ви кажат каквото и да е за качеството на модела.

Ключови изводи

  • Създавайте оценъчни рубрики, специфични за вашата бизнес област, с явни тежести
  • Проверявайте дали сумата от тежестите остава равна на 1, докато рубриката еволюира
  • Комбинирайте автоматизирана оценка (код, дължина) и LLM-като-съдия (качество)
  • Тествайте генерирания код, като го изпълнявате, с таймаут и в изолирана среда
  • Изградете многократен тръбопровод, който пази история на кампаниите