Inference Engine

Un moteur d’inférence est un logiciel qui exécute un réseau de neurones entraîné pour produire des prédictions sur de nouvelles données. Il prend un modèle exporté depuis un framework d’entraînement, généralement sous forme de graphe de calcul tel qu’un fichier ONNX, optimise ce graphe pour un processeur donné, puis l’exécute avec un minimum de latence d’inférence et de mémoire. Il existe des moteurs pour toutes les catégories de matériel, des GPU de centre de données aux téléphones et microcontrôleurs. En déploiement de modèles, le moteur est le composant qui calcule chaque prédiction.

Comment les moteurs d’inférence accélèrent les modèles#

Un modèle déployé ne met jamais à jour ses poids. Un moteur peut donc supprimer tout ce dont l’entraînement a besoin, comme les activations stockées pour la rétropropagation, et réécrire librement le graphe. Il précalcule toutes les parties qui dépendent uniquement de constantes, fusionne des séquences de couches — par exemple convolution, normalisation et activation — en noyaux uniques afin que les résultats intermédiaires restent dans la mémoire rapide de la puce, et planifie la mémoire pour réutiliser les tampons. Il peut réduire la précision numérique à FP16 ou INT8 par quantification du modèle, en mesurant les plages d’activation sur des données échantillons pour INT8. Des moteurs comme TensorRT chronomètrent ensuite plusieurs noyaux candidats pour chaque couche sur l’appareil réel et conservent le plus rapide ; le résultat est donc lié à ce matériel :

La fusion de la normalisation par lots dans la convolution précédente est l’une des réécritures les plus courantes. À l’inférence, la normalisation ne fait que mettre à l’échelle et décaler chaque canal selon des valeurs fixes, qui peuvent donc être intégrées aux poids et au biais de la convolution. PyTorch expose la même transformation sous le nom fuse_conv_bn_eval :

import torch
from torch.nn.utils.fusion import fuse_conv_bn_eval

torch.manual_seed(0)

# A trained convolution followed by batch normalization (random statistics here)
conv = torch.nn.Conv2d(16, 32, kernel_size=3, padding=1).eval()
bn = torch.nn.BatchNorm2d(32).eval()
bn.running_mean.uniform_(-1, 1)
bn.running_var.uniform_(0.5, 2.0)

# Fold the normalization's scale and shift into the convolution's weights and bias
fused = fuse_conv_bn_eval(conv, bn)

# One layer now replaces two and produces the same output
x = torch.randn(1, 16, 64, 64)
with torch.inference_mode():
    diff = (bn(conv(x)) - fused(x)).abs().max().item()
print(f"Max difference after fusing: {diff:.1e}")

Le résultat affiche une différence maximale de 2.1e-06, due à l’arrondi en virgule flottante : la couche fusionnée calcule la même fonction que les deux couches d’origine en un seul passage en mémoire au lieu de deux.

Moteurs d’inférence courants#

• TensorRT : le moteur de NVIDIA pour ses GPU de centre de données et ses modules Jetson. Il crée un plan pour un modèle de GPU et une version de TensorRT donnés ; il faut donc reconstruire les moteurs si l’un ou l’autre change.
• OpenVINO : la boîte à outils d’Intel pour ses CPU, ses GPU intégrés et discrets, ainsi que ses NPU.
• ONNX Runtime : le moteur multiplateforme de Microsoft pour les modèles ONNX. Il délègue le travail à des backends matériels appelés fournisseurs d’exécution, notamment CUDA, TensorRT, OpenVINO et Core ML.
• LiteRT : l’environnement d’exécution de Google, anciennement TensorFlow Lite, pour Android, Linux embarqué et les microcontrôleurs, avec des délégués pour les GPU mobiles et les NPU.
• Core ML : le framework embarqué d’Apple, qui répartit le travail entre le CPU, le GPU et le Neural Engine.
• vLLM : un moteur open source pour les grands modèles de langage, qui ajoute l’ordonnancement des requêtes et une mémoire paginée pour le cache d’attention afin de servir plusieurs utilisateurs simultanément.

L’API Ultralytics YOLO choisit le moteur en fonction du fichier qu’elle charge. Le même appel predict exécute donc un checkpoint .pt dans PyTorch, un fichier .onnx dans ONNX Runtime, un fichier .engine dans TensorRT, ou un dossier OpenVINO dans OpenVINO. Exporter Ultralytics YOLO26 vers OpenVINO et charger le résultat permet de changer de moteur sans modifier le reste du code :

from ultralytics import YOLO

# Exporter le modèle PyTorch au format OpenVINO
model = YOLO("yolo26n.pt")
path = model.export(format="openvino")  # creates 'yolo26n_openvino_model/'

# Charger le dossier exporté exécute les prédictions avec le moteur OpenVINO
ov_model = YOLO(path)
results = ov_model("https://ultralytics.com/images/bus.jpg")
results[0].save(filename="bus_openvino.jpg")

Moteurs d’inférence et termes apparentés#

• PyTorch et autres frameworks d’entraînement : gardent le graphe flexible et enregistrent les opérations pour calculer les gradients, afin de concevoir et d’entraîner les modèles. Ils exécutent aussi l’inférence, avec plus de surcoût qu’un moteur conçu pour un appareil donné.
• ONNX : un format de fichier qui décrit le graphe et les poids d’un modèle. ONNX Runtime et TensorRT sont des moteurs qui le lisent.
• Service de modèles : encapsule un ou plusieurs moteurs dans un service réseau doté d’une API, du traitement par lots des requêtes et de la gestion des versions, comme le fait NVIDIA Dynamo-Triton, anciennement Triton Inference Server, pour les modèles TensorRT, ONNX Runtime et PyTorch.
• Moteur d’inférence de système expert : sens plus ancien du terme, issu de l’IA à base de règles, où le moteur d’inférence applique des règles si-alors à une base de connaissances par chaînage avant ou arrière.