Implementazione modelli ML

1) Ruolo e obiettivi

Installazione = fornitura affidabile di inferance al prodotto e operazioni in conformità con RG/AML/Legale e budget.
Obiettivi: bassa latitanza, elevata disponibilità, riproduzione, sicurezza e reversibilità rapida (rollback).

2) Architetture di cerving

2. 1 Pattern

Online (real-time): REST/gRPC, p95 50-150 mc per la personalizzazione; ≤2 -5 c per gli alert RG/AML.
Near-real-time: microbatchi 1-5 min (vetrine OLAP).
Batch/offline: vetrine notturne Gold, esportatori WORM per regolatore.
In-process scoring - Incorporare il modello light nel servizio (ritardo ridotto).
Serverless: funzioni con partenza fredda per operazioni rare.

2. 2 Topologie

Single Model Service è facile e veloce.
Ensemble/Graph (router → predrocess → model → postprocess) → pipline complesse.
Sidecar Feature Fetcher → estrae i fili online dalla cache (Redis/Scylla).

3) Registro e versioni modello

Registry: «model _ id», «variante», «stage = {Staging, Produzione, Archivio}», manufatti (peso, preprocessore, calibrazione), requisiti (CPU/GPU/memoria), scheda modello (dati, metriche, rischi, fairness).
Artefatti immutabili: content-hash; Copie WORM delle release.
Criteri di output: solo mediante registro e manifesti dichiarativi.

4) Contenitore e imballaggio

dockerfile
FROM python:3. 11-slim
ENV PYTHONUNBUFFERED=1
WORKDIR /app
COPY requirements. txt.
RUN pip install -r requirements. txt --no-cache-dir
COPY artifacts/./artifacts/
COPY src/./src/
CMD ["python", "src/serve. py"]

python serve. py from fastapi import FastAPI import joblib, time app = FastAPI()
model = joblib. load("artifacts/model. joblib")
scaler = joblib. load("artifacts/scaler. joblib")

@app. post("/score")
def score(payload: dict):
t0 = time. time()
x = preprocess(payload, scaler)
y = float(model. predict_proba([x])[0,1])
return {"score": y, "latency_ms": int((time. time()-t0)1000), "model_version": "1. 8. 3"}

5) Kubernets/Helm e skailing automatico

yaml apiVersion: apps/v1 kind: Deployment metadata: {name: ml-score, labels: {app: ml-score}}
spec:
replicas: 3 selector: {matchLabels: {app: ml-score}}
template:
metadata: {labels: {app: ml-score}}
spec:
containers:
- name: api image: registry/ml-score:1. 8. 3@sha256:...
ports: [{containerPort: 8080}]
resources:
requests: {cpu: "500m", memory: "512Mi"}
limits:  {cpu: "2",  memory: "2Gi"}
envFrom: [{secretRef: {name: ml-secrets}}]
readinessProbe: {httpGet: {path: /healthz, port: 8080}, periodSeconds: 5}
livenessProbe: {httpGet: {path: /livez,  port: 8080}, periodSeconds: 10}

yaml apiVersion: autoscaling/v2 kind: HorizontalPodAutoscaler metadata: {name: ml-score-hpa}
spec:
scaleTargetRef: {apiVersion: apps/v1, kind: Deployment, name: ml-score}
minReplicas: 3 maxReplicas: 50 metrics:
- type: Pods pods:
metric: {name: requests_per_second}
target: {type: AverageValue, averageValue: "15"}
- type: Resource resource: {name: cpu, target: {type: Utilization, averageUtilization: 70}}

6) Strategie di scarico

Shadow (avvio scuro) - Il nuovo modello elabora le copie delle query e ignora le risposte. confronto metriche/latenza/costo.
Canary: 1-10% del traffico → 25% → 50% → 100% con SLO verde; Reimpostazione automatica in caso di degrado.
Blue-Green: pile parallele Un maglione istantaneo di routing.
Routing in base a mercati/tenanti/dispositivi.
A/B/n - esperimenti in linea con sequential testing.

yaml routes:
- match: {tenant: "EEA"} # feature-flags/rules to: {model: "1. 8. 3", weight: 20}
- match: {tenant: "EEA"}
to: {model: "1. 7. 9", weight: 80}

7) Ficci online/offline: equivalenza

Una singola libreria di trasformazioni e Feature Store (online + offline).
Test di equivalenza: MAE/MAPE tra i file online e il riferimento offline sul campione di riferimento.
Cash fish: Redis/Scylla, TTL per i segni delle finestre; timeout e fallbacks.

8) Osservabilità, SLO e alerting

8. 1 punti di riferimento SLI/SLO

Latenza: p95-150 ms (personalizzazione), p99-300 ms; RG/AML alert 5 con end-to-end.
Disponibile: ≥ 99. 9%.
Errore di infertilità: 0. 5% 5xx; coverage ≥ 99%.
Deriva: PSI fich/score <soglia, ECE (calibrazione) stabile.
Бизнес: uplift Net Revenue, fraud saved, time-to-intervene.

8. 2 Metriche (Prometheus)

yaml
- http_request_duration_seconds{quantile="0. 95"}
- http_requests_total{code=~"5.."}
- model_inference_latency_ms_bucket
- feature_fetch_latency_ms_bucket
- model_score_distribution_bucket
- psi_feature_{name}
- expected_cost_live

yaml
- alert: HighP95Latency expr: histogram_quantile(0. 95, sum(rate(model_inference_latency_ms_bucket[5m])) by (le)) > 0. 15 for: 10m
- alert: DriftDetected expr: psi_feature_amount_base > 0. 25 for: 15m

Трейсинг: OpenTelemetry — span’ы `feature_fetch`, `score`, `postprocess`, `guardrail`.

9) RG/AML guardrail e criteri di sicurezza

Pre-/Post-filter - maschere di attività proibite (frequenza di visualizzazione, cooldown, proibizione di offshore aggressivi).
Policy Shielding: scansione al di sopra della soglia RG, intervallo/pausa morbido.
Controllo: logica «policy _ id», «propensity», «mask», «decision», «reason».
PII e residenza: token anziché ID, chiavi di crittografia separate e cluster su EEA/UK/BR; divieto di join'ove crocifissi senza fondamento.
Segreti: KMS/CMK, Secret Manager; Niente PII nei cassetti/roulotte.

10) Calibrazione, soglie e politiche decisionali

Calibrazione (Platt/Isotonic) come artefatto.
Soglia di expected cost; configurabile nel registro/flag fich.
Safety caps - Limite di azione superiore/inferiore, override manuale per la compilazione.

11) Rimborsi, degrado e DR

One-click rollback - Passa alla precedente «model _ variante».
Runbook: script « », «errori», «deriva/calibrazione rotta», «fornitore di fiffe esterno non disponibile».
Isolamento degli errori: circuito breaker, retry/backoff, cache dell'ultima soluzione valida.
DR: Becap manufatti/registro, replica in una regione calda, esercitazioni.

python try:
features = fetch_features(timeout=30)
except TimeoutError:
features = last_known_good(user_id) # fallback

12) Cost-ingegneria e prestazioni

Profilazione percorso: fili (30-60%), modello (20-40%), rete/IO (10-30%).
Riduzione dei costi: cache hot five, quote replay, modelli lightweight, INT8/FP16 (se necessario), lazy-postprocess.
HPA su RPS/CPU/latency, vincolo state-size su strim-fich.
Chargeback: cost/request, cost/feature; budget per i mercati/squadre.

13) Rilasci sicuri e conformità

Criteri di preparazione: SLO verde su shadow, nessuna deriva/fuoriuscita, scheda modello compilata, diapositive fairness normali.
Regolatore: archivio di rilascio WORM (peso, calibrazione, soglie, metriche, fogli di prova), report di esportazione invariati.
DSAR/RTBF - Procedure per rimuovere le tracce di un utente specifico dai caselli/logi/fich.

14) QA prima dell'escursione

Test di integrazione: appalti API, schemi Fich, valigette vuote/estreme.
Carico: p99, code di distribuzione, traffico burst.
Test di equivalenza online/offline.
Test Chaos: disattivazione della cache/base Fiech, timeout dei servizi esterni.

15) Esempi di configurazione

yaml
- match: [headers: {x-exp: "canary"}]
route:
- destination: {host: ml-score-v1-8-3, weight: 20}
- destination: {host: ml-score-v1-7-9, weight: 80}

python
@app. get("/healthz")
def health():
return {"ok": True, "model_version": "1. 8. 3", "registry_sig_ok": verify_signature()}

16) Processi e RACI

R (Secondable): MLOs (cerving/orchestrazione/osservazione), Data Eng (fici/cache/contratti), Data Science (schede modello/calibrazione/soglie).
A (Accountable): Head of Data / CDO.
C (Consulted): Compliance/DPO (PII/RG/AML/DSAR), Security (KMS/segreti/controllo), SRE (SLO/incidenti), Finance (RE/budget).
I (Informed) - Prodotto/Marketing/Operazioni/Supporto.

17) Road map di implementazione

1. Registro modello e manufatti immutabili; Servizio FastAPI/gRPC + K8s/Helm.

2. Avvio Shadow con monitoraggio p95/5xx/deriva, test di equivalenza fich.

3. Canary 10% 50% 100% con automatico e alert.

4. Scheda modello, calibrazione, soglia expected-cost e Guardrails v1.

• Fich-cache, circuito breakers, runbooks/DR.-esercitazioni.
• Scailing automatico su RPS/latency, cost-dashboard e changeback.
• Monitoraggio delle diapositive fairness, archivio delle release WORM.

• Conte del cerving (candidati → re-rank), slate-loging propensity.
• Regione multi, residenza (EEA/UK/BR) con chiavi separate.
• Auto-noleggio/spostamento alla deriva, rapporti di qualità auto/calibrazione.

18) Foglio di assegno prod pronto

• La scheda del modello è piena. dati/fitch/calibrazione/soglie versionate.
• Contratti Fich e test di equivalenza online/offline - verde.
• SLO: p95, 5xx, coverage - verde su shadow e 10% canary su 24 ore
• Gli alert e i dashboard (latitanza/errori/deriva/expected-cost) sono inclusi.
• Guardrails RG/AML e le verifiche delle soluzioni sono attive; PII/residenza rispettati.
• One-click rollback e runbook incidenti testati.
• Il costo rientra nel budget; HPA e cache configurati.

19) Anti-pattern e rischi

Scarichi manuali senza registro e manufatti immutabili.
In linea/offline non concordanti, i files non corrispondono alla soluzione di vendita.
Assenza di shadow/canary, regressione nascosta.
La soglia non è da expected cost, non è da calibrare.
Lookups esterni sincronizzati senza timeout/cache.
Nessun DR/rollback, nessun archivio di rilascio WORM.

20) Totale

La produzione ML non è una «sfida del modello», ma una piattaforma di ingegneria: registro e versioni, scorie sicure (shadow/canary/blue-green), disciplina del fich e della calibrazione, osservabilità e SLO, guardrail per RG/AML e un piano di rientro chiaro. Seguendo questa playbook, si ottiene un'inferienza rapida, affidabile e complessa che porta stabilmente valore aziendale a costi controllati.