Correct Usage 2025

Guides de déploiement (prod-ready), méthodologie de benchmarking, et calcul précis des coûts d’inférence. Inclut sizing & capacity planning, paramètres de génération, SLO/SLA, checklists sécurité & conformité.

Déploiement fiable Benchmarks reproductibles Coûts maîtrisés Conformité & guardrails

API REST (SSE)

@app.post("/v1/chat/completions")
async def chat(req: ChatReq):
    async with sse_response() as stream:
        async for tok in llm.stream(req):
            await stream.send({"delta": tok})
    return {"finish_reason":"stop"}

gRPC (extrait proto)

service LLM { rpc ChatStream(ChatReq) returns (stream ChatChunk); }
message ChatReq { repeated Message messages=1; string model=2; }

Docker/K8s (extraits)

FROM nvidia/cuda:12.2.0-runtime
RUN pip install vllm fastapi uvicorn
CMD ["python","-m","vllm.entrypoints.openai.api_server","--model","mistral"]

HPA/KEDA (autoscaling tokens/s)

metrics:
- type: Pods
  pods:
    metric: {name: tokens_per_second}
    target: {type: AverageValue, averageValue: "200"}

Sécurité & quotas

Auth Bearer, CORS restrictif, limites taille requête.
Quota par clé/projet (req/jour, tok/min).
Masquage PII dans logs + TTL/purge.

Tip : exposer /v1/embeddings pour RAG et déduplication, + cache des réponses (hash prompt+ctx).

Protocole : Warmup → Sweep (batch, max_new_tokens) → Charge QPS (N min) → Collecte (p50/p95/p99, tok/s, erreurs) → Analyse
Qualité : golden set (exact-match, groundedness, JSON valid) + red-team (safety).

Génération de charge (ex.)

# wrk (SSE simplifié) ou locust
users = 200; spawn_rate = 20
payload = {"model":"mistral","messages":[{"role":"user","content":"Résumé 3 puces"}]}

Métriques à tracer

latency p50/p95/p99, TTFB & TTFT (streaming).
tokens/s (sortants) & taux d’erreurs 5xx.
coût/1k tok, VRAM, util GPU (%).

Prometheus (extraits)

llm_latency_seconds_bucket{le="1",model="mistral"} 42
llm_tokens_total{type="out"} 123456
llm_errors_total{code="5xx"} 3

Tableau de résultats (gabarit)

Config	p95	tok/s	coût/1k	qualité
FP16, batch 16	1.8s	220	0.0041	OK
INT8, batch 32	1.5s	310	0.0032	OK*

* Vérifier exact-match et groundedness post-quantization.

Formules utiles

throughput ≈ (batch_eff × tok_out) / latence_step
coût ≈ (tok_in + tok_out) × prix_tok + stockage + egress

Tip : fixer des seeds & versions (poids, prompts, hyperparams, index RAG) pour la reproductibilité, et publier un manifest de bench.

Calculateur (gabarit)

inputs_tok = 1200; outputs_tok = 300
unit_price = 0.004 / 1000
cost = (inputs_tok + outputs_tok) * unit_price

Budgets & quotas

Quota par clé/projet : req/jour, tok/min, max_new_tokens.
Alertes coût : seuils jour/semaine/mois + chargeback par tags.
Dashboards : coût/1k tok, coût requête, coût feature.

Optimisations concrètes

INT8/4-bit (canary qualité, rollback facile).
RAG : k↓, re-rank, cache embeddings & réponses.
Streaming + early-stop ; limiter contexte inutile.

Tableau d’arbitrage

Levier	Impact coût	Impact qualité	Note
Quantization INT8	↓↓	≈	Valider tâches critiques
k RAG ↓	↓	±	Compense avec re-rank
Max new tokens ↓	↓	±	Contrats de sortie stricts

Prometheus (coût)

llm_cost_per_1k_tok{env="prod"} 0.0037
llm_cost_total{team="search"} 123.45

Tip : cartographier “coût → paramètres” (temp, top_p, max_new_tokens, k RAG) et intégrer des tests de coût en CI/CD.

Capacité ≈ (tok/s par pod) × (# pods)  |  Tok/s dépend de batch, longueur de contexte, quantization, KV cache.

Choix parallélisme

Contrainte	Préférence	Notes
VRAM limitée	PP + ZeRO	équilibrer stages
NVLink/IB rapide	TP	all-reduce efficace
Grand cluster	TP+PP hybride	load-balancing fin

Batching & KV

Batch dynamique + paged KV cache (vLLM).
Limiter max_model_len & max_new_tokens.
Fenêtre glissante pour prompts très longs.

HPA/KEDA (ex.)

scaleTargetRef: {name: vllm}
metric: tokens_per_second → target 200/pod
policy: stabilizeWindowSeconds: 60

Tip : calibrer sur deux profils : “short-burst” (FAQ) et “long-context” (RAG) — reporter des SLO distincts.

Cheatsheet sampling

Paramètre	Effet	Plage conseillée
temperature	créativité	0.1–0.7
top_p	nucleus	0.7–0.95
top_k	filtrage k	20–100
presence/frequency	dédup/variété	0.0–1.0

Contrats de sortie

<policy>Réponds en JSON strict valide ce schéma.</policy>
<schema>{"type":"object","properties":{"answer":{"type":"string"}},"required":["answer"]}</schema>

Stop & garde-fous

Stop sequences spécifiques au format.
Validation JSON côté serveur (Pydantic/Schema).
Refus guidé si non-conforme + feedback.

Prompt(system+user) → LLM → Validation(JSON) → Post-process (schema/guardrails) → Réponse

Bonnes pratiques

Standardiser prompts système & formats entre runtimes.
RAG : citations obligatoires + IDs passages loggés.
Observabilité : traces corrélées aux coûts & refus.

Anti-patterns

Pas de streaming → latence perçue ↑ & coûts ↑.
Aucun max_new_tokens → factures imprévisibles.
Swap de modèle sans canary ni contrat d’API figé.

Playbook migration

figer_contrats(); canary(10%); comparer p95/tok/s/qualité/coût;
promouvoir_si_OK(); sinon rollback_auto → postmortem

Tip : conserver une “référence” (modèle + prompt + params) prête pour rollback instantané en cas d’écart SLO.

Correct Usage 2025

Guides de déploiement

Benchmarks & Méthodo

Coûts d’inférence

Sizing & Capacity

Paramètres de génération

Best Practices & Pitfalls