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

CI/CD за ИИ: Автоматизирани оценки

Урок 18 от 20 Обновен 3 ноември 2026 г. Напреднало
На тази страница
  1. Интегриране на оценките във Вашия CI/CD конвейер
  2. Принципът: Бариера, а не отчет
  3. Свързване на всичко в GitHub Actions
  4. Сравнявайте, вместо да съдите в абсолютни стойности
  5. Ключови изводи

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

Интегриране на оценките във Вашия CI/CD конвейер

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

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

Принципът: Бариера, а не отчет

Конвейерът за оценки се интегрира във Вашия поток на разполагане чрез познат механизъм. Разработчик променя подкана или параметър, комитът задейства CI конвейера и оценките се изпълняват автоматично спрямо референтния набор от данни. Ако резултатите отговарят на праговете, разполагането продължава; в противен случай то се блокира, като се предоставя подробен отчет, показващ коя оценка е провалена и с колко.

Критичният момент е именно това поведение на блокиране. CI, който генерира красив отчет, без да спира конвейера, се превръща в артефакт, който никой не проверява след две седмици. Само кодът за изход, различен от нула, превръща измерването в предпазна мярка.

Скриптът по-долу чете конфигурация, зарежда всеки набор от данни, изпълнява случаите и сравнява средния резултат с обявения праг. Методът за оценяване – просто включване на ключови думи – е умишлено рудиментарен: проверката в CI трябва да бъде бърза, детерминирана и независима от съдия, чиято оценка може да варира от едно изпълнение до друго.

import json
import sys
import openai
from pathlib import Path

client = openai.OpenAI()

def load_eval_config(path: str = "evals/config.json") -> dict:
    """Зарежда конфигурацията за оценка."""
    with open(path) as f:
        return json.load(f)

def load_dataset(path: str) -> list[dict]:
    """Зарежда JSONL набор от данни."""
    cases = []
    with open(path) as f:
        for line in f:
            cases.append(json.loads(line))
    return cases

def run_ci_evals(config: dict) -> dict:
    """Изпълнява оценки за CI."""
    results = {}

    for eval_config in config["evaluations"]:
        name = eval_config["name"]
        dataset = load_dataset(eval_config["dataset"])
        threshold = eval_config["min_threshold"]
        model = eval_config["model"]
        prompt = Path(eval_config["prompt_file"]).read_text()

        scores = []
        for case in dataset:
            response = client.responses.create(
                model=model,
                reasoning={"effort": "none"},  # temperature requires effort none
                instructions=prompt,
                input=case["input"],
                temperature=0.0,
            )

            # Просто оценяване чрез включване на ключови думи
            if "keywords" in case:
                response_lower = response.output_text.lower()
                found = sum(
                    1 for word in case["keywords"]
                    if word.lower() in response_lower
                )
                score = found / len(case["keywords"])
            else:
                score = 1.0  # Няма специфичен критерий

            scores.append(score)

        avg_score = sum(scores) / len(scores)
        passed = avg_score >= threshold

        results[name] = {
            "score": avg_score,
            "threshold": threshold,
            "passed": passed,
            "num_cases": len(dataset),
        }

    return results

def ci_report(results: dict) -> tuple[str, bool]:
    """Генерира отчет за CI и указва дали е успешен."""
    lines = ["# Отчет за оценка на ИИ\n"]
    all_pass = True

    for name, r in results.items():
        status = "PASS" if r["passed"] else "FAIL"
        if not r["passed"]:
            all_pass = False
        lines.append(
            f"- [{status}] {name}: {r['score']:.2%} "
            f"(праг: {r['threshold']:.0%}, {r['num_cases']} случая)"
        )

    report = "\n".join(lines)
    return report, all_pass

Забележете, че подканата се чете от файл, вместо да бъде написана директно в скрипта. Това е което прави задействането възможно: версия на подканата, контролирана в хранилището, генерира разлика (diff), а разликата може да задейства оценка. Докато Вашите подкани съществуват като низови литерали, разпръснати из кода на приложението, правилната автоматизация не е възможна.

Конфигурацията декларира по една оценка за всяка задача, всяка със собствен праг.

{
  "evaluations": [
    {
      "name": "ticket-classification",
      "dataset": "evals/datasets/classification.jsonl",
      "prompt_file": "prompts/classification.txt",
      "model": "gpt-5.6-terra",
      "min_threshold": 0.90
    },
    {
      "name": "resume-generation",
      "dataset": "evals/datasets/resumes.jsonl",
      "prompt_file": "prompts/resume.txt",
      "model": "gpt-5.6-terra",
      "min_threshold": 0.75
    }
  ]
}

Разликата между тези два прага е сърцевината на метода. Класификацията на билети е затворена задача: под 0.90 функцията не предоставя очакваната услуга. Обобщаването е отворена задача, оценявана въз основа на ключови думи, които един добър текст може законно да формулира по различен начин; изискването на 0.90 би блокирало всяко разполагане и бързо би довело до деактивиране на проверката. Калибрирайте всеки праг въз основа на резултати, наблюдавани в продукционна среда, а не на закръглено число, което изглежда успокояващо.

Свързване на всичко в GitHub Actions

Работният поток се задейства само при съответните пътища – подкани, оценки, код за интеграция на ИИ – така че промяна в стиловете да не консумира API повиквания.

# .github/workflows/eval-ai.yml
name: AI Evaluation

on:
  pull_request:
    paths:
      - "prompts/**"
      - "evals/**"
      - "src/ai/**"

jobs:
  evaluate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"

      - run: pip install openai

      - name: Run evals
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
        run: python evals/run_ci.py

      - name: Publish report
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: eval-report
          path: evals/report.md

Два детайла заслужават внимание. API ключът преминава през секретите на хранилището, никога през файла на работния поток, който е достъпен за всеки с достъп до кода. И публикуването на отчета използва if: always(), в противен случай артефактът няма да бъде произведен, когато оценките се провалят – което е точно единственият случай, в който трябва да го прочетете.

Входният скрипт свързва всичко: той записва отчета на диска за артефакта, го отпечатва в дневниците и задава кода за изход, който позволява или блокира останалата част от конвейера.

#!/usr/bin/env python3
"""Скрипт за оценка за CI — evals/run_ci.py"""

import sys
from pathlib import Path

def main():
    config = load_eval_config("evals/config.json")
    results = run_ci_evals(config)
    report, all_pass = ci_report(results)

    # Записване на отчета
    Path("evals/report.md").write_text(report)
    print(report)

    # Код за изход за CI
    if not all_pass:
        print("\nНякои оценки се провалиха. Разполагането е блокирано.")
        sys.exit(1)
    else:
        print("\nВсички оценки са успешни.")
        sys.exit(0)

if __name__ == "__main__":
    main()

Сравнявайте, вместо да съдите в абсолютни стойности

Фиксираният праг отговаря на въпроса „Достатъчно добро ли е това?“. Той не отговаря на „По-добро ли е това от преди?“, което често е истинският въпрос. Пренаписана подкана може да остане над прага, докато губи три точки в сравнение с предишната версия: CI става зелен и влошаването навлиза в продукционна среда, без никой да забележи.

Следователно тестът за регресия изпълнява двете версии върху един и същ набор от данни, в една и съща кампания, и сравнява средните стойности. Толеранс от 5% поглъща шума, присъщ на генеративните изходи; отвъд това присъдата е изрична.

def prompt_regression_test(
    current_prompt: str,
    previous_prompt: str,
    dataset: list[dict],
    model: str,
    degradation_threshold: float = 0.05,
) -> dict:
    """Проверява дали нова подкана не влошава производителността."""
    scores_current = []
    scores_previous = []

    for case in dataset:
        # Оценяване с текущата подкана
        r1 = client.responses.create(
            model=model, instructions=current_prompt,
            reasoning={"effort": "none"},  # temperature requires effort none
            input=case["input"], temperature=0.0,
        )
        # Оценяване с предишната подкана
        r2 = client.responses.create(
            model=model, instructions=previous_prompt,
            reasoning={"effort": "none"},  # temperature requires effort none
            input=case["input"], temperature=0.0,
        )

        s1 = evaluate_response(r1.output_text, case)
        s2 = evaluate_response(r2.output_text, case)
        scores_current.append(s1)
        scores_previous.append(s2)

    avg_current = sum(scores_current) / len(scores_current)
    avg_previous = sum(scores_previous) / len(scores_previous)
    delta = avg_current - avg_previous

    return {
        "current_score": avg_current,
        "previous_score": avg_previous,
        "delta": delta,
        "regression": delta < -degradation_threshold,
        "verdict": "OK" if delta >= -degradation_threshold else "REGRESSION",
    }

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

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

  • Интегрирайте оценките във Вашия CI/CD конвейер като модулни тестове
  • Контролирайте версиите на подканите във файлове: без разлика (diff) задействане не е възможно
  • Дефинирайте минимални прагове за всеки тип оценка, калибрирани въз основа на данни от продукционна среда
  • Блокирайте разполаганията чрез код за изход, когато резултатите паднат под праговете
  • Тествайте за регресии, като сравнявате нови и стари подкани върху един и същ набор от данни