Implementazione modelli ML

(Sezione Tecnologia e infrastruttura)

Breve riepilogo

La produzione robusta di ML è un insieme di manufatti ripetibili (modello/tokenizer/config), cerving standardizzato (Triton/KServe/vLLM), processo di lancio sicuro (canari/blu-green/shadow), osservabilità (latitanza, qualità, deriva) e runbook-ov per gli incidenti. Per i pazienti sono critici i ritardi bassi (antifrode/personalizzazione), i severi SLO, PII/Complex e il controllo dei costi.

1) Modalità di installazione

Batch (offline) - Operazioni notturne/orarie (riprodurre retrospettive, aggiornare segmenti). Economico, prevedibile.
Online (API sincrona): antifrode, personalizzazione, raccomandazioni, suggerimenti LLM. Richiede p95 SLA (ad esempio, 100-300 ms).
Stream (near-real-time) - Finestre da 1 a 60 secondi (Flink/Spark/Kafka Streams) per i segnali e i trigger CRM.
Ibrido: scorer rapido e ruvido online + ricalcolazione offline/calibrazione.

2) Manufatti e confezioni

Manufatti modellati: peso, tokenizzatore, confighi di preprocessing/postprocessing, versione dataset/codice.
Formati: PyTorch/TF SavedModel, ONNX per la compatibilità, TensorRT-engine per l'accelerazione, GGUF/awq/gptq per la quantificazione LLM.
Contenitori Docker OCI con dipendenze pinned Tag multipli (CPU/GPU).
Release immutabili: tag model: fraud-v3. 2. 1`, `image: fraud:3. 2. 1`.

3) Piattaforma di cerving

Triton Inference Server: batching multi-model, dinamico, ensemble-pipelines.
KServe (K8s-nativo): auto-scale (HPA/KPA), canari/shadow, runtime personalizzate.
vLLM/TGI (LLM): continuous batching, cache KV, decoding speculativo.
Ficistore: online (mc-SLA) + offline per la coerenza di Fic (feature parity).

yaml apiVersion: serving. kserve. io/v1beta1 kind: InferenceService metadata: { name: fraud }
spec:
predictor:
canaryTrafficPercent: 15 model:
modelFormat: { name: triton }
storageUri: s3://models/fraud/v3. 2. 1/
resources: { limits: { nvidia. com/gpu: "1" } }

4) Strategie di rilascio

Blue-Green: due pile identiche, cambio di traffico istantaneo, semplice ripartenza.
Canary: aumento graduale del traffico (1% 5% 25% 100%) per gate SLO/qualità.
Shadow: il nuovo modello riceve una copia del traffico, le risposte non influiscono su nulla - valutazione sicura.
I test A/B misurano le metriche aziendali (conversione, ritenzione), l'importanza statistica.

map $request_id $route {
default old;
"~ canary" new; # 5-15% by flag/cook/feature-toggle
}

5) SLO e budget di lavoro

Antifrode/personalizzazione online: p95-100-150 mc, p99-250-400 mc.
LLM suggerimenti (128-512 token): p95 da 300 a 800 ms di generazione dei primi token, tokens/s del target.
Disponibile: ≥ 99. 9% per le vie critiche.
Qualità: AUC/PR-AUC/Top-K @ N per il% delle risposte tossiche/non corrette X.
Costo: $/1k richieste o $/1k token entro il budget.

6) CI/CD per modelli

1. Treno/finetune è un modello nel registro (metadati: dati/codice/metriche/licenze).

2. Pack & Validate: test unit/post-test, compatibilità API, test di carico (latency/tokens/s).

3. Canary Deploy: 1-5% traffico; osservabilità (SLO/qualità/costo).

4. Promote/Rollback per criteri gate.

yaml jobs:
build-serve:
steps:
- run: make export_onnx && make docker_build
- run: pytest tests/serve --maxfail=1
- run: python perf_check. py --p95 120 --fail-on-regress
- run: kubectl apply -f kserve-canary. yaml

7) Ottimizzazione dei ritardi e dei passaggi

Batching/microbatching (Triton/vLLM), parallelismo delle richieste, pre/post-processing per CPU.
Quantificazione (INT8/FP8/INT4) Compilazione runtime.
Cache: fich (online-fickstore/Redis), risultati e cache KV per LLM.
Warmup: riscaldamento della bilancia/cache durante la deposizione; «caldo» per lo skale automatico.
Tempo budget: arresto precoce, limitazione dei token/beam, adattamento della temperatura.

8) Osservabilità: telemetria, deriva, qualità

Metriche SRE: RPS, p50/p95/p99, errori (5xx/4xx), GPU/CPU util, memoria, coda, batch-fill.
Metriche ML: AUC/PR-AUC, calibration error, coverage, tokens/s, lunghezza di risposta, cache-hit.
Deriva: PSI/JS divergenza per entrata/uscita, monitoraggio dello spostamento delle distribuzioni; Gli alert.
Qualità online: esempi d'oro di controllo, risposta sempreverde, punteggio automatico di AG/tossicità per LLM.
Cronologia: prompt/risposta (anonimizzata), trace _ id, versione del modello.

inference_latency_ms_bucket{model="fraud-v3. 2. 1",le="100"} 12345 inference_qps{model="fraud-v3. 2. 1"} 450 tokens_per_second{model="llm-help-v1"} 210

9) Gestione dei file e coerenza

Feature-parity: stesse trasformazioni offline/online; versionare le feci come codice.
Fichestor online: ms-SLA, TTL, upsert, idempotency; la cache è più vicina al cervingo.
Backfill/refresh: un piano per evitare che lo screening online si discosti dalle metriche offline.

10) Sicurezza, PII e licenze

PII: tornizzazione/occultamento, segmentazione regionale (EU/TR/LATAM), crittografia in pace/transito.
Segreti/chiavi: KMS/Secret Manager, nessun segreto nelle immagini.
Criteri LLM: filtri di contenuti, stoper sicuri, red-teaming.
Licenze: controlla le condizioni di dataset/peso, i divieti di reading/trading.
Isolamento: namespace-RBAC, quote, taints/tolerations per i pool GPU.

11) Scale automatico e QoS

Autoscaling: RPS/code/latency/GPU-util; min-ready-pods per le linee calde.
QoS - Critical online (anti-fraud)> chat LLM> esperimenti. Preemption a favore dei critici.
Multiregion: latency-based routing, cache di peso riscaldata, replica fich.

12) Runbooks e incidenti

Altezza p99: controlla batch-fill, coda, GPU-util, cache-miss; attivare il batch aggressivo/abbassare il beam/token.
La qualità è scesa: ritorno alla versione precedente, attivare shadow, fissare le fonti della deriva.
I costi aumentano, includendo la quantificazione/TenorRT, aumentando la batteria, ottimizzando i file/cache, riducendo la frequenza di generazione LLM attraverso la cache e i risultati.
Incidente PII: immediata stop-the-line, ritiro degli artefatti, controllo dell'accesso, rapporto al regolatore della procedura.

13) Esempi di modelli

text dynamic_batching { preferred_batch_size: [4, 8, 16, 32]
max_queue_delay_microseconds: 2000 }
instance_group { kind: KIND_GPU count: 2 }

--tensor-parallel-size 2
--max-num-seqs 512
--gpu-memory-utilization 0. 9

python resp = client. score({"features": f}) # v3. 2. 1 assert set(resp. keys()) >= {"score","version","latency_ms"}

14) Assegno foglio di implementazione

1. Definire SLO/SLA (latency/availability/quality/cost).
2. Standardizzare gli artefatti e il registro dei modelli (versioni, metadati).
3. Selezionate una pila di cerving (Triton/KServe/vLLM) e un filettatore.
4. Regolare i canari/blu-green/shadow e i gate automatici.
5. Creare un ICI/CD: test di compatibilità, perf-regressione, promozione sicura.
6. Attivare l'osservabilità (SRE + ML metriche), il monitoraggio alla deriva e gli alert.
7. Assicurarsi che PII/sicurezza/licenze e verifiche.
8. Configurare lo scale automatico/QoS e le regole multiregionali.
9. Preparare il runbook-e e passare il game-day.
10. Immettere la gestione dei costi: batching, quantificazione, cache, RAG.

15) Antipattern

La Deplom «com'è», senza canarie/osservabilità, ha causato incidenti inaspettati.
I file non conformi offline/online → una differenza di metriche.
Nessun test di perforazione o limite di → p99 «nuota».
La logica dei prompt/risposte senza anonimato è un rischio PII.
Un pool di GPU generico per tutto senza , critico online soffre.
Non ci sono ritiri o snapshot di manufatti per lunghi periodi di inattività.

Riepilogo

L'implementazione con successo di modelli ML è costituita da manufatti contenibili, cerving standardizzato, processo di rilascio sicuro (canary/blue-green/shadow), SLO rigido e osservazione qualità/deriva/costo. Aggiungi fichestor, CI/CD con perf-gate, igiene PII, auto-scale e - e i tuoi servizi di antifrode/personalizzazione/LLM mantengono stabilmente i picchi di carico, mantenendo prevedibile il budget e il budget.