Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Architektūra gamybai: stebėjimas, įspėjimai, mastelio keitimas

Paskaita 20 iš 20 Atnaujinta 2026 m. lapkričio 3 d. Pažengusiems
Šiame puslapyje
  1. Tavo programa gamyboje: trys ramstai
  2. Stebėk: ką matuoti
  3. Reaguok: laipsniški įspėjimai
  4. Sugerk: trys atsparumo mechanizmai
  5. Gamybos diegimo kontrolinis sąrašas
  6. Svarbiausi punktai
  7. Patikrink savo žinias

Tavo programa gamyboje: trys ramstai

LLM programos diegimas į gamybą nėra tik kodas. Tris ramstus užtikrina patikimumą: stebėjimas (kad matytum), įspėjimai (kad reaguotum) ir mastelio keitimas (kad atlaikytum apkrovą). Jie sudaro grandinę, o grandinė yra tokia stipri, koks yra silpniausias jos grandis: metrikos, į kurias niekas nežiūri, yra nenaudingos; įspėjimai be reagavimo procedūros yra triukšmas; o mastelio keitimas, kuris įsijungia per vėlai, tiesiog reiškia sutrikimą. Ši paskutinė pamoka sujungia visus kurso konceptus į vientisą gamybos architektūrą.

Stebėk: ką matuoti

Keturių šeimos metrikos apima esmę: kvietimų skaičių, delsą, klaidas ir kainą, suskirstytą pagal modelius. Būtent skirstymas pagal modelius daro prietaisų skydelį veiksmingu – bendras 3 % klaidų rodiklis tau nieko nepasako, tačiau tas pats skaičius, sutelktas viename modelyje, iškart nurodo kaltininką.

Toliau pateikta klasė kaupia šias metrikas atmintyje, naudodama 10 000 delsos reikšmių slankųjį langą, kad procesas neaugtų be galo. Atkreipk dėmesį, kad naudojami percentiliai, o ne vidurkiai: LLM paslaugos vidutinė delsa beveik visada klaidina, nes keletas labai lėtų kvietimų „paslepiami“ vidurkyje, nors būtent dėl jų skundžiasi naudotojai.

import time
from dataclasses import dataclass, field
from collections import defaultdict

@dataclass
class ProductionMetrics:
    """Renka pagrindines gamybos metrikas."""

    counters: dict = field(default_factory=lambda: defaultdict(int))
    latencies: dict = field(default_factory=lambda: defaultdict(list))
    errors: dict = field(default_factory=lambda: defaultdict(int))
    costs: dict = field(default_factory=lambda: defaultdict(float))

    def record_call(
        self,
        model: str,
        latency: float,
        input_tokens: int,
        output_tokens: int,
        cost: float,
        success: bool,
    ):
        self.counters[model] += 1
        self.latencies[model].append(latency)
        self.costs[model] += cost

        if not success:
            self.errors[model] += 1

        # Paliekame tik paskutines 10 000 delsos reikšmių
        if len(self.latencies[model]) > 10_000:
            self.latencies[model] = self.latencies[model][-10_000:]

    def percentile(self, model: str, p: float) -> float:
        """Apskaičiuoja delsos percentilį."""
        values = sorted(self.latencies.get(model, []))
        if not values:
            return 0.0
        idx = int(len(values) * p / 100)
        return values[min(idx, len(values) - 1)]

    def error_rate(self, model: str) -> float:
        total = self.counters.get(model, 0)
        if total == 0:
            return 0.0
        return self.errors.get(model, 0) / total

    def dashboard(self) -> dict:
        """Generuoja išsamų prietaisų skydelį."""
        dashboard = {}
        for model in self.counters:
            dashboard[model] = {
                "calls": self.counters[model],
                "latency_p50": f"{self.percentile(model, 50):.2f}s",
                "latency_p99": f"{self.percentile(model, 99):.2f}s",
                "error_rate": f"{self.error_rate(model):.2%}",
                "total_cost": f"${self.costs[model]:.2f}",
            }
        return dashboard

Žinoma, rinkimas turi būti sistemingas. Rankinis kiekvieno kvietimo instrumentavimas garantuoja, kad vieną pamirši – ir greičiausiai būtent tą, kuris sukels problemų. Toliau pateiktas dekoratorius perkelia matavimą į kvietimo funkcijos lygmenį: blokas finally fiksuoja delsą ir sėkmę nepaisant nieko, net jei išimtis plinta toliau.

import openai
import functools

metrics = ProductionMetrics()

def monitor(func):
    """Dekoratorius, stebintis kiekvieną API kvietimą."""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        model = kwargs.get("model", args[0] if args else "unknown")
        start = time.perf_counter()
        success = True

        try:
            result = func(*args, **kwargs)
            return result
        except Exception as e:
            success = False
            raise
        finally:
            latency = time.perf_counter() - start
            metrics.record_call(
                model=model,
                latency=latency,
                input_tokens=0,
                output_tokens=0,
                cost=0,
                success=success,
            )

    return wrapper

Šioje versijoje žetonų skaitikliai ir kaina lieka nuliniai, nes atsakymo objektas įrašymo metu nėra prieinamas. Užpildyk juos nuskaitydami API grąžinamus naudojimo laukus: be šios informacijos tavo prietaisų skydelis sąžiningai rodys nulinių kainų stulpelį.

Reaguok: laipsniški įspėjimai

Įspėjimas yra vertingas tik tada, kai ragina veikti. Štai kodėl sistema kiekvienai metrikai išskiria dvi slenkstines reikšmes: įspėjimo slenkstį, signalizuojantį apie nukrypimą, kurį reikia išnagrinėti darbo metu, ir kritinį slenkstį, pateisinantį žmogaus pažadinimą. Šių dviejų supainiojimas sukelia blogiausią įmanomą rezultatą – komandą, kuri išmoko ignoruoti pranešimus.

from enum import Enum

class AlertLevel(Enum):
    INFO = "info"
    WARNING = "warning"
    CRITICAL = "critical"

class AlertSystem:
    """Generuoja įspėjimus pagal metrikas."""

    def __init__(self):
        self.thresholds = {
            "error_rate": {"warning": 0.05, "critical": 0.15},
            "latency_p99": {"warning": 10.0, "critical": 30.0},
            "hourly_cost": {"warning": 50.0, "critical": 200.0},
        }
        self.sent_alerts: list[dict] = []

    def check(self, metrics: ProductionMetrics) -> list[dict]:
        """Tikrina metrikas ir generuoja įspėjimus."""
        alerts = []

        for model in metrics.counters:
            # Klaidų rodiklis
            rate = metrics.error_rate(model)
            if rate >= self.thresholds["error_rate"]["critical"]:
                alerts.append({
                    "level": AlertLevel.CRITICAL,
                    "message": (
                        f"KRITINIS klaidų rodiklis modeliui {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })
            elif rate >= self.thresholds["error_rate"]["warning"]:
                alerts.append({
                    "level": AlertLevel.WARNING,
                    "message": (
                        f"Didelis klaidų rodiklis modeliui {model}: "
                        f"{rate:.1%}"
                    ),
                    "model": model,
                })

            # Delsa
            p99 = metrics.percentile(model, 99)
            if p99 >= self.thresholds["latency_p99"]["critical"]:
                alerts.append({
                    "level": AlertLevel.CRITICAL,
                    "message": (
                        f"KRITINIS p99 delsa modeliui {model}: "
                        f"{p99:.1f}s"
                    ),
                    "model": model,
                })

        self.sent_alerts.extend(alerts)
        return alerts

    async def notify(self, alerts: list[dict]):
        """Siunčia pranešimus (webhook, el. paštas, Slack)."""
        import httpx

        for alert in alerts:
            if alert["level"] == AlertLevel.CRITICAL:
                # Nedelsiant siunčiamas pranešimas
                async with httpx.AsyncClient() as http:
                    await http.post(
                        "https://your-webhook.example.com/alerts",
                        json={
                            "level": alert["level"].value,
                            "message": alert["message"],
                        },
                    )

Valandiniai kainų įspėjimai yra tie, kuriuos dažniausiai pamiršta, ir tai gaila: neribotas kartojimų ciklas arba du kartus paleistas grupinis darbas sukelia sąskaitą, o ne klaidą. Tai vienintelis saugos tinklas, aptinkantis tokio tipo incidentus jiems vykstant.

Sugerk: trys atsparumo mechanizmai

Kai API grąžina klaidą, kartojimas tik pablogina situaciją: tu didini apkrovą jau sutrikusiai paslaugai ir verči savo naudotojus laukti veltui. Grandinės pertraukiklis (circuit breaker) apverčia šią logiką. Po nustatyto skaičiaus nuoseklių nesėkmių jis „atidaro“ grandinę ir iškart atmeta vėlesnius kvietimus, o tada bando iš naujo po nustatyto atstatymo delsos laiko.

class CircuitBreaker:
    """Nutraukia kvietimus, kai įvyksta per daug klaidų."""

    def __init__(
        self,
        open_threshold: int = 5,
        reset_delay: float = 60.0,
    ):
        self.threshold = open_threshold
        self.reset_delay = reset_delay
        self.consecutive_failures = 0
        self.opened_at: float | None = None

    @property
    def is_open(self) -> bool:
        if self.opened_at is None:
            return False
        if time.time() - self.opened_at > self.reset_delay:
            # Bandoma uždaryti grandinę
            self.opened_at = None
            self.consecutive_failures = 0
            return False
        return True

    def record_success(self):
        self.consecutive_failures = 0
        self.opened_at = None

    def record_failure(self):
        self.consecutive_failures += 1
        if self.consecutive_failures >= self.threshold:
            self.opened_at = time.time()

    def call(self, func, *args, **kwargs):
        """Vykdo funkciją, jei grandinė uždara."""
        if self.is_open:
            raise RuntimeError(
                "Grandinė atidaryta – API nepasiekiamas. "
                f"Bandykite po {self.reset_delay}s."
            )
        try:
            result = func(*args, **kwargs)
            self.record_success()
            return result
        except Exception as e:
            self.record_failure()
            raise

Grandinės pertraukiklis saugo tavo programą, tačiau jos nepriverčia veikti. Tai yra modelio atsarginio varianto (fallback) užduotis, kuris bando alternatyvas eilės tvarka, praleisdamas tas, kurių grandinės jau atidarytos. Vienas svarbus dizaino aspektas: sąrašo tvarka yra produkto sprendimas, o ne techninis. Pirmiausia dėk modelį, teikiantį pageidaujamą paslaugą, o po jo – tuos, kurie teikia suprastintą, bet priimtiną paslaugą – šiek tiek mažiau aštrus atsakymas yra geriau nei neprieinamas pranešimas.

class ModelFallback:
    """Nesėkmės atveju perjungia į atsarginį modelį."""

    def __init__(self):
        self.models = ["gpt-5.6-terra", "gpt-5.6-sol", "gpt-5.6-luna"]
        self.circuits = {
            m: CircuitBreaker() for m in self.models
        }

    def call(self, prompt: str) -> str:
        """Bando kiekvieną modelį, kol gaunamas atsakymas."""
        client = openai.OpenAI()

        for model in self.models:
            circuit = self.circuits[model]
            if circuit.is_open:
                continue

            try:
                response = circuit.call(
                    client.responses.create,
                    model=model,
                    input=prompt,
                )
                return response.output_text
            except Exception:
                continue

        raise RuntimeError("Visi modeliai nepasiekiami.")

Trečiasis mechanizmas susijęs su pajėgumų planavimu. Darbuotojų skaičiaus valdymas pagal eilės dydį, o ne CPU apkrovą, yra teisingas refleksas paslaugai, kuri daugumą laiko praleidžia laukdama tinklo atsakymų: CPU lieka neveiklus, o eilė auga. Atkreipk dėmesį į taikomos taisyklės asimetriją – didinant mastelį dvigubiname, o mažinant – perpus, naudojant labai nutolusius slenkstinius rodiklius (100 prieš 10). Šis tarpas neleidžia svyruoti: be jo sistema nuolat kurtų ir naikintų darbuotojus ties lūžio tašku.

class AutoScaler:
    """Koreguoja darbuotojų skaičių pagal apkrovą."""

    def __init__(
        self,
        min_workers: int = 2,
        max_workers: int = 50,
        scale_up_threshold: int = 100,
        scale_down_threshold: int = 10,
    ):
        self.min_workers = min_workers
        self.max_workers = max_workers
        self.up_threshold = scale_up_threshold
        self.down_threshold = scale_down_threshold
        self.active_workers = min_workers

    def adjust(self, queue_size: int) -> int:
        """Grąžina rekomenduojamą darbuotojų skaičių."""
        if queue_size > self.up_threshold:
            self.active_workers = min(
                self.active_workers * 2,
                self.max_workers,
            )
        elif queue_size < self.down_threshold:
            self.active_workers = max(
                self.active_workers // 2,
                self.min_workers,
            )

        return self.active_workers

Gamybos diegimo kontrolinis sąrašas

Šis kursas baigiamas kontroliniu sąrašu, kurį reikia peržiūrėti prieš atveriant programą viešai. Kiekvienas punktas nurodo į pamoką, kurią jau išėjai; jei kuris nors atrodo neaiškus, perskaityk tą pamoką prieš diegdamas.

  • Delsos stebėjimas (p50, p95, p99) ir klaidų rodikliai
  • Įspėjimai sukonfigūruoti kritiniams slenkstiams
  • Grandinės pertraukiklis apsaugai nuo API gedimų
  • Sukonfigūruotas modelio atsarginis variantas
  • Įjungta įvesties ir išvesties moderacija
  • Įgyvendintas kliento pusės dažnio ribojimas
  • Struktūruoti žurnalai derinimui
  • Automatizuoti vertinimai CI/CD grandinėje
  • Kainos biudžetas su įspėjimais
  • Versijuota promptų dokumentacija

Svarbiausi punktai

  • Stebėjimas apima delsą, klaidas, kainas ir atsakymų kokybę
  • Sekite delsos percentilius, niekada tik vidurkį
  • Įspėjimai turi būti laipsniški: pirmiausia įspėjimas, paskui kritinis
  • Grandinės pertraukiklis saugo nuo gedimų kaskados; atsarginis variantas užtikrina prieinamumą
  • Gamybos kontrolinis sąrašas neleidžia praleisti kritinių dalykų

Patikrink savo žinias

Delsa, kainos, vertinimai: gamybos refleksai penkiuose klausimuose.

1. Kokie yra pagrindiniai svertai delsumui mažinti?

Atsakymas: Srautinis perdavimas (suvokiama delsa), promptų talpyklojimas (stabilūs priešdėliai), numatytos išvestys, kai atsakymas didžiąja dalimi nuspėjamas (Chat Completions, modeliuose, pašalintuose 2027 m. sausio 14 d.), ir paties prompto optimizavimas – matuojama nuo galo iki galo.

2. Kada reikėtų naudoti Batch API?

Atsakymas: Masiniam apdorojimui be realaus laiko reikalavimų: asinchroninės grupės sumažinta kaina – reitingavimas, praturtinimas arba didelės apimties generavimas neturi vietos sinchroniniame kelyje.

3. Ką daro pokalbio glaustinimas?

Atsakymas: Jis suspaudžia ilgą istoriją (santraukos, genėjimas), kad tilptų į kontekstą ir kontroliuotų kainas – tai būtina agentams ir ilgoms sesijoms.

4. Kokia yra Evals sistemos paskirtis CI/CD?

Atsakymas: Automatiškai vykdyti tavo vertinimus kiekvieną kartą pakeitus promptą ar modelį: regresija aptinkama įvykdžius commit, o ne gamyboje.

5. Ką apima pilna gamybos architektūra?

Atsakymas: Stebėjimą (delsa, kainos, kokybė), įspėjimus, asinchronines eiles, mastelio moderaciją ir mastelio keitimo planą – AI gamyboje yra sistema, o ne API kvietimas.

Matuok, talpykluok, grupuok, nuolat vertink: keturi įpročiai, darantys programas greitas, lengvas ir patikimas.