Frameworks & Accélération

TensorRT • OpenVINO • ONNX Runtime • ExecuTorch/PyTorch Mobile • Apache TVM • Core ML / NNAPI / Vulkan. Du convert → build → runtime → profilage, avec recettes & matrices de compat.

INT8, sparsity, QAT Zéro-copy pipelines P95 < 80ms Bundles signés

Gain perf vs FP32×3–×8

INT8 + kernels dédiés (Tensor Cores / iGPU / VPU).

Latence P95 pipeline< 80 ms

Batch=1 • NMS GPU • streams async • zéro-copy.

Portabilité ONNXHaute

Opset ≥ 17 • EP fallback CPU sûr.

Empreinte modèle30–80 MB

Pruning + distillation + zip/CRC signé.

Accélérations : INT8/QAT, sparsity structurelle, kernels Tensor Cores, NMS GPU.

Plugins : BatchedNMS, YoloLayer, custom CUDA (post-process).

# Export → ONNX → TensorRT (INT8) torch.onnx.export(model, x, "detector.onnx", opset_version=17) trtexec --onnx=detector.onnx --int8 --calib=calib.cache \ --fp16 --sparsity=enable --workspace=4096 \ --saveEngine=detector.plan --skipInference

Calibrations par-canal si dispo. QAT recommandé pour stabilité.
Prétraite & post-traite côté GPU (zéro-copy). Batch=1 en vol.

Étape	Commande / API	Sortie	Notes
Export ONNX	torch.onnx.export	.onnx	Opset ≥ 17, dynamic axes ok
Build Engine	trtexec ou API C++/Py	.plan	INT8 + FP16 + sparsity
Vérif graph	polygraphy surgeon	report	Détecte les ops non supportées
Plugins	en C++/CUDA	.so	Ex: decode / NMS custom

# Exemple API Python (build & serialize) builder = trt.Builder(logger) config = builder.create_builder_config() config.set_flag(trt.BuilderFlag.INT8); config.int8_calibrator = calibrator engine = builder.build_engine(network, config) open("detector.plan","wb").write(engine.serialize())

Devkit Jetson (placer une photo réelle de ton banc). Pense à ajouter ventilation et alimentation stable lors des builds INT8.

Métrique	Obj.	Comment	Outils
Latence P95	< 80 ms	inference + post	trtexec --dumpProfile, Nsight
FPS perception	≥ 20	cadence stable	trace ROS2 / profiler
Conso IA	< 8 W	clocks dynamiques	tegrastats/jetson_stats
Temp GPU	< 75°C	throttling sinon	tegrastats

# Profilage granulaire (Python) for i in range(iters): context.execute_v2(bindings) t = cuda.Event(); t.record(); t.synchronize() # Export JSON: p50/p95 par couche

Activer plusieurs optimization profiles si dimensions variables.
Fixer l’affinité CPU/GPU et isoler l’IRQ caméra.

Zéro-copy : V4L2/CSI → CUDA DMA → preprocess GPU → .plan → post-proc GPU → topic ROS2.
NMS : privilégier batchedNMS (plugin) pour éviter copies host.
Ops non supportées : exporter via torch.fx + remplacement custom (plugin).
Stabilité INT8 : QAT > PTQ quand jeu de calib faible ou distribution variable.

Docs : docs.nvidia.com/deeplearning/tensorrt
Repo : github.com/NVIDIA/TensorRT
Polygraphy : tools/Polygraphy

Stratégie HETERO : dispatch couches selon coût (latence/énergie), fallback CPU automatique.

# ONNX → IR (FP16) + compression mo --input_model model.onnx --compress_to_fp16 \ --data_type=FP16 --output_dir build_ir

# Quantification post-training (INT8) pot -c pot_config.json -m build_ir/model.xml -w build_ir/model.bin

ASTUCE : garde à la source un export FP32 + un IR FP16 + un INT8 versionnés.

Mode	Exemple	Usage	Notes
HETERO:GPU,CPU	core.compile_model(net,"HETERO:GPU,CPU")	GPU prioritaire	Fallback auto
MULTI:GPU,CPU	"MULTI:GPU,CPU"	Scheduling multi-devices	Balance charge
AUTO	"AUTO:GPU,CPU"	Choix auto	Simplifie le déploiement

# Async infer + mesures req = compiled.create_infer_request() for i in range(n): req.start_async({input: x}); req.wait() # export p50/p95 par couche via perf counters

Active performance counters pour obtenir timings per-layer.
Combine CPU+iGPU pour tenir le P95 sous 80 ms sur U-series.

Docs : docs.openvino.ai
Model Zoo : open_model_zoo
Pot (post-training quant) : POT

EP	Cible	Forces	Fallback	Notes
TensorRT	Jetson/RTX	INT8 ultra-rapide	CUDA→CPU	Profil unique par taille
OpenVINO	Intel	Hétérogène	CPU	IR conseillé
CUDA	NVIDIA	Large support	CPU	Plugins possibles
NNAPI/Core ML	Android/iOS	Accélérateurs natifs	CPU	Selon device

import onnxruntime as rt providers = [("TensorrtExecutionProvider", {"trt_max_workspace_size": 2<<30}), "CUDAExecutionProvider", "CPUExecutionProvider"] sess = rt.InferenceSession("model.onnx", providers=providers) y = sess.run(None, {"input": x_np})

ASTUCE : ordonne les EP du plus rapide au plus générique pour un fallback propre.

Famille d’opérations	Remarques déploiement
Conv/MatMul/GEMM	OK tous EP — privilégier kernels spécialisés INT8.
Non-Max Suppression	Utiliser implémentations EP (TRT plugin / OpenVINO op) pour éviter la copie CPU.
Ops dynamiques (Resize/Pad)	Éviter shapes exotiques ; figer tailles quand possible.
Custom	ORT permet custom ops côté C++ pour post-process.

Docs : onnxruntime.ai/docs
ONNX : onnx.ai
ORT Mobile : Mobile EP

Capturer le graphe (torch.export) → compiler AOT ExecuTorch → exécuter via XNNPACK ou passerelle NNAPI/Core ML.
Bundle AAB/IPA : inclure modèles chiffrés + vérification d’intégrité.

# Export puis compile ExecuTorch exported = torch.export.export(model, (example_input,)) et_prog = executorch.compile(exported, backend="xnnpack") # ou "nnapi" et_prog.save("model.et")

// Android (Kotlin) – chargement val runtime = ExecuTorchRuntime(context) val module = runtime.loadModuleFromAsset("model.et")

API	Accélérateurs	Avantages	Attention
NNAPI (Android)	NPU/DSP/GPU	Performance, faible conso	Couverture d’op limitée selon appareil
Core ML (iOS)	ANE/GPU	Ultra rapide sur Apple Silicon	Conversion via coremltools
XNNPACK	CPU	Fallback portable	Moins performant qu’accélérateur

ExecuTorch : pytorch.org/executorch
PyTorch Mobile : pytorch.org/mobile
coremltools : coremltools

API	OS	Accélérateurs	Forces	Attention
Core ML	iOS	ANE/GPU	Perf & efficacité	Conversion nécessaire
NNAPI	Android	NPU/DSP/GPU	Très économe	Couverture ops varie
Vulkan	Android/Linux	GPU générique	Contrôle fin	Dev plus bas-niveau

// Pseudo-shader SPIR-V (concept) layout(local_size_x = 256) in; void main(){ /* conv / matmul */ }

Utile pour post-process custom si aucun EP natif ne convient.

# Manifest modèle signé (extrait JSON) { "name":"detector-int8","format":"onnx","hash":"sha256:…", "size": 43_512_064, "device_allow":["jetson-xavier","jetson-orin"], "min_driver":"535.89", "rollback":"A/B" }

Vérifier hash/clé avant chargement ; stocker en partition scellée (TEE/TPM si dispo).
Politique rollback si métriques en-dessous des SLA (P95/FPS/Conso).

Core ML Tools : coremltools
NNAPI : developer.android.com
Vulkan : khronos.org/vulkan

Frameworks & Accélération

NVIDIA TensorRT

Intel OpenVINO

ONNX Runtime

PyTorch Mobile / ExecuTorch

Apache TVM

Core ML / NNAPI / Vulkan