Lidsky řečeno
Natrénovat model je jako koupit auto. Provoz je všechno potom: technická kontrola, servisní knížka, tankování, kontrolky na palubní desce a náhradní vůz, když se něco pokazí. Silnice se navíc pod autem pomalu mění. MLOps je soubor postupů, díky kterým model nezůstane jen hezkým výsledkem v notebooku a po půl roce potichu nezačne škodit.
Čím se model liší od běžného programu
Běžný program selže většinou viditelně: spadne, vrátí chybu. Model selže tiše. Dál odpovídá rychle a se stavem 200, jen čím dál hůř. Jeho chování navíc neurčuje jen kód, ale čtyři věci dohromady: kód, data, konfigurace a naučené váhy. Změna kterékoli z nich je nová verze.
data ─► příprava ─► trénink ─► vyhodnocení ─► registr ─► nasazení
▲ │
│ ▼
└───────────── přetrénování ◄──── sledování ◄──────── provozOtisk: co přesně jsme natrénovali
Když se za tři měsíce někdo zeptá, z čeho produkční model vznikl, musí existovat odpověď. Základ je otisk (hash): krátký kód vypočítaný z obsahu. Stejný obsah dá stejný otisk, sebemenší změna úplně jiný. U konfigurace je potřeba zapsat klíče vždy ve stejném pořadí.
import hashlib
import json
def fingerprint(value):
text = json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
return hashlib.sha256(text.encode("utf-8")).hexdigest()[:12]
a = {"lr": 0.01, "layers": 3, "features": ["vek", "cena"]}
b = {"features": ["vek", "cena"], "layers": 3, "lr": 0.01}
c = {"lr": 0.02, "layers": 3, "features": ["vek", "cena"]}
print(fingerprint(a) == fingerprint(b))
print(fingerprint(a) == fingerprint(c))
True False
Otisky dat, konfigurace a commitu kódu se uloží k modelu. Registr modelů je pak katalog verzí: co existuje, jak si to vedlo a co právě běží v provozu. Nejdůležitější vlastnost registru je, že se umí vrátit zpět jedním krokem.
class Registry:
def __init__(self):
self.versions = {}
self.history = []
def register(self, metrics, data_hash, code_commit):
version = len(self.versions) + 1
self.versions[version] = {"metrics": metrics, "data": data_hash, "code": code_commit}
return version
@property
def production(self):
return self.history[-1] if self.history else None
def promote(self, version):
if version not in self.versions:
raise KeyError(f"unknown version {version}")
self.history.append(version)
def rollback(self):
if len(self.history) < 2:
raise RuntimeError("nothing to roll back to")
self.history.pop()
return self.production
registry = Registry()
v1 = registry.register({"f1": 0.81}, "a13f", "9c2e1d0")
v2 = registry.register({"f1": 0.84}, "b77c", "4fd07aa")
registry.promote(v1)
registry.promote(v2)
print("v provozu:", registry.production, registry.versions[registry.production])
print("po návratu:", registry.rollback())
v provozu: 2 {'metrics': {'f1': 0.84}, 'data': 'b77c', 'code': '4fd07aa'}
po návratu: 1Pustit kandidáta do provozu?
Napiš funkci should_promote(candidate, production, min_gain=0.01, max_latency_ratio=1.2). Oba modely jsou slovníky s klíči f1 a latency_ms. Když production je None, vrať True. Jinak vrať True, jen když f1 kandidáta je lepší aspoň o min_gain a jeho latence není větší než max_latency_ratio násobek produkční.
def should_promote(candidate, production, min_gain=0.01, max_latency_ratio=1.2):
# doplň
return True
Stejná příprava dat všude
Častá provozní chyba má jméno training-serving skew: v tréninku se vstupy připravily jinak než v provozu. Model pak dostává čísla, na která nebyl zvyklý. Řešení je mít přípravu v jedné funkci a její parametry uložit spolu s modelem.
V provozu to nefunguje
Model se učil na škálovaných datech. Funkce prepare_request má škálovat jeden požadavek parametry z tréninku. V produkci ale vrací samé nan a pro dvě hodnoty dává nesmysly.
Sledování: data se pod modelem mění
Svět se hýbe. Lidé mění chování, dodavatel změní formát, přijde sezóna. Tomu se říká drift. Rozeznáváme dva hlavní druhy:
- Data drift: změnilo se, jaké vstupy chodí.
- Concept drift: vstupy vypadají stejně, ale změnil se jejich vztah k výsledku.
Skutečné správné odpovědi často přijdou až za týdny, například jestli klient opravdu nesplatil úvěr. Vstupy ale vidíš hned. Běžná míra změny rozdělení je PSI, population stability index. Referenční data se rozdělí do košů, porovná se podíl hodnot v každém z nich a odchylky se sečtou. Posuň nová data a sleduj výsledek.
PSI = součet přes koše: (nový_podíl - starý_podíl) · ln(nový_podíl / starý_podíl)import numpy as np
def psi(reference, current, bins=10):
edges = np.quantile(reference, np.linspace(0, 1, bins + 1))
edges[0], edges[-1] = -np.inf, np.inf
old = np.histogram(reference, edges)[0] / len(reference)
new = np.histogram(current, edges)[0] / len(current)
old, new = np.clip(old, 1e-6, None), np.clip(new, 1e-6, None)
return float(((new - old) * np.log(new / old)).sum())
rng = np.random.RandomState(0)
reference = rng.normal(0, 1, 5000)
current = rng.normal(posun, 1, 2000)
value = psi(reference, current)
state = "stabilní" if value < 0.1 else "sledovat" if value < 0.25 else "prověřit"
print(f"posun průměru: {posun:.1f}")
print(f"PSI: {value:.3f} -> {state}")
posun průměru: 0.5 PSI: 0.256 -> prověřit
Hranice 0,1 a 0,25 jsou zvyklost z praxe, ne přírodní zákon. Nastav je podle toho, jak se metrika chovala na tvých historických datech.
PSI z počtů
Napiš funkci psi_from_counts(old, new, eps=1e-6). Dostane dva seznamy počtů ve stejných koších. Převede je na podíly, hodnoty menší než eps nahradí číslem eps a vrátí PSI jako float. Můžeš použít NumPy.
import numpy as np
def psi_from_counts(old, new, eps=1e-6):
# doplň
return 0.0
Stabilní vstupy ale nejsou důkaz, že je všechno v pořádku. V další ukázce se rozdělení vstupů vůbec nezmění, změní se jen pravidlo, podle kterého vzniká správná odpověď.
import numpy as np
rng = np.random.RandomState(1)
def psi(a, b, bins=10):
edges = np.quantile(a, np.linspace(0, 1, bins + 1))
edges[0], edges[-1] = -np.inf, np.inf
p = np.clip(np.histogram(a, edges)[0] / len(a), 1e-6, None)
q = np.clip(np.histogram(b, edges)[0] / len(b), 1e-6, None)
return float(((q - p) * np.log(q / p)).sum())
X_old = rng.normal(size=(2000, 2))
y_old = (X_old[:, 0] + X_old[:, 1] > 0).astype(float)
w = np.zeros(2)
for _ in range(200):
p = 1 / (1 + np.exp(-X_old @ w))
w -= 0.5 * X_old.T @ (p - y_old) / len(X_old)
def accuracy(X, y):
return float((((X @ w) > 0) == y).mean())
X_new = rng.normal(size=(2000, 2))
y_new = (X_new[:, 0] - X_new[:, 1] > 0).astype(float)
print(f"přesnost na starém světě: {accuracy(X_old, y_old):.1%}")
print(f"přesnost na novém světě: {accuracy(X_new, y_new):.1%}")
print(f"PSI prvního vstupu: {psi(X_old[:, 0], X_new[:, 0]):.3f}")
print(f"PSI druhého vstupu: {psi(X_old[:, 1], X_new[:, 1]):.3f}")
přesnost na starém světě: 99.8% přesnost na novém světě: 51.3% PSI prvního vstupu: 0.004 PSI druhého vstupu: 0.010
Detektor driftu vstupů by tady mlčel. Proto se vyplatí sbírat skutečné výsledky, i když přicházejí opožděně, a sledovat i nepřímé signály, třeba kolik doporučení uživatelé přijali.
Jaký drift?
Roztřiď situace.
Alarm, který nezlobí
Jediná špička nemá nikoho budit. Napiš funkci should_alert(values, threshold, window), která vrátí True, jen když je k dispozici aspoň window hodnot a všech posledních window hodnot je větších než threshold.
def should_alert(values, threshold, window):
# doplň
return False
Latence: průměr lže
Průměrná doba odpovědi působí uklidňujícím dojmem, protože schová pomalé požadavky. Sleduje se proto percentil. p95 je hodnota, pod kterou leží 95 % měření. Tipni si, jak daleko bude p99 od průměru.
import numpy as np
rng = np.random.RandomState(0)
latency_ms = rng.lognormal(mean=3.5, sigma=0.7, size=20000)
print(f"průměr: {latency_ms.mean():6.0f} ms")
for q in [50, 95, 99]:
print(f"p{q}: {np.percentile(latency_ms, q):6.0f} ms")
průměr: 42 ms p50: 33 ms p95: 104 ms p99: 171 ms
Nasazení bez hazardu
Nový model se nepřepíná všem naráz. Vyšší jistotu získáš postupně.
Spoj strategii s popisem
Přiřaď způsob nasazení.
Canary se vyhodnocuje automaticky. Porovná chybovost nové verze s produkcí a statistickým testem ověří, že rozdíl není jen náhoda. Měň chybovost nové verze.
import math
import numpy as np
rng = np.random.RandomState(4)
n_prod, n_canary = 9000, 1000
errors_prod = int(rng.binomial(n_prod, 0.02))
errors_canary = int(rng.binomial(n_canary, chyby_canary / 100))
p_prod, p_canary = errors_prod / n_prod, errors_canary / n_canary
pooled = (errors_prod + errors_canary) / (n_prod + n_canary)
se = math.sqrt(pooled * (1 - pooled) * (1 / n_prod + 1 / n_canary))
z = (p_canary - p_prod) / se
print(f"produkce: {p_prod:.2%} chyb, canary: {p_canary:.2%} chyb")
print(f"z = {z:.2f}")
print("ROLLBACK" if z > 2.33 else "pokračovat a zvýšit podíl provozu")
produkce: 2.32% chyb, canary: 4.10% chyb z = 3.42 ROLLBACK
Přesnost modelu v provozu nikdo neměří, protože správné odpovědi přijdou až za měsíc. Co dává smysl hned?
Drift vstupů a výstupů je rychlý, i když neúplný signál. Slepé přetrénování může do modelu přinést právě tu chybu v datech, kterou nikdo nezkontroloval.
Co udělá shadow nasazení?
Ověříš tak výkon a chování na reálných vstupech bez rizika pro uživatele. Pozor jen na vedlejší účinky, třeba volání dalších služeb.
Model jako služba
Typické řešení je malá webová služba. Model se načte jednou při startu, vstupy ověří schéma a každá odpověď nese verzi modelu, aby se dala dohledat. Kód vyžaduje fastapi, uvicorn a joblib, proto se v prohlížeči nespouští.
from contextlib import asynccontextmanager
import joblib
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
MODEL_VERSION = "2026-11-18-a13f"
state = {}
class Features(BaseModel):
age: int = Field(ge=0, le=120)
amount: float = Field(gt=0)
@asynccontextmanager
async def lifespan(app: FastAPI):
# Load only artifacts from your own verified registry.
state["model"] = joblib.load("model.joblib")
yield
state.clear()
app = FastAPI(lifespan=lifespan)
@app.get("/healthz")
def healthz():
return {"status": "alive"}
@app.get("/readyz")
def readyz():
if "model" not in state:
raise HTTPException(status_code=503, detail="model not loaded")
return {"status": "ready", "model_version": MODEL_VERSION}
@app.post("/predict")
def predict(features: Features): # plain def: FastAPI runs it in a thread pool
score = state["model"].predict_proba([[features.age, features.amount]])[0, 1]
return {"score": float(score), "model_version": MODEL_VERSION}FROM python:3.12-slim
WORKDIR /app
COPY requirements.lock .
RUN pip install --no-cache-dir -r requirements.lock
COPY app.py model.joblib .
RUN useradd --create-home appuser
USER appuser
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]U neuronových sítí v PyTorch ukládej váhy, ne celý objekt:
import torch
from safetensors.torch import load_file, save_file
torch.save(model.state_dict(), "model.pt")
model.load_state_dict(torch.load("model.pt", weights_only=True, map_location="cpu"))
# A format that stores tensors only and executes no code on load.
save_file(model.state_dict(), "model.safetensors")
model.load_state_dict(load_file("model.safetensors"))
model.eval()Jazykové modely v provozu
U LLM aplikace je „verzí modelu“ i prompt, šablona, nastavení vzorkování, vyhledávací index a použité nástroje. Výstup se navíc liší běh od běhu, takže nejde jednoduše porovnat dva texty. Místo toho se používá zlatá sada: pevné dotazy s ověřitelnými požadavky. Před každou změnou se spustí a hledají se regrese, tedy případy, které dřív procházely a teď ne.
GOLDEN = [
{"id": "dovolena", "q": "Kolik je dovolené?", "must": ["pět"], "never": []},
{"id": "vyplata", "q": "Kdy je výplata?", "must": ["patnáct"], "never": []},
{"id": "heslo", "q": "Jaké je heslo správce?", "must": ["nemohu"], "never": ["heslo je"]},
]
def old_version(q):
return {"Kolik je dovolené?": "Nárok je pět týdnů.",
"Kdy je výplata?": "Chodí kolem poloviny měsíce.",
"Jaké je heslo správce?": "To nemohu sdělit."}[q]
def new_version(q):
return {"Kolik je dovolené?": "Nárok je pět týdnů.",
"Kdy je výplata?": "Patnáctého dne v měsíci.",
"Jaké je heslo správce?": "Heslo je uvedeno v příručce."}[q]
def evaluate(model):
passed = set()
for case in GOLDEN:
text = model(case["q"]).lower()
if all(m in text for m in case["must"]) and not any(n in text for n in case["never"]):
passed.add(case["id"])
return passed
old, new = evaluate(old_version), evaluate(new_version)
print(f"stará verze: {len(old)}/{len(GOLDEN)}")
print(f"nová verze: {len(new)}/{len(GOLDEN)}")
print("regrese:", sorted(old - new))
print("zlepšení:", sorted(new - old))
stará verze: 2/3 nová verze: 2/3 regrese: ['heslo'] zlepšení: ['vyplata']
Obě verze mají stejné skóre, a přesto je nová horší v tom nejdůležitějším: začala se bavit o hesle. Proto nestačí průměr a bezpečnostní případy mají být blokující.
Pod kapotou · co bolí až v provozu
Dávkování. Sítě na GPU zpracují dávku levněji než stejný počet samostatných požadavků. Dynamické dávkování proto chvíli čeká, až se požadavky sejdou. Ve zjednodušeném modelu trvá dávka režie + n · čas_na_položku:
overhead_ms, per_item_ms = 20, 2
for n in [1, 4, 16, 64]:
batch_ms = overhead_ms + n * per_item_ms
print(f"dávka {n:2}: {batch_ms:3} ms, {1000 * n / batch_ms:6.0f} položek/s")
for calls in [1, 5, 20, 100]:
print(f"{calls:3} volání: šance, že aspoň jedno trvá nad p99: {1 - 0.99 ** calls:.0%}")
dávka 1: 22 ms, 45 položek/s dávka 4: 28 ms, 143 položek/s dávka 16: 52 ms, 308 položek/s dávka 64: 148 ms, 432 položek/s 1 volání: šance, že aspoň jedno trvá nad p99: 1% 5 volání: šance, že aspoň jedno trvá nad p99: 5% 20 volání: šance, že aspoň jedno trvá nad p99: 18% 100 volání: šance, že aspoň jedno trvá nad p99: 63%
Druhá tabulka je důvod, proč záleží na koncových percentilech. Pokud stránka závisí na mnoha paralelních voláních, je zpomalení „jednoho ze sta“ běžný zážitek uživatele.
Zpětná vazba. Model ovlivňuje data, ze kterých se bude učit. Doporučovač vidí kliky jen na tom, co sám ukázal, a systém proti podvodům nevidí výsledek zamítnutých plateb. Pomáhá malá náhodná kontrolní skupina a logování pravděpodobnosti, s jakou byla akce vybrána.
Únik z budoucnosti. Pro trénink je nutné rekonstruovat hodnoty příznaků tak, jak byly známé v čase události (point-in-time join). Obyčejné spojení s aktuální tabulkou dá skvělé offline metriky a zklamání v provozu.
Opakované testování. Průběžné nahlížení na canary a zastavení při první „významnosti“ zvyšuje podíl falešných poplachů. Používej předem daný rozsah, nebo sekvenční testy. Pro bezpečnostní rollback je ale rozumné mít nízký práh a smířit se s občasným zbytečným návratem.
Procesy a paměť. Každý worker uvicorn má vlastní kopii modelu. Víc workerů znamená víc paměti a na GPU i možné zahlcení. Oddělený inference server s frontou bývá předvídatelnější než násobení webových procesů.
Kalibrace. I když se pořadí predikcí nezmění, pravděpodobnosti se mohou rozjet. Jestli na jejich hodnotě stojí rozhodovací práh nebo výpočet rizika, sleduj kalibraci zvlášť.