Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

CI/CD għall-AI: Evals Awtomatizzati

Lezzjoni 18 / 20 Aġġornat 3 ta’ Novembru 2026 Avvanzat
F'din il-paġna
  1. Integra l-Evals fil-Pipeline CI/CD Tiegħek
  2. Il-Prinċipju: Gate, Mhux Rapport
  3. Għaqqad Kollox f’GitHub Actions
  4. Qabbel Minflok IĠĠudika f’Termini Assoluti
  5. Punti Ewlenin

Lezzjoni aġġornata fit-3 ta’ Novembru 2026 abbażi tad-dokumentazzjoni ta’ OpenAI: temperature u top_p huma aċċettati biss b’sforz ta’ raġunar ta’ none, filwaqt li l-mudelli GPT-5.6 jirraġunaw b’mod awtomatiku (medium). Għalhekk, is-sejħiet li jistabbilixxu dawn il-parametri għandhom jispeċifikaw reasoning={"effort": "none"} (API Responses) jew reasoning_effort="none" (Chat Completions). Sorsi: Użu ta’ GPT-6 · GPT-5.6 Terra.

Integra l-Evals fil-Pipeline CI/CD Tiegħek

Li tippubblika bidla fil-prompt fil-produzzjoni mingħajr evalwazzjoni huwa bħal li tippubblika kodiċi mingħajr testijiet. It-tqabbil huwa aktar preċiż milli jidher: fiż-żewġ każijiet, il-bidla tidher trivjali, tkun ġiet ivverifikata manwalment fuq eżempju jew tnejn, u l-effett sekondarju jidher tliet ijiem wara għal utent li mhux se jgħidulek. Id-differenza hija li r-reġressjoni ta’ prompt ma tqajjem l-ebda eċċezzjoni—l-applikazzjoni tkompli twieġeb, sempliċement agħar.

L-għan huwa li l-evalwazzjoni awtomatizzata ssir gate obbligatorja fil-proċess ta’ depljament tiegħek, li tiżgura li kull bidla żżomm jew itejjeb il-kwalità. Eżattament dan se nkopru hawn taħt.

Il-Prinċipju: Gate, Mhux Rapport

Il-pipeline tal-evals tintegra fil-fluss ta’ depljament tiegħek b’mekkaniżmu familjari. Żviluppatur ibiddel prompt jew parametru, il-commit jnedi l-pipeline CI, u l-evals jiġu eżegwuti awtomatikament fuq id-dataset ta’ referenza. Jekk il-punteġġi jilħqu s-soglie, id-depljament ikompli; inkella, jiġi mblukkat, b’rapport dettaljat li jindika liema evalwazzjoni falla’ u b’kemm.

Il-punt kritiku huwa l-imġiba tal-blokk. CI li jipproduċi rapport sabiħ mingħajr ma jwaqqaf il-pipeline isir artifatt li ħadd ma jċekkja wara żewġ ġimgħat. Kodiċi ta’ ħruġ mhux żero biss huwa dak li jibdel il-kejl f’guardrail.

L-iskript hawn taħt jaqra konfigurazzjoni, iġbed kull dataset, eżegwixxi l-każijiet, u jqabbel il-punteġġ medju mas-sogħla ddikjarata. Il-metodu ta’ punteġġ—sempliċi inklużjoni ta’ keywords—huwa rudimentali intenzjonalment: il-verifika ta’ CI trid tkun veloċi, deterministiku u indipendenti minn ġudikatur li l-punteġġ tiegħu jista’ jvarja minn eżekuzzjoni għal oħra.

import json
import sys
import openai
from pathlib import Path

client = openai.OpenAI()

def load_eval_config(path: str = "evals/config.json") -> dict:
    """Loads the evaluation configuration."""
    with open(path) as f:
        return json.load(f)

def load_dataset(path: str) -> list[dict]:
    """Loads a JSONL dataset."""
    cases = []
    with open(path) as f:
        for line in f:
            cases.append(json.loads(line))
    return cases

def run_ci_evals(config: dict) -> dict:
    """Runs evaluations for 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,
            )

            # Simple evaluation by keyword inclusion
            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  # No specific criterion

            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]:
    """Generates a report for CI and indicates if it's OK."""
    lines = ["# AI Evaluation Report\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"(threshold: {r['threshold']:.0%}, {r['num_cases']} cases)"
        )

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

Innota li l-prompt jinqara minn fajl u mhux miktub direttament fl-iskript. Dan huwa dak li jagħmel it-tnedija possibbli: prompt verżjonat fir-repo jipproduċi diff, u diff jista’ jnedi evalwazzjoni. Sakemm il-prompts tiegħek jgħixu bħala string literals imferrħa fil-kodiċi tal-applikazzjoni, awtomazzjoni ġenwina mhijiex possibbli.

Il-konfigurazzjoni tiddikjara evalwazzjoni waħda għal kull task, kull waħda bis-sogħla tagħha.

{
  "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
    }
  ]
}

Id-distanza bejn iż-żewġ soglia hija l-qalba tal-metodu. Il-klassifikazzjoni tat-tickets hija task magħluq: taħt 0.90, il-funzjonalità ma tagħtix is-servizz mistenni. Is-sommarizzazzjoni hija task miftuħ, ġġudikata fuq keywords li test tajjeb jista’ legalment jesprimi b’mod differenti; li teħtieġ 0.90 timblokka kull depljament u malajr twassal biex il-verifika tiġi diżattivata. Ikkalibra kull sodla abbażi tal-punteġġi osservati fil-produzzjoni u mhux abbażi ta’ numru tond li jkalmek.

Għaqqad Kollox f’GitHub Actions

Il-workflow jibda biss fuq paths rilevanti—prompts, evals, kodiċi tal-integrazzjoni tal-AI—sabiex bidla fil-stylesheet ma tkunx tispiċċa sejħiet 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

Żewġ dettalji ħaqqhom attent. Iċ-ċavetta API tgħaddi minn secrets tar-repo, qatt mill-workflow, li jinqara minn kull min għandu aċċess għall-kodiċi. U l-pubblikazzjoni tar-rapport tuża if: always(), inkella l-artifact ma jiġix prodott meta l-evals ifallu—eżattament l-uniku każ li fih ikollok bżonn taqrah.

L-iskript tad-dħul jgħaqqad kollox: jikteb ir-rapport fuq disk għall-artifact, jistampahu fil-logs, u jissettja l-kodiċi ta’ ħruġ li jippermetti jew jimblokka l-bqija tal-pipeline.

#!/usr/bin/env python3
"""Evaluation script for 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)

    # Write the report
    Path("evals/report.md").write_text(report)
    print(report)

    # Exit code for CI
    if not all_pass:
        print("\nSome evaluations failed. Deployment blocked.")
        sys.exit(1)
    else:
        print("\nAll evaluations pass.")
        sys.exit(0)

if __name__ == "__main__":
    main()

Qabbel Minflok IĠĠudika f’Termini Assoluti

Sodla fissa twieġeb il-mistoqsija “Din biżżejjed tajba?” Ma twieġibx “Din aħjar minn qabel?”, li spiss hija l-mistoqsija vera. Prompt miktub mill-ġdid jista’ jibqa’ ‘l fuq mis-sodla waqt li jitlef tliet punti meta mqabbel mal-verżjoni preċedenti: CI jidher aħdar u d-degradazzjoni tidħol fil-produzzjoni mingħajr ħadd ma jinnota.

Għalhekk it-test ta’ reġressjoni jaħdem iż-żewġ verżjonijiet fuq l-istess dataset, fl-istess kampanja, u jqabbel il-medji. Tolleranza ta’ 5% tassorbi l-ħoss inerenti għar-riżultati ġenerattivi; lil hinn minnhekk, il-verdet huwa espliċitu.

def prompt_regression_test(
    current_prompt: str,
    previous_prompt: str,
    dataset: list[dict],
    model: str,
    degradation_threshold: float = 0.05,
) -> dict:
    """Verifies that a new prompt does not degrade performance."""
    scores_current = []
    scores_previous = []

    for case in dataset:
        # Evaluate with current prompt
        r1 = client.responses.create(
            model=model, instructions=current_prompt,
            reasoning={"effort": "none"},  # temperature requires effort none
            input=case["input"], temperature=0.0,
        )
        # Evaluate with previous prompt
        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",
    }

Dan it-test jirdoppja n-numru ta’ sejħiet, u għalhekk l-ispiża u t-tul. Riżervu għall-bidliet fil-prompts, żommh ‘l bogħod mill-passaġġ tal-commits ordinarji, u eżegwixxi fuq sottset rappreżentattiv aktar milli fuq id-dataset ta’ referenza kollu.

Punti Ewlenin

  • Integra l-evals fil-pipeline CI/CD tiegħek bħall-unit tests
  • Verżjona l-prompts f’fajls: mingħajr diff, l-ebda tnedija mhija possibbli
  • Iddefinixxi soglie minimi skont it-tip ta’ evalwazzjoni, kalibrati fuq data tal-produzzjoni
  • Imblokka d-depljaments permezz tal-kodiċi ta’ ħruġ meta l-punteġġ jinżel taħt is-sodla
  • Ittestja għar-reġressjonijiet billi tqabbel il-prompts il-ġodda ma’ dawk il-qodma fuq l-istess dataset