Inference Engine

Un motor de inferencia es el software que ejecuta una red neuronal entrenada para generar predicciones sobre datos nuevos. Recibe un modelo exportado desde un framework de entrenamiento, normalmente como un grafo de cálculo, por ejemplo, un archivo ONNX; optimiza ese grafo para un procesador concreto y lo ejecuta con la menor latencia de inferencia y el menor consumo de memoria posibles. Hay motores para todo tipo de hardware, desde GPU de centros de datos hasta teléfonos y microcontroladores. En el despliegue de modelos, el motor es el componente que calcula cada predicción.

Cómo aceleran los modelos los motores de inferencia#

Un modelo desplegado nunca actualiza sus pesos, así que un motor puede eliminar todo lo que necesita el entrenamiento, como las activaciones almacenadas para la propagación hacia atrás, y reescribir el grafo libremente. Calcula de antemano cualquier parte que dependa solo de constantes, fusiona cadenas de capas —como convolución, normalización y activación— en núcleos únicos para que los resultados intermedios permanezcan en la rápida memoria del chip y planifica la memoria para reutilizar los búferes. Puede reducir la precisión numérica a FP16 o INT8 mediante la cuantización de modelos; para INT8, mide los rangos de activación con datos de muestra. A continuación, motores como TensorRT cronometran varios núcleos candidatos para cada capa en el dispositivo real y conservan el más rápido, por lo que el resultado depende de ese hardware:

La fusión de la normalización por lotes con la convolución anterior es una de las reescrituras más habituales. Durante la inferencia, la normalización solo escala y desplaza cada canal en cantidades fijas, así que esos valores se pueden integrar en los pesos y el sesgo de la convolución. PyTorch expone la misma transformación como 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}")

Imprime una diferencia máxima de 2.1e-06, debida al redondeo de coma flotante: la capa fusionada única calcula lo mismo que las dos capas originales, pero con un solo recorrido por la memoria en lugar de dos.

Motores de inferencia habituales#

• TensorRT: El motor de NVIDIA para sus GPU de centros de datos y módulos Jetson. Crea un plan para un modelo de GPU y una versión de TensorRT concretos, así que hay que reconstruir los motores cuando cambia cualquiera de los dos.
• OpenVINO: El kit de herramientas de Intel para sus CPU, GPU integradas y discretas, y NPU.
• ONNX Runtime: El motor multiplataforma de Microsoft para modelos ONNX. Delega el trabajo en backends de hardware llamados proveedores de ejecución, entre ellos CUDA, TensorRT, OpenVINO y Core ML.
• LiteRT: El entorno de ejecución de Google, antes llamado TensorFlow Lite, para Android, Linux integrado y microcontroladores, con delegados para GPU y NPU móviles.
• Core ML: El framework de Apple para dispositivos, que distribuye el trabajo entre la CPU, la GPU y Neural Engine.
• vLLM: Un motor de código abierto para modelos de lenguaje grandes que incorpora planificación de solicitudes y memoria paginada para la caché de atención, lo que permite atender a muchos usuarios a la vez.

La API de Ultralytics YOLO elige el motor según el archivo que carga. Por eso, la misma llamada a predict ejecuta un checkpoint .pt en PyTorch, un archivo .onnx en ONNX Runtime, un archivo .engine en TensorRT o una carpeta de OpenVINO en OpenVINO. Exportar Ultralytics YOLO26 a OpenVINO y cargar el resultado cambia de motor sin necesidad de modificar el resto del código:

from ultralytics import YOLO

# Exporta el modelo de PyTorch al formato de OpenVINO
model = YOLO("yolo26n.pt")
path = model.export(format="openvino")  # creates 'yolo26n_openvino_model/'

# Al cargar la carpeta exportada, las predicciones se ejecutan con el motor de OpenVINO
ov_model = YOLO(path)
results = ov_model("https://ultralytics.com/images/bus.jpg")
results[0].save(filename="bus_openvino.jpg")

Motores de inferencia frente a términos relacionados#

• PyTorch y otros frameworks de entrenamiento: Mantienen flexible el grafo y registran operaciones para calcular gradientes, de modo que se puedan diseñar y entrenar modelos. También ejecutan inferencias, aunque con más sobrecarga que un motor creado para un único dispositivo.
• ONNX: Un formato de archivo que describe el grafo y los pesos de un modelo. ONNX Runtime y TensorRT son motores que lo leen.
• Servicio de modelos: envuelve uno o varios motores en un servicio de red con API, procesamiento por lotes de solicitudes y gestión de versiones, como hace NVIDIA Dynamo-Triton, antes llamado Triton Inference Server, con los modelos TensorRT, ONNX Runtime y PyTorch.
• Motor de inferencia de sistemas expertos: El significado anterior del término, procedente de la IA basada en reglas, donde el motor de inferencia aplica reglas de tipo si-entonces a una base de conocimiento mediante encadenamiento hacia delante o hacia atrás.