10 · Estaciones · ModeloLección 3 de 3
Export, engine y paridad
Export, engine and parity
El quinto paso del sistema de Alba de principio a fin: convertir el modelo aprobado en un archivo que cualquiera lee, compilarlo para la GPU que lo va a servir, comprobar que sigue siendo el mismo modelo y que no se volvió más lento, y dejar sus huellas en el registry.
Secciones14
- 01Lo que entra, lo que sale y lo que se decide
- 02ONNX: el modelo como un archivo que se entrega
- 03TensorRT: del ONNX al engine
- 04Un engine para una GPU y una versión
- 05La paridad del engine
- 06El gate de latencia
- 07Huellas y registro: el final de la estación
- 08Si algún día fuera INT8 extra
- 09Errores comunes
- 10En la vida real extra
- 11Ejercicios
- 12Lo que sigue
- 13Palabras que vas a oír
- 14Chequeo
El gate ya dijo que el modelo nuevo es bueno. Pero lo que se va a servir no es ese modelo: es otro archivo, en otro formato, con otros números por dentro. ¿Cómo se fabrica ese archivo y cómo sabes que responde lo mismo que el que aprobaste?
Alba es la empresa que seguimos en todo el curso: un marketplace en línea que recibe ≈ 2.5 millones de publicaciones nuevas al día, con ≈ 3 fotos cada una, y le sugiere a quien vende la categoría de cada foto entre 500 posibles. La sugerencia la da una ResNet-50 de ≈ 24.5 millones de parámetros, servida con Triton (el servidor de modelos de NVIDIA) en 2 GPUs T4, y se reentrena cada mes. Ana, por ejemplo, sube la foto de unos tenis y recibe «Calzado › Tenis».
Esta lección es una estación: un paso del sistema que arma cada modelo nuevo, contado como trabajo de ingeniería completo. Recibe algo, lo trabaja y se lo pasa a la siguiente. La anterior, «Gate de evaluación y registry», comparó el modelo nuevo contra el actual en las 50,000 fotos del golden set y lo aprobó: no es peor en más de 0.3 puntos, ni en las categorías grandes, ni en los pedazos difíciles. Ese modelo aprobado es un checkpoint: el archivo de PyTorch que guardó el entrenamiento, con sus pesos en FP32.
El problema es que Alba no sirve ese archivo. Sirve un engine: el mismo modelo, compilado para la T4 (traducido a las instrucciones exactas de ese chip) y con casi todas sus cuentas en FP16. Es más rápido, pero sus números por dentro son otros. La lección «Cómo guarda números una computadora» explica por qué cambiar de formato mueve cada número un poco; aquí vas a ver cómo se fabrica ese engine, paso a paso, y cómo se demuestra que sigue siendo el modelo que se aprobó.
Lo que entra, lo que sale y lo que se decide
EsencialIn, out and what gets decided
Lo que entra
- El checkpoint aprobado. El archivo de PyTorch que el gate aprobó, el de
resnet50-2026-10-01, entrenado el 1 de octubre de 2026. El archivo pesa ≈ 294 MB porque también trae el estado del entrenamiento (los momentos de Adam, el paso, las semillas); de él solo importan los pesos: ≈ 98 MB en FP32. - Unas ≈ 10,000 fotos del golden set, un subconjunto de las 50,000, ya pasadas por el preprocesamiento 1.4.0 (los pasos que llevan la foto a 224 × 224 píxeles y normalizan sus colores), el mismo paquete que usa el gateway (el programa que recibe la foto de Ana y la prepara para el modelo).
- Los números del champion. El champion es el modelo que hoy atiende a la gente. De él se necesita cuánto tarda, medido igual que se va a medir al nuevo.
Lo que sale
model.onnx: el modelo como un archivo ONNX, ≈ 98 MB. Es la entrega: lo que cualquier herramienta puede leer.model.plan: el engine de TensorRT en FP16, ≈ 49 MB de pesos (el archivo completo, de ≈ 50 a 150 MB). Es lo que de verdad corre en la T4.- Una imagen de Triton con el engine adentro: un paquete con el servidor y todo lo que necesita para correr, listo para arrancar en cualquier máquina. Su tag (su nombre) es la versión del modelo. Cómo se arma lo cuenta «Empaquetado con Docker».
- Dos reportes (paridad y latencia) y las huellas del build: la huella SHA-256 de cada archivo (un número que sale del contenido exacto del archivo; lo ves en «Huellas y registro»), la GPU y las versiones del software con que se construyó.
- Una versión nueva en el registry de modelos, el catálogo donde cada modelo guarda sus versiones numeradas. Es la versión 14,
resnet50-2026-10-01, y recibe el aliaschallenger: un nombre que señala a una versión y se puede mover (es el ejemplo de octubre; en noviembre, la misma estación registra la versión 15, como la viste en la lección anterior). «Gate de evaluación y registry» lo explica a fondo; aquí se completa ese registro.
Lo que se decide
La estación responde dos preguntas, y nada más:
- ¿El archivo que se va a servir es el mismo modelo que se evaluó? Eso es la paridad del engine.
- ¿Cabe en el tiempo? Que no sea más de 10 % más lento que el champion. Eso es el gate de latencia.
Si cualquiera de las dos falla, el paso termina con error, no se registra nada y el champion sigue atendiendo. Lo que la estación no decide: si el modelo es bueno (ya lo decidió el gate), ni cómo se sirve ni cómo se despliega (las estaciones 6 a 10).
Los siete pasos
La estación es un pedazo del pipeline mensual de Alba, el que corre su orquestador el día 1 de cada mes. Corre en un runner de CI propio (CI es la integración continua: el sistema que corre pruebas y builds automáticos con cada cambio). Es una máquina g4dn.xlarge de AWS con una T4, que se prende para el trabajo y se apaga al terminar, por menos de US$10 al mes. La estación tarda ≈ 20–30 min:
- 1
Exportar a ONNX, en CPU
El modelo de PyTorch se convierte en un archivo ONNX y se revisa ahí mismo, con tres chequeos.
- 2
Paridad en CPU
ONNX Runtime, un programa que corre archivos ONNX, lo corre en CPU y lo compara con PyTorch. Es FP32 contra FP32: deben coincidir casi en todo.
- 3
Construir el engine, en la T4
TensorRT, el compilador de modelos de NVIDIA, lee el ONNX y lo compila para esa GPU, en FP16.
- 4
Poner el engine dentro de la imagen de Triton
El archivo
classifier/1/model.planqueda dentro de la imagen que se va a servir. - 5
Paridad del engine
Con esa imagen corriendo en la T4, el engine responde las ≈ 10,000 fotos y se compara con PyTorch en FP32.
- 6
Gate de latencia
perf_analyzer, la herramienta de NVIDIA que mide el servidor como lo haría un cliente, le manda peticiones a 250 y a 500 por segundo y compara su p99 con el del champion. - 7
Huellas y registro
Las huellas van al registry y la versión queda como
challenger.
challenger. Toca cada caja. El primer recorrido sigue el modelo de octubre; el segundo, un engine que no pasa la paridad.- Checkpoint aprobado · ≈ 294 MB · se usan los pesos
Lo que aprobó el gate: el checkpoint deresnet50-2026-10-01, en PyTorch: ≈ 294 MB, porque también trae el estado del entrenamiento. De él solo se usan los pesos (ckpt["model"]), ≈ 98 MB en FP32. - Exportar a ONNX · opset 17 · 3 chequeos
export_onnx.pycarga los pesos conweights_only=True, pone el modelo eneval()y exporta condynamo=False, opset 17 y el eje de batch dinámico. Revisa el archivo cononnx.checkery lee su opset real. - Paridad en CPU · ONNX Runtime · 512 fotos
ONNX Runtime en CPU contra PyTorch, en batch 1 y 32: mismo top-1 en las 512 fotos y diferencia de logits del orden de 0.0001. Es FP32 contra FP32: atrapa un export roto. - Construir el engine · trtexec FP16 · 1/16/32
build_engine.shrevisa quenvidia-smidiga T4 y corre trtexec con la imagentensorrt:24.08-py3(TensorRT 10.3), en FP16 y con perfil 1/16/32. Tarda ≈ 2–5 min. - Triton con el engine · release 24.08 · horneado
Elmodel.planqueda dentro de la imagen de Triton (tritonserver:24.08-py3, la misma release), enclassifier/1/model.plan. El tag de la imagen es la versión del modelo. Aquí se prende en la T4 del runner para los dos exámenes que siguen. - Paridad del engine · FP16 contra FP32
La paridad del engine: Triton y PyTorch FP32 responden las mismas fotos. Pasa con top-1 igual en ≥ 99.5 %, top-5 que coincide en ≥ 99 % y diferencia máxima de logits ≤ 0.5. - p99 del champion · medido igual
El p99 del modelo actual a 250 y a 500 peticiones por segundo, medido con perf_analyzer en el mismo tipo de máquina. Es contra lo que se compara el challenger en el gate de latencia. - Gate de latencia · perf_analyzer · 250 y 500/s
perf_analyzer manda peticiones a tasa fija contra la imagen nueva. Pasa si el p99 no sube más de 10 % sobre el del champion, a las dos tasas. - Golden set · ≈ 10,000 de 50,000
Un subconjunto de ≈ 10,000 fotos del golden set, ya preparadas con el preprocesamiento 1.4.0, el mismo del gateway. - Versión 14 · challenger · huellas
Con los dos exámenes en verde se registra la versión 14 del modeloclassifier: ONNX, engine, huellas, reportes y punteros. Recibe el aliaschallenger.
¿Por qué tanto trabajo, si PyTorch ya sabe correr el modelo? Por tres razones. Un engine FP16 de TensorRT suele ser varias veces más rápido que PyTorch en FP32 en la misma GPU: con él, una T4 llega a ≈ 1,200 fotos por segundo. El archivo de PyTorch es un pickle, y abrir un pickle puede correr código (lo ves en «Archivos y formatos»). Y el servidor no necesita Python ni el código de entrenamiento: necesita un archivo que diga qué cuentas hacer.
ONNX: el modelo como un archivo que se entrega
EsencialONNX: the model as a handoff file
Entrenar y servir son dos mundos. Entrenar pasa en PyTorch, con Python, en una A10G (la GPU con que Alba entrena). Servir pasa en Triton, un programa escrito en C++ (otro lenguaje, más rápido y sin Python), en una T4. Entre los dos hace falta un formato de entrega que no dependa de ninguno.
Qué hay dentro de un ONNX
ONNX (Open Neural Network Exchange) es un formato de archivo para modelos que leen muchas herramientas, no solo PyTorch. Un archivo ONNX guarda tres cosas:
- El grafo del modelo. La lista de operaciones de la red, en orden, y cómo se conectan: la salida de esta convolución entra a esta ReLU, que entra a esta suma. A cada operación se le llama operador (operator):
Conv,Relu,Add,GlobalAveragePool(el promedio de cada canal) yGemm(una multiplicación de matrices). No hay código de Python: solo operadores con nombre. - Los pesos. Los ≈ 24.5 millones de números que aprendió el modelo, guardados en FP32: ≈ 24.5 millones × 4 bytes ≈ 98 MB. No son exactamente los 24,532,532 parámetros: el exportador de Alba mete cada BatchNorm dentro de la convolución que la precede (sus cuentas se pueden juntar), y el archivo queda con 24,505,972 números. Casi lo mismo.
- La firma. Cómo se llaman la entrada y la salida, de qué tipo son y qué forma tienen. En Alba: la entrada se llama
input, es FP32 con forma[batch, 3, 224, 224](cuántas fotos van juntas, 3 colores y 224 × 224 píxeles), y la salida se llamalogits, FP32 con forma[batch, 500].
Por dentro, el archivo es un mensaje de protobuf, el formato binario de Google para datos con esquema. Lo que importa es que es solo datos: abrirlo no corre código, a diferencia de un pickle.
model.onnx de Alba: la firma, el grafo de operadores con sus pesos, y el opset que dice qué versión de cada operador se usó.El opset: la versión de los operadores
Los operadores cambian con el tiempo. Una versión nueva de Resize acepta otra opción; una de Softmax cambia sobre qué eje opera por omisión. Por eso cada archivo ONNX declara su opset: el número de versión del conjunto de operadores que usó. El de Alba es opset 17.
El opset es parte del contrato. Quien lee el archivo (ONNX Runtime, TensorRT) tiene que conocer ese opset. Si exportas con un opset que tu versión de TensorRT todavía no entiende, el build falla; si el opset cambia sin que nadie lo pida, el mismo operador puede significar otra cosa. Por eso Alba fija el opset y, como vas a ver, lo lee del archivo después de exportar.
La forma variable: el eje de batch dinámico
El modelo de Alba recibe a veces 1 foto y a veces varias juntas: Triton junta las que llegan casi al mismo tiempo en un batch (lo ves en «Qué tan rápido y cuánto: latencia y throughput»). La firma tiene que decir que la primera dimensión cambia. A eso se le llama eje de batch dinámico: la dimensión 0 de input y de logits se declara con un nombre, batch, en vez de un número.
No lo confundas con el batching dinámico de Triton. Uno es una propiedad del archivo (acepta batches de cualquier tamaño); el otro es lo que hace el servidor (juntar peticiones). Sin el primero, el segundo no sirve: un archivo que solo acepta batch 1 no puede recibir 4 fotos juntas.
El script de export
Alba exporta con un script, export_onnx.py, que vive en el repositorio del modelo. Lo esencial cabe en unas líneas. Es una ilustración: necesita PyTorch y torchvision (la biblioteca de PyTorch con las redes de visión ya armadas), que aquí no están instalados.
import torch, torchvision
modelo = torchvision.models.resnet50(weights=None, num_classes=500) # la red vacía, con 500 salidas
ckpt = torch.load("final.pt", map_location="cpu", weights_only=True) # pesos y estado, sin correr código
modelo.load_state_dict(ckpt["model"], strict=True) # solo los pesos, cada uno en su lugar
modelo.eval() # BatchNorm con sus estadísticas guardadas
ejemplo = torch.randn(2, 3, 224, 224) # batch 2, para que el 1 no quede fijo
torch.onnx.export(modelo, (ejemplo,), "model.onnx", dynamo=False, opset_version=17,
input_names=["input"], output_names=["logits"],
dynamic_axes={"input": {0: "batch"}, "logits": {0: "batch"}},
do_constant_folding=True)Cada argumento es una decisión:
weights_only=Trueystrict=True. El primero carga solo tensores y datos simples (diccionarios, listas, números), sin dejar que el archivo corra código. Del checkpoint, que también trae el estado del entrenamiento, se toman solo los pesos:ckpt["model"]. El segundo exige que cada peso del checkpoint tenga su lugar en la red y que no falte ninguno: si alguien cambió la cabeza a 501 clases sin avisar, falla aquí y no en producción.modelo.eval(). Pone la BatchNorm a usar las estadísticas que guardó al entrenar, en vez de las del batch que le llega. El exportador que usa Alba lo haría solo, pero el nuevo no (lo ves en el recuadro de abajo), así que Alba lo escribe siempre.- Un ejemplo de batch 2. El exportador corre el modelo una vez con ese ejemplo y graba lo que pasó. Con batch 1, algunas herramientas tratan el 1 como constante; con 2 no hay duda de que es la dimensión que cambia.
dynamo=False, opset 17. Usa el exportador clásico: corre el modelo una vez y graba las operaciones que pasaron, con TorchScript (a eso se le llama trazar). Desde PyTorch 2.9 el exportador por omisión es otro; Alba lo deja para un cambio aparte, con su propia paridad.dynamic_axes. Declara el eje 0 comobatch, en la entrada y en la salida.do_constant_folding=True. Si una parte del grafo da siempre el mismo resultado (porque solo depende de pesos), el exportador la calcula una vez y guarda el resultado, en vez de dejar esa cuenta para cada foto.
Al terminar, el script imprime una línea que se queda en el log del pipeline: [export] opset=17 input=input[batch,3,224,224] output=logits.
Los tres chequeos del export
Un export puede salir mal sin dar error. Por eso el mismo script revisa el archivo antes de soltarlo, y si algo no cuadra imprime FALLÓ la verificación y sale con error:
- 1
El archivo está bien formado
onnx.checkerconfull_check=Truerevisa que el grafo sea válido: que cada operador exista en el opset, que cada entrada de cada nodo (cada operación del grafo) venga de algún lado y que las formas cuadren de punta a punta. - 2
El opset es el que se pidió
Lee el opset escrito en el archivo y lo compara con 17. Parece redundante, pero no lo es: con el exportador nuevo, pedir opset 17 puede dejarte un archivo en 18 sin ningún error, a lo más con un aviso en el log.
- 3
ONNX Runtime contra PyTorch
Corre las mismas 512 fotos en los dos, en batch 1 y en batch 32: mismo top-1 en todas, y una diferencia máxima de logits del orden de 0.0001.
ONNX Runtime (ORT) es un programa que carga un ONNX y lo corre, en CPU o en GPU. Por dentro reparte los nodos del grafo entre sus proveedores de ejecución (execution providers), los motores que hacen las cuentas: el de CPU, el de CUDA (para GPUs de NVIDIA), el de TensorRT y otros. Aquí Alba usa solo el de CPU, a propósito: este chequeo no necesita GPU, así que corre en cualquier máquina y en un minuto.
¿Por qué batch 1 y 32? Porque son las orillas del rango que promete la firma. Si el eje de batch quedó fijo por error, el batch 1 pasa y el 32 truena. Y es FP32 contra FP32: las dos versiones hacen las mismas cuentas, en otro orden, así que solo deben diferir en el último decimal. Si aquí sale una diferencia de 0.01, el export está mal, aunque el top-1 coincida.
Para ir más hondoEl exportador nuevo y sus trampas+
Desde PyTorch 2.9, torch.onnx.export usa por omisión otro exportador, el que parte de torch.export (dynamo=True). Alba tiene anotado pasarse a él como un cambio aparte, porque trae trampas como estas dos (la tercera, el opset, la atrapa el chequeo 2).
Sin eval(), otro modelo. El exportador clásico pone el modelo en eval mientras exporta (su opción training vale EVAL por omisión). El nuevo no: captura el modelo tal como está, y en modo train la BatchNorm se queda con el comportamiento de entrenamiento. Con la ResNet-50 de Alba capturada así, el top-1 coincidió con el original en 0 % de las fotos (lo cuenta «PyTorch en lo que toca a producción»).
El ONNX que pesa 0.3 MB. El exportador nuevo guarda los pesos aparte: un model.onnx de ≈ 0.3 MB con el grafo y un model.onnx.data de ≈ 98 MB con los pesos, salvo que le pidas lo contrario. Si un paso del pipeline copia solo el .onnx, el siguiente no encuentra los pesos y falla, a veces mucho después. Alba, con dynamo=False, saca un solo archivo; si migra, el chequeo 3 lo atraparía, porque corre el archivo que de verdad se va a entregar.
Y una más, que no es del exportador. El provider que se apaga solo. Alba corre ONNX Runtime solo en CPU, pero hay servicios que lo usan en GPU. Si corre con el provider de CUDA y un operador no está soportado ahí, ese nodo pasa sin error al siguiente provider de la lista y, al final, a la CPU: el modelo responde bien, solo que más lento, y lo único que lo delata es la latencia. Por eso un servicio con ORT en GPU revisa qué provider tomó cada nodo, y por eso la latencia se mide con el artefacto final.
TensorRT: del ONNX al engine
EsencialTensorRT: from ONNX to engine
El ONNX dice qué cuentas hacer. No dice cómo hacerlas rápido en una T4. Eso es lo que hace TensorRT, el compilador de modelos de NVIDIA. Un compilador es un programa que traduce una descripción (aquí, el grafo) a instrucciones que un chip ejecuta directo. TensorRT recibe el ONNX y produce un engine, un archivo .plan con el modelo listo para correr en una GPU concreta. A la parte de TensorRT que hace ese trabajo se le llama builder.
Lo que hace el builder
- 1
Lee el grafo
Carga el ONNX y revisa que cada operador sea uno que sabe compilar.
- 2
Lo simplifica
Quita lo que no hace nada (una operación que copia su entrada tal cual) y precalcula lo que es constante.
- 3
Junta operaciones: la fusión
Una convolución, su BatchNorm, su ReLU y la suma de la conexión residual se vuelven un solo kernel (un programa que corre en la GPU).
- 4
Elige la precisión de cada capa
Con
--fp16, usa FP16 donde puede; si una capa no tiene versión en FP16 o es más rápida en FP32, la deja en FP32. - 5
Cronometra tácticas
Una táctica es una forma concreta de hacer la cuenta de una capa. Para cada capa prueba varias en esta GPU y se queda con la más rápida.
- 6
Guarda el engine
Escribe todo, con los pesos ya en FP16, en el archivo
.plan.
La fusión de capas es la que más se nota. La lección «CPU y GPU» la cuenta: en PyTorch, sin fusionar, la ResNet-50 son 174 operaciones por batch, cada una un kernel que la CPU tiene que lanzar; fusionadas, quedan ≈ 56. (Una parte la adelanta el export, que ya mete cada BatchNorm en su convolución; TensorRT junta el resto.) Menos kernels son menos lanzamientos, y además el resultado intermedio no tiene que ir y volver de la memoria de la GPU entre una operación y la siguiente.
Las tácticas explican por qué el engine depende de la GPU. Para una convolución de cierto tamaño hay decenas de formas de repartir el trabajo entre los núcleos. Cuál es la más rápida depende del chip, de su memoria y hasta del tamaño del batch. TensorRT no lo adivina: las prueba, las mide y escribe la ganadora en el engine.
.plan. Toca cada caja; el recorrido sigue el engine de Alba en la T4.- model.onnx · grafo · pesos FP32
El ONNX que salió del export: el grafo de operadores, los pesos en FP32 y la firma. - Leer el grafo · operadores
Carga el ONNX y revisa que cada operador sea uno que sabe compilar, en el opset del archivo. Si no, el build falla aquí. - Simplificar · quita y precalcula
Quita operaciones que no hacen nada y precalcula las partes que solo dependen de pesos. - Fusionar · 174 → ≈ 56 kernels
Fusión de capas: cada convolución con su BatchNorm, su ReLU y la suma residual se vuelve un solo kernel. Menos lanzamientos y menos viajes a memoria. - Elegir precisión · FP16 donde se puede
Con--fp16, cada capa va en FP16 si tiene versión en FP16 y conviene; si no, se queda en FP32. Una capa que se desborda en FP16 (sus números pasan de ≈ 65,504, el máximo de FP16) es la que hay que dejar en FP32 a mano. - Cronometrar tácticas · en esta GPU
Una táctica es una forma concreta de hacer la cuenta de una capa. Para cada capa prueba varias, las mide en la GPU que tiene enfrente y se queda con la más rápida, para las formas del perfil. Por eso el engine depende de la GPU, y dos builds pueden salir un poco distintos. - Guardar el engine · pesos en FP16
Escribe en un solo archivo (a esto se le llama serializar) el grafo fusionado, la precisión de cada capa, las tácticas elegidas y los pesos, en el formato de esta versión de TensorRT. - model.plan · ≈ 50–150 MB
El engine: ≈ 49 MB de pesos FP16 más lo que agrega TensorRT. Atado a sm_75 y a TensorRT 10.3. - La T4 y el perfil · sm_75 · batch 1/16/32
La GPU real donde se cronometra (la guardia revisa que sea T4, compute capability 7.5) y el perfil que le pasatrtexec: mínimo 1, óptimo 16, máximo 32.
El perfil de optimización: qué batches acepta
El ONNX dice que el batch es variable. El engine necesita saber entre qué valores, porque las tácticas se eligen para tamaños concretos. Eso es el perfil de optimización (optimization profile): tres formas de entrada.
- Mínima: el batch más chico que acepta. En Alba, 1.
- Óptima: la forma para la que se cronometran las tácticas. En Alba, 16.
- Máxima: la más grande que acepta. En Alba, 32, igual que el
max_batch_sizede Triton. Un batch de 33 no entra.
Aquí hay una tensión. En la hora pico, los batches que de verdad llegan a la T4 son de ≈ 1 a 3 fotos. Triton espera a lo más 2 ms para juntar fotos, y en ese tiempo no llegan más. El engine funciona con esos batches, porque están dentro del rango, pero sus tácticas se eligieron pensando en 16. Por eso el 16 es un punto de partida, no un dato: lo correcto es construir también un engine con óptima 4, medir los dos con el tráfico real (de 250 a 500 peticiones por segundo) y quedarse con el que dé mejor p99.
trtexec: construir y medir
trtexec es la herramienta de línea de comandos de TensorRT. Construye el engine y lo mide. El paso 3 de la estación es, en esencia, esta línea. Es una ilustración: necesita una GPU de NVIDIA y la imagen de TensorRT.
trtexec --onnx=model.onnx --saveEngine=model.plan --fp16 \
--minShapes=input:1x3x224x224 --optShapes=input:16x3x224x224 \
--maxShapes=input:32x3x224x224 --shapes=input:16x3x224x224Las tres primeras opciones de forma son el perfil. La última, --shapes, es el tamaño con que trtexec hace una medición rápida de velocidad al final (un benchmark), para tener un número de control: si sale diez veces más lento que el mes pasado, algo raro pasó. En la T4 de Alba el build tarda ≈ 2–5 min.
Un engine para una GPU y una versión
EsencialOne engine for one GPU and one version
Un engine no es portable. Por omisión viene atado a dos cosas, y si cambia cualquiera hay que construirlo otra vez.
Atado a la GPU: la compute capability
Cada generación de GPUs entiende sus propias instrucciones, y NVIDIA le pone un número, la compute capability: 7.5 para la T4 (se escribe sm_75), 8.6 para la A10G, 8.9 para la L4, 8.0 para la A100 y 9.0 para la H100. «CPU y GPU» lo explica en «La arquitectura de la GPU». Los kernels que eligió el builder están compilados para sm_75 y las tácticas se cronometraron en una T4. En una L4 ese engine no carga.
Atado a la versión: la release de NGC
El formato del .plan cambia entre versiones de TensorRT. Un engine construido con TensorRT 10.3 lo debe cargar TensorRT 10.3. (TensorRT tiene modos de compatibilidad entre versiones y entre GPUs, que se piden al construir y pueden costar velocidad; el de GPUs no cubre la T4. Alba no los usa.) ¿Cómo se garantiza eso?
NVIDIA publica sus programas en contenedores listos (paquetes con el programa y todo lo que necesita para correr), en su catálogo NGC, con una release cada mes que se nombra por año y mes: 24.08 es la de agosto de 2024. Los contenedores de una misma release comparten la base: la misma CUDA y, los que la traen, la misma TensorRT. Alba construye el engine con la imagen nvcr.io/nvidia/tensorrt:24.08-py3 (TensorRT 10.3) y lo sirve con tritonserver:24.08-py3, de la misma release (Ubuntu 22.04, CUDA 12.6). Misma release en el build y en el servidor: esa es la regla.
La guardia del build
El script que construye el engine, build_engine.sh, tiene dos variables fijas: NGC_RELEASE=24.08 y EXPECTED_GPU=T4. Antes de construir, le pregunta a nvidia-smi (el programa que reporta qué GPU tiene la máquina) qué GPU hay. Si no dice T4, aborta. Al terminar imprime la GPU, la release y la huella SHA-256 del ONNX y del plan, que se vuelven parte de las huellas del build.
¿Por qué una guardia, si el runner siempre tiene una T4? Porque «siempre» dura hasta que alguien cambia el tipo de máquina del runner, o corre el script en su laptop. Sin la guardia, el engine se construye, pasa todo en esa máquina… y no carga en producción.
En CI, nunca al arrancar el servidor
Hay herramientas que construyen el engine al vuelo, cuando el servidor arranca: ONNX Runtime con su provider de TensorRT, por ejemplo. Alba no lo hace, por tres razones:
- Tarda. El build son minutos, y un pod nuevo de Triton (una copia más del servidor, que Kubernetes arranca en otra máquina cuando sube el tráfico) ya tarda ≈ 5–13 min en estar listo. Cada réplica nueva, en plena subida de tráfico, sumaría otros minutos sin servir.
- No es el que se probó. Las tácticas se eligen cronometrando, y el cronómetro tiene ruido. Dos builds del mismo ONNX en dos T4 pueden elegir tácticas distintas. El engine que pasó la paridad es ese archivo, con esa huella; uno construido al arrancar es otro, sin examen.
- Falla tarde. Si el build falla en CI, falla un paso del pipeline y nadie se entera afuera. Si falla al arrancar, falla en producción.
Por eso el engine se construye una vez, en el runner de CI con la T4, y se hornea en la imagen de Triton: el archivo classifier/1/model.plan queda dentro de la imagen, cuyo tag es la versión del modelo. El .plan no se guarda en git. Volver al modelo anterior es volver a la imagen anterior, que ya trae su engine. Un engine no se «reconstruye rápido» en un incidente.
Si aun así un engine de otra GPU o de otra versión llega a producción, Triton no lo puede cargar, y el despliegue se detiene sin afectar a nadie. El recuadro cuenta cómo.
Para ir más hondoQué se rompe cuando se rompe+
Si un engine de otra GPU o de otra versión llega a producción, Triton no lo puede cargar. Alba arranca Triton para que se detenga ante cualquier error al cargar un modelo: el pod falla, Kubernetes (el sistema que arranca y vigila los servidores de Alba) lo reinicia, vuelve a fallar, y el despliegue, que no quita ningún pod viejo hasta que el nuevo esté listo, se detiene. Los pods viejos siguen sirviendo. Es la mejor falla posible: ruidosa, temprana y sin afectar a nadie. Los detalles son de «Kubernetes» y «Rollout seguro».
Si algún día Alba tuviera T4 y L4, serían dos engines, dos imágenes y una regla de Kubernetes para mandar cada una a su tipo de máquina.
La paridad del engine
EsencialEngine parity
El engine ya existe y carga en Triton. Ahora la pregunta central: ¿responde lo mismo que el checkpoint que aprobó el gate?
La paridad del engine compara el artefacto que se va a servir con el modelo que se evaluó, foto por foto. No mide si el modelo es bueno: mide si es el mismo. No la confundas con la prueba de paridad del preprocesamiento, que revisa que la foto llegue al modelo con los mismos números en el entrenamiento y en el servicio. Son dos exámenes distintos, con el mismo apellido.
Tres números
La referencia es PyTorch en FP32: el checkpoint aprobado, en eval(). El candidato es el engine FP16 corriendo en Triton. Los dos reciben las mismas N fotos y cada uno da 500 logits por foto. Con eso se calculan tres números:
- donde
- N
- fotos del examen (en Alba, ≈ 10,000 del golden set)
- Nigual
- fotos en que la referencia y el engine dan la misma categoría top-1
- a1
- el acuerdo top-1, la fracción de fotos con la misma primera sugerencia (de 0 a 1)
- Ri,Qi
- las 5 categorías de logit más alto de la foto i, en la referencia y en el engine
- |Ri∩Qi|
- cuántas de esas 5 aparecen en las dos listas (de 0 a 5)
- o5
- el solapamiento top-5, la fracción promedio de las 5 sugerencias que coinciden (de 0 a 1)
- uik,vik
- el logit de la categoría k en la foto i, de la referencia y del engine (sin unidad)
- d
- la diferencia máxima de logits, la más grande de todas las fotos y categorías (sin unidad)
Y los umbrales de Alba: a1 ≥ 99.5 %, o5 ≥ 99 % y d ≤ 0.5.
El acuerdo top-1 y la diferencia máxima de logits ya los viste en «Cómo guarda números una computadora», en su sección «Cuantizar a fondo: punto cero, INT4, FP8 y el examen»: el primero es lo que ve Ana; el segundo delata un bug antes de que cambie una respuesta (FP32 contra FP32 da ≈ 0.0001, un FP16 sano ≈ 0.01 y uno roto 1 o más, así que el tope de 0.5 no da falsas alarmas). Lo nuevo es o5: mide las 5 sugerencias que la pantalla le muestra a Ana, no solo la primera.
La paridad, en chiquito
El código de abajo hace el examen con 40 fotos y 10 categorías. La referencia son logits al azar con semilla fija. El «engine» son esos logits con un poco de ruido y redondeados a FP16 con struct, el módulo de Python que convierte números a bytes (su formato "e" es un número de 16 bits). El «roto» es un engine con una capa que se desbordó: sus números pasaron de ≈ 65,504, el máximo que cabe en FP16, y echaron a perder las salidas. Aquí lo simulamos con mucho ruido. La foto 7 está casi empatada a propósito, entre Tenis y Botas.
import random, struct
random.seed(5)
CATS = ["Tenis", "Botas", "Sandalias", "Mochilas", "Bolsas", "Lámparas",
"Bicicletas", "Relojes", "Gorras", "Playeras"]
fp32 = [[random.gauss(0, 2) for _ in CATS] for _ in range(40)] # 40 fotos × 10 logits
fp32[7][0], fp32[7][1] = 2.301, 2.300 # una foto casi empatada
def a_fp16(x): # redondea a 16 bits, como guarda un engine FP16
return struct.unpack("e", struct.pack("e", x))[0]
engine = [[a_fp16(z + random.gauss(0, 0.004)) for z in foto] for foto in fp32]
roto = [[z + random.gauss(0, 1.0) for z in foto] for foto in fp32] # una capa que se desbordó
def top(foto, k):
return sorted(range(len(foto)), key=lambda c: -foto[c])[:k]
def paridad(nombre, ref, otro):
N = len(ref)
a1 = sum(top(r, 1) == top(o, 1) for r, o in zip(ref, otro)) / N
o5 = sum(len(set(top(r, 5)) & set(top(o, 5))) / 5 for r, o in zip(ref, otro)) / N
d = max(abs(zr - zo) for r, o in zip(ref, otro) for zr, zo in zip(r, o))
pasa = a1 >= 0.995 and o5 >= 0.99 and d <= 0.5
print(f"{nombre:<7} a1 = {a1:.1%} · o5 = {o5:.1%} · d = {d:.4f} · ¿pasa? {pasa}")
paridad("engine", fp32, engine)
paridad("roto", fp32, roto)
print("foto 7:", [round(z, 4) for z in fp32[7][:2]], "→", [round(z, 4) for z in engine[7][:2]])engine a1 = 100.0% · o5 = 100.0% · d = 0.0121 · ¿pasa? True
roto a1 = 70.0% · o5 = 84.5% · d = 2.8273 · ¿pasa? False
foto 7: [2.301, 2.3] → [2.3047, 2.3047]El engine sano da d ≈ 0.012, del orden de 0.01, y coincide en todo. El roto cambia 12 de las 40 primeras sugerencias y su d pasa de 2.8: lo atrapan los tres números a la vez. Y mira la foto 7. En FP16, entre 2 y 4 los números van de 0.002 en 0.002, así que un empate de 0.001 desaparece: los dos logits quedaron en 2.3047. Aquí ganó Tenis porque, en un empate, top se queda con la primera categoría; un engine de verdad puede resolverlo al revés. Esa es la clase de foto que cambia de respuesta en un engine sano.
¿Cuántas fotos necesita el examen?
Con 40 fotos, una sola foto casi empatada que cambie da a1 = 39 ÷ 40 = 97.5 % y tumba el examen. Por eso el examen de verdad es grande. Con ≈ 10,000 fotos y el umbral de 99.5 %, tienen que coincidir 9,950, así que pueden cambiar a lo más 50 (la lección «Cómo guarda números una computadora» lo cuenta en «El examen de un modelo convertido»). Aquí la pregunta es otra: cuánto ruido tiene el examen mismo.
La respuesta corta: miles. Un engine FP16 sano sí cambia unas cuantas fotos casi empatadas, así que el examen necesita lugar para ellas sin confundirlas con un bug. Con 10,000 fotos caben 50 cambios, y un engine sano cambia muchas menos; con 512 caben solo 2, y el examen se vuelve un volado: a veces reprueba a un engine sano y a veces deja pasar uno roto. El recuadro de abajo hace la cuenta.
Para ir más hondoEl examen también tiene ruido+
Supón que un engine sano cambia de verdad el top-1 de una fracción f de las fotos (las casi empatadas). Cuántas cambian en un examen de N fotos es un volado cargado repetido N veces: sale alrededor de N×
- donde
- N
- fotos del examen
- amin
- el acuerdo top-1 mínimo que pide el examen (en Alba, 0.995 = 99.5 %)
- L
- cuántas fotos pueden cambiar de top-1 sin que el examen falle (en fotos)
- f
- la fracción de fotos que el engine cambia de verdad (de 0 a 1)
- N×
f - cuántas cambian en promedio (en fotos)
- σ
- la desviación estándar de ese número, cuánto se mueve de un examen a otro (en fotos)
- D
- el margen en desviaciones: cuántas σ caben entre lo esperado y el límite (sin unidad). Con D ≥ 3 el examen casi nunca se equivoca; con D cerca de 0 es un volado
Toma un engine sano que cambia f = 0.2 % de las fotos (un supuesto del ejemplo: 1 de cada 500, las casi empatadas) y otro con un bug que cambia f = 1 %:
¿Y si el examen fuera de 512 fotos, como el chequeo del export? Entonces L = 0.005 × 512 = 2.56: a lo más 2 cambios. El sano espera ≈ 1, y con una cuenta exacta (la de la distribución binomial) falla ≈ 8.5 % de las veces sin tener nada malo; el roto espera ≈ 5 y pasa ≈ 11 % de las veces. Un examen así falla por mala suerte y deja pasar bugs. Para el export no importa, porque FP32 contra FP32 no cambia ninguna respuesta (f ≈ 0): ahí se exige el mismo top-1 en todas las fotos. Para FP16, hacen falta miles.
Aplica las tres ecuaciones de la lección: L, los cambios de top-1 que caben; σ, cuánto se mueve el número de cambios de un examen a otro; y D, el margen en desviaciones (cada salida dice su fórmula). Arranca con el examen de Alba (10,000 fotos, 99.5 %) y un engine FP16 sano que cambia el 0.2 % de las fotos (un supuesto del ejemplo).
Supone que cada foto cambia o no con la misma probabilidad f, sin depender de las demás, y usa la aproximación normal; con pocas fotos esperadas (menos de ≈ 10) la cuenta exacta, la binomial, se aleja un poco. El 0.2 % de un engine sano es un supuesto del ejemplo, no una medición de Alba.
Empieza con el engine sano y el examen de Alba. Baja N a 512 y mira cómo el margen D cae a ≈ 1.5. Luego sube f a 1 %, el engine roto, con N en 10,000 y en 512.
Tres paridades, tres lugares
Alba corre la paridad tres veces, en tres lugares, porque cada una ve cosas que las otras no:
- En CPU, con ONNX Runtime (paso 2 de esta estación): FP32 contra FP32. Atrapa un export roto: el modelo sin
eval(), un eje de batch que quedó fijo, un opset que cambió. - El engine en Triton, en la T4 (paso 5): FP16 contra FP32, con las ≈ 10,000 fotos. Atrapa lo que hizo TensorRT: una capa que se desborda en FP16, un engine mal construido. Y como corre contra Triton y no contra el
.plansuelto, también revisa el contrato con el servidor: que la entrada se llameinput, sea FP32 con forma[3, 224, 224]por foto, y que la salida sean los 500logits. - De punta a punta, por el gateway real, antes de staging (en «CI/CD y registro de imágenes»). Corre en el runner de CI con T4, con el gateway y el Triton de verdad, justo antes de pasar a staging (una copia completa del sistema, sin gente real, para probar antes de producción). Esta paridad manda fotos JPEG reales por el camino de Ana. Atrapa lo que ninguna de las dos anteriores puede ver, porque las dos reciben la foto ya preparada: un preprocesamiento distinto (los colores en otro orden, otra normalización), un
labels.jsonen otro orden (la lista que dice qué categoría es cada una de las 500 salidas), un tipo de dato distinto en el gateway.
Para ir más hondoUn FP16 con 97 %: dónde buscar el bug+
Un engine FP16 con 97 % de acuerdo no es redondeo: es un bug. FP16 cambia unas cuantas fotos casi empatadas, no 300 de 10,000. La forma de buscarlo es partir el camino en dos:
- Corre el mismo examen con el ONNX en ONNX Runtime, en FP32. Si ahí ya da 97 %, el problema está en el export, no en TensorRT: revisa
eval(), el opset y la versión del exportador. - Si el ONNX da ≈ 100 % y el engine 97 %, el problema está en el build. Lo más común es una capa que se desborda en FP16: un número que pasa de ≈ 65,504, el máximo de FP16, y se vuelve infinito. Se comparan las salidas intermedias capa por capa hasta encontrar dónde diverge, y esa capa se deja en FP32.
Mientras tanto, nada se registra y el champion sigue atendiendo.
El gate de latencia
EsencialThe latency gate
El engine es el mismo modelo. Falta saber si no se volvió más lento. Cada mes el engine se construye de nuevo, y aunque la red es la misma, el build pudo elegir otras tácticas, o alguien cambió el perfil, o la release.
Qué se mide y con qué
perf_analyzer es la herramienta de NVIDIA para medir un servidor Triton desde afuera, como lo haría un cliente. Le manda peticiones a una tasa fija (por ejemplo, 250 por segundo, pase lo que pase: una carga abierta) y anota cuánto tarda cada una en volver. Esa latencia incluye todo lo que pasa dentro de Triton: la espera en la fila, los 2 ms que Triton espera para juntar un batch y el cómputo en la GPU. Es lo que el gateway va a vivir.
Alba lo corre con la imagen nueva de Triton en la T4 del runner, a dos tasas:
- 250 peticiones por segundo: la parte de una T4 en el pico de diseño. Alba diseña para 500 fotos por segundo en su pico, repartidas entre sus 2 T4.
- 500 peticiones por segundo: lo que le toca a una T4 si se cae la otra zona y una sola atiende todo. Cada T4 vive en una zona distinta de AWS: un grupo de centros de datos aparte, con su propia luz y su propia red.
A cada tasa mide el p99 (la latencia que el 99 % de las peticiones no rebasa) del challenger y lo compara con el del champion, medido igual, en el mismo tipo de máquina. Comparar contra el champion, y no contra un número fijo, cancela todo lo que no es el modelo: la máquina, la red del runner, la versión de perf_analyzer.
- donde
- tchamp
- el p99 del champion a esa tasa, en ms
- g
- la holgura permitida, como fracción (en Alba, 0.10: hasta 10 % más lento)
- tlim
- el p99 más alto que puede tener el challenger para pasar, en ms
- tnuevo
- el p99 del challenger a esa tasa, en ms. La segunda línea es la regla: pasa si se cumple a las dos tasas
- λ
- la tasa de la prueba, en peticiones por segundo
- X
- el máximo que da una T4 con el engine FP16, en fotos por segundo (en Alba, ≈ 1,200)
- ρ
- qué fracción de ese máximo usa la prueba (de 0 a 1)
El reporte guarda, además, el máximo de fotos por segundo que alcanzó, cuánta VRAM usa el engine y cuánto tarda Triton en cargarlo. Ninguno de esos tres bloquea por sí solo, pero un cambio grande se revisa.
Con números de un mes normal (los p99 son supuestos del ejemplo, del orden de lo que tarda Triton en la T4 de Alba):
¿Y por qué medir a 500 si a 250 ya pasó? Porque la latencia no crece parejo con la carga: cuando la fila se llena, la cola de la distribución (las peticiones más lentas, las que deciden el p99) crece mucho más que el centro (lo ves en «Utilización: la curva que explota cerca del 100 %», en la lección de latencia). Un engine puede empatar con el champion a media carga y quedarse atrás con la carga doble. El código de abajo lo muestra con latencias simuladas: el challenger tiene casi la misma mediana que el champion, pero una cola más gorda a 500 por segundo.
import math, random
random.seed(11)
def medir(mediana, cola, n=5000): # n latencias en ms; cola más alta = más peticiones muy lentas
return [mediana * math.exp(random.gauss(0, cola)) for _ in range(n)]
def p99(xs): # rango más cercano: la latencia número ⌈0.99·n⌉
xs = sorted(xs)
return xs[math.ceil(0.99 * len(xs)) - 1]
g = 0.10 # holgura: hasta 10 % más lento que el champion
corridas = {250: (medir(6.0, 0.20), medir(6.1, 0.20)), # (champion, challenger)
500: (medir(7.5, 0.22), medir(7.7, 0.30))}
for tasa, (champ, nuevo) in corridas.items():
t_c, t_n = p99(champ), p99(nuevo)
limite = (1 + g) * t_c
print(f"{tasa} req/s · champion {t_c:.2f} ms · challenger {t_n:.2f} ms · "
f"límite {limite:.2f} ms · ¿pasa? {t_n <= limite}")250 req/s · champion 9.56 ms · challenger 9.71 ms · límite 10.52 ms · ¿pasa? True
500 req/s · champion 12.48 ms · challenger 14.99 ms · límite 13.73 ms · ¿pasa? FalseA 250 pasa, a 500 no: la mediana del challenger es apenas 3 % mayor (7.7 contra 7.5 ms), pero su cola es más ancha y el p99 sube 20 %. Si el gate midiera solo a 250, ese engine habría pasado, y el día que se cayera una zona el gateway lo habría sentido.
Aplica las dos ecuaciones de la lección: tlim=
El gate corre esta comparación dos veces, a 250 y a 500 peticiones por segundo, y el challenger tiene que pasar las dos. El ≈ 1,200 de X es el máximo que da una T4 de Alba con TensorRT FP16; los p99 de 12.5 y 13.1 ms son supuestos del ejemplo.
Empieza con el gate de octubre a 500 por segundo. Sube tnuevo a 15 ms, el del código, y mira el margen volverse negativo. Luego sube λ para ver cuánto le queda a la T4.
Huellas y registro: el final de la estación
EsencialFingerprints and registration: closing the station
Con la paridad y la latencia en verde, falta lo que convierte un archivo suelto en una versión que se puede rastrear: las huellas y el registro.
Las huellas del build
Una huella del build es todo lo que se necesita para saber qué archivo es y con qué se fabricó. En Alba son cuatro datos:
- La huella SHA-256 del ONNX.
- La huella SHA-256 del
.plan. - La GPU donde se construyó: T4, sm_75.
- La release de NGC: 24.08, con TensorRT 10.3.
Una huella SHA-256 es un número de 256 bits que sale del contenido exacto de un archivo: si cambia un solo byte, sale otro número completamente distinto, y en la práctica nadie puede fabricar un archivo distinto con la misma huella. La lección «Tiempo, hashes e identificadores» lo explica a fondo. Aquí se usa para una cosa muy concreta: que el .plan que carga Triton sea el mismo que pasó la paridad. Antes de usar el archivo, se le saca su huella y se compara con la que quedó en el registry; si no coinciden, no se usa. El código lo hace con dos archivos de juguete.
import hashlib, json
onnx = b"ONNX de juguete: grafo, pesos y firma" # en Alba, ≈ 98 MB
plan = b"engine de juguete para una T4" # en Alba, ≈ 50-150 MB
def sha256(datos):
return hashlib.sha256(datos).hexdigest()
huellas = {"onnx_sha256": sha256(onnx), "plan_sha256": sha256(plan),
"gpu": "Tesla T4", "compute_capability": "7.5",
"ngc_release": "24.08", "tensorrt": "10.3"}
for k, v in huellas.items():
print(f"{k:<19}", v[:16] + "…" if k.endswith("sha256") else v)
def verificar(datos, esperada): # lo que corre antes de usar el archivo
real = sha256(datos)
if real != esperada:
raise SystemExit(f"FALLÓ: huella {real[:12]}… ≠ registrada {esperada[:12]}…")
print("plan verificado:", real[:12] + "…")
verificar(plan, huellas["plan_sha256"])
verificar(plan + b" ", huellas["plan_sha256"]) # un byte de más: otro archivoonnx_sha256 d2f2bcccd7f0b0ce…
plan_sha256 de7cdd0692942102…
gpu Tesla T4
compute_capability 7.5
ngc_release 24.08
tensorrt 10.3
plan verificado: de7cdd069294…
FALLÓ: huella fecbe1e92280… ≠ registrada de7cdd069294…Un espacio de más dio otra huella, y la verificación detuvo el programa. Así se verifican los pesos al cargarlos en Alba: con su SHA-256, contra lo que dice el registry. La GPU y la release no protegen contra un archivo cambiado: sirven para saber, meses después, por qué un engine no carga en una máquina nueva, y para reconstruirlo igual si hiciera falta.
Lo que guarda la versión
El registro es el último paso. La versión 14 del modelo classifier en el registry (en Alba es MLflow, un programa de código abierto para registrar experimentos y modelos) queda con:
- El ONNX y el engine, con la GPU (T4, sm_75) y la release (24.08) como etiquetas (tags).
- El
labels.json(las 500 categorías en el orden de las salidas) con su huella, y la versión del preprocesamiento, 1.4.0. - La firma de entrada y salida.
- El reporte del gate, el de la paridad y el de la latencia.
- Los punteros de la corrida que la entrenó: el snapshot de datos (la foto fija del dataset con que entrenó), el commit del código (su versión exacta en git) y el digest de la imagen de entrenamiento (su huella). Todo eso viene de «Versionado y linaje» y de «Entrenamiento y experimentos».
Y recibe el alias challenger. A partir de aquí, el modelo nuevo existe para el resto del sistema: las estaciones siguientes lo sirven, lo empaquetan, lo despliegan y lo prueban con tráfico real. El alias champion solo se mueve al final del canary (la prueba con una parte chica del tráfico real), en «Rollout seguro».
¿Cuánto ocupa? Es una cuenta de multiplicar, con los 24,532,532 parámetros del modelo de Alba:
- donde
- P
- parámetros del modelo (en Alba, 24,532,532)
- w
- bytes por parámetro (4 en FP32, 2 en FP16)
- S
- lo que ocupan los pesos, en bytes
Toda la estación tarda ≈ 20–30 min: el paso del engine ≈ 5–10 (el build en sí, ≈ 2–5), la paridad ≈ 10 y el resto unos minutos. El entrenamiento (el fine-tune) tardó ≈ 3–4 h.
Si algún día fuera INT8
ExtraIf it were INT8 someday
INT8 guarda cada número en un entero de 8 bits con una escala, la mitad de bytes que FP16. «Cómo guarda números una computadora» explica cómo funciona y por qué hay que calibrar. Alba no lo usa, y es buena idea entender por qué antes de proponerlo.
Alba responde ≈ 10 millones de fotos al día (las de las publicaciones más las que piden otros equipos): ≈ 116 por segundo en promedio. Repartidas entre las 2 T4 son ≈ 58 fotos por segundo cada una, de las ≈ 1,200 que pueden dar: el ≈ 5 % de su capacidad. Son 2 y no 1 para que, si se cae una zona, la otra siga atendiendo. INT8 haría cada foto más rápida, pero no quitaría ninguna de las dos: no compraría nada.
Cambiaría con ≈ 10 veces el tráfico. A 5,000 peticiones por segundo, el equipo de Alba estima 10 T4 en FP16 contra 6–7 en INT8. A US$0.526 la hora, una T4 cuesta 0.526 × 730 ≈ US$384 al mes (un mes tiene ≈ 730 horas); quitar 3 o 4 son ≈ US$1,150–1,540 al mes. Ahí sí valdría la pena.
Y si un día pasa, la estación cambia así:
- Entra un dato más: las fotos de calibración, ≈ 500–1,000 del tráfico reciente, de todos los slices y con el preprocesamiento del gateway. Son parte de la receta: se versionan y su huella va con las del build.
- El umbral de paridad se fija con datos. INT8 cambia más fotos que FP16, y el 99.5 % puede no ser el número correcto.
- El examen mira la cola larga. Una cuantización puede pasar la paridad con 99 % y romper las categorías chicas, porque el promedio las esconde. El examen de INT8 se mira por categoría y por slice, como el gate.
Errores comunes
EsencialCommon mistakes
En la vida real
ExtraIn real life
En Alba
El 1 de octubre de 2026, el pipeline mensual entrena resnet50-2026-10-01 durante ≈ 3–4 h en una A10G, lo evalúa, y el gate lo aprueba. En ese momento arranca esta estación: el orquestador pide un runner con T4 y corre los siete pasos. El script exporta el ONNX en opset 17, ONNX Runtime lo compara con PyTorch en 512 fotos, build_engine.sh revisa que la GPU sea T4 y construye el engine con la imagen 24.08, el engine queda horneado en la imagen de Triton, la paridad corre las ≈ 10,000 fotos, perf_analyzer mide a 250 y a 500 por segundo, y las huellas se escriben en la versión 14, que queda como challenger. Media hora después, el runner se apaga.
Si algo falla, el paso termina en rojo, avisa a la persona de guardia y el champion sigue atendiendo. Un mes sin modelo nuevo no le cuesta nada a Ana; un engine malo en producción, sí.
Otros sistemas, la misma estación
- Video en tiempo real. Un sistema que analiza las cámaras de un centro de distribución corre su detector en una L4, con un engine FP16 construido con
trtexecen una L4 y con la misma imagen del servidor de video. Su configuración no le dice al servidor dónde está el ONNX, a propósito: si el engine no corresponde, el servidor falla en vez de reconstruirlo en silencio. - Inspección en el edge. En una fábrica, un modelo corre en el edge, en el propio aparato y no en la nube: un módulo Jetson de NVIDIA (una computadora chica con GPU) junto a la línea. Ahí el engine se construye en el propio dispositivo, con el modo de energía fijo (porque cambia la velocidad del chip y, con ella, las tácticas) y para esa versión exacta del software de Jetson, y sus huellas van al registry igual que las de Alba.
- Un modelo chico en CPU. Un modelo de fraude o de texto pequeño puede servirse con ONNX Runtime en CPU, sin GPU y sin engine. La estación se acorta a los pasos 1, 2, 6 y 7: el ONNX es lo que se sirve, y su paridad es FP32 contra FP32.
- Un LLM propio. Un servicio que sirve su propio modelo de lenguaje en H100 también compila y cuantiza, pero su paridad no puede ser «el mismo top-1»: el modelo escribe texto. Se compara con los golden sets de cada producto, con métricas de texto, contra la versión en BF16.
Fuera de ML
Un programa en C se compila para una arquitectura: el binario de una laptop con chip x86 no corre en un teléfono con chip ARM. Por eso las tiendas de apps y los instaladores traen un binario por arquitectura, cada uno compilado y probado aparte. Y una traducción de un contrato se revisa con una retrotraducción: otra persona traduce de vuelta al idioma original, sin ver el original, y se comparan los dos. Es una paridad: no dice si el contrato es bueno, dice si la traducción dice lo mismo.
Ejercicios
EsencialExercises
Resuélvelos con lápiz antes de abrir la solución. Usa las letras de la lección: N, Nigual, a1, o5, Ri, Qi, uik, vik, d (paridad); amin, L, f, σ, D (cuántas fotos); tchamp, tnuevo, tlim, g, λ, X, ρ (latencia); P, w, S (peso).
- 1Fácil
¿Cuánto pesan los pesos del modelo de Alba en FP16? ¿Y en INT8, con 1 byte por parámetro? ¿Por qué el engine completo puede pesar más que eso?
Ver la solución paso a paso
- S=
P× , con P = 24,532,532.w - FP16: 24,532,532 × 2 = 49,065,064 B ≈ 49.1 MB.
- INT8: 24,532,532 × 1 ≈ 24.5 MB. Un archivo INT8 real pesa un poco más, porque guarda escalas y deja algunas partes en más bits: Alba lo estima en ≈ 25.1 MB.
- El engine guarda, además de los pesos, los kernels elegidos, el perfil, y a veces pesos repetidos en el formato que pide cada táctica. Por eso Alba lo estima en ≈ 50–150 MB y lo mide al construirlo.
- S=
- 2Fácil
¿Qué paridad atrapa cada bug: (a) el gateway pasa la foto con los colores en orden BGR (azul, verde, rojo) en vez de RGB (rojo, verde, azul); (b) el ONNX quedó con el batch fijo en 2; (c) una capa del engine se desborda en FP16?
Ver la solución paso a paso
- (a) Solo la de punta a punta, por el gateway: las otras dos reciben la foto ya preparada con el preprocesamiento correcto.
- (b) La de CPU con ONNX Runtime: el chequeo corre batch 1 y 32, y los dos fallan con un batch fijo en 2.
- (c) La del engine en Triton: el ONNX en FP32 está bien, así que la de CPU pasa; el engine FP16 es el que se rompe.
- 3Medio
En noviembre, el champion da tchamp = 12.5 ms de p99 a 500 por segundo y el challenger, tnuevo = 13.9 ms. A 250 por segundo los dos dan 9.6 ms. Con la holgura g = 0.10, ¿pasa el gate? ¿Qué revisarías primero? Y si una T4 da X ≈ 1,200 fotos por segundo, ¿qué fracción de ella usa la prueba de 500, y cuál el promedio real de Alba, ≈ 58 por segundo por T4?
Ver la solución paso a paso
- tlim=
(1+ = 1.10 × 12.5 = 13.75 ms.g)× tchamp - 13.9 > 13.75: falla a 500, aunque a 250 empate. No se registra y sigue el champion.
- Primero, si cambió algo del build: el perfil (¿óptima 16 o 4?), la release, la imagen. Luego, repetir la medición: si la segunda da 13.2, era ruido de la prueba, y ajustar la holgura o cuántas peticiones se miden va en un PR propio.
- ρ=
λ÷ : 500 ÷ 1,200 ≈ 42 %; el promedio, 58 ÷ 1,200 ≈ 5 %. Por eso INT8 no compra nada hoy: las T4 sobran.X
- tlim=
- 4Fácil
Dos fotos, tres categorías. Referencia: foto 1 con logits (4.10, 1.20, 0.50), foto 2 con (2.00, 1.99, −1.00). Engine: foto 1 con (4.11, 1.19, 0.50), foto 2 con (1.99, 2.00, −1.01). Calcula a1 y d. ¿Qué pasaría con estos números en el examen de Alba?
Ver la solución paso a paso
- a1=
Nigual÷ y d=N max|uik− , con N = 2.vik| - Foto 1: top-1 en las dos es la categoría 1 (4.10 y 4.11). Foto 2: la referencia da la 1 (2.00), el engine la 2 (2.00 contra 1.99): cambió. Así, Nigual = 1.
- a1 = 1 ÷ 2 = 50 %.
- d = la mayor de |4.10 − 4.11| = 0.01, |1.20 − 1.19| = 0.01, 0, |2.00 − 1.99| = 0.01, |1.99 − 2.00| = 0.01 y |−1.00 − (−1.01)| = 0.01: 0.01, normal para FP16.
- Con 2 fotos, un empate tumba el a1. En el examen de 10,000, esa foto sería 1 de las 50 permitidas, y d = 0.01 está muy por debajo de 0.5: pasaría.
- a1=
- 5Medio
En una foto, la referencia sugiere (Tenis, Botas, Sandalias, Mocasines, Pantuflas) y el engine (Tenis, Botas, Mocasines, Sandalias, Zapatos de vestir). ¿Cuánto aporta esa foto a o5? Si de 10,000 fotos 9,900 coinciden en sus 5 y 100 son como esta, ¿cuánto vale o5?
Ver la solución paso a paso
- o5=
1N× : cada foto aporta la fracción de sus 5 sugerencias que coinciden.∑|Ri∩Qi|÷ 5 - Ri∩Qi = {Tenis, Botas, Sandalias, Mocasines}: 4 de 5. El orden no importa para o5. Aporta 4/5 = 0.8.
- o5 = (9,900 × 1 + 100 × 0.8) ÷ 10,000 = (9,900 + 80) ÷ 10,000 = 99.8 %, arriba del 99 %.
- o5=
- 6Medio
El equipo de plataforma actualiza la imagen de Triton de producción a una release más nueva, con otra versión de TensorRT, y no reconstruye el engine. ¿Qué pasa al desplegar? ¿Qué debió pasar antes?
Ver la solución paso a paso
- El engine de TensorRT 10.3 no carga en la versión nueva: Triton se detiene al arrancar, el pod nuevo queda reiniciándose y el despliegue (el rollout) se detiene. Los pods viejos siguen sirviendo, así que nadie lo nota afuera.
- Antes: subir de release es un cambio del modelo, no solo del servidor. Se cambia
NGC_RELEASEen el build, se construye un engine nuevo en la T4 con esa release, y pasa su paridad y su latencia como cualquier mes.
- 7Reto
Con la fórmula de D, compara un examen de 2,000 fotos con el de 10,000 para el engine sano (f = 0.2 %). ¿Cuál es más confiable y por qué el de Alba es de 10,000?
Ver la solución paso a paso
- L=
(1− , σ=amin)× N √N× y D=f× (1− f) (L− , con amin = 0.995 y f = 0.002.N× f)÷ σ - Con 2,000: L = 0.005 × 2,000 = 10; esperadas N×
f = 2,000 × 0.002 = 4; σ = √2,000×0.002× ≈ 2.0; D = (10 − 4) ÷ 2.0 ≈ 3.0.0.998 - Con 10,000: D ≈ 6.7 (la cuenta de la lección).
- Las dos pasan casi siempre al engine sano, pero el de 2,000 queda justo en el borde de las 3 desviaciones: con un engine que cambie un poco más (f = 0.3 %), D baja a (10 − 6) ÷ 2.45 ≈ 1.6 (con σ = √2,000×
0.003× ≈ 2.45) y empieza a fallar por mala suerte. Con 10,000, D crece con la raíz de N: el examen distingue mejor lo sano de lo roto, y los 10 minutos de paridad son baratos.0.997
- L=
- 8Reto
La paridad del engine da a1 = 97 % y d = 3.4. ¿Cómo buscas el bug? Escribe los pasos y qué conclusión sacas de cada resultado posible.
Ver la solución paso a paso
- 97 % son ≈ 300 de 10,000 fotos, y d = 3.4 es 340 veces lo normal en FP16 (≈ 0.01): es un bug, no redondeo.
- Paso 1: corre el mismo examen con el ONNX en ONNX Runtime, FP32. Si da ≈ 97 % también, el bug está en el export: revisa
eval(), el opset del archivo y si cambió el exportador o su versión. - Si el ONNX da ≈ 100 % y d ≈ 0.0001, el bug está en el build: compara las salidas de cada capa entre el ONNX y el engine hasta encontrar la primera que diverge; casi siempre es una que pasa del máximo de FP16 (≈ 65,504). Se deja en FP32 y se construye de nuevo.
- En los dos casos, no se registra nada y el champion sigue.
Lo que sigue
EsencialWhat comes next
- «Código de serving» toma el contrato que fijó esta estación (
inputFP32 de[3, 224, 224]por foto,logitsde 500, batch hasta 32) y escribe elconfig.pbtxtde Triton y el gateway que lo usa. - «Empaquetado con Docker» cuenta cómo se arma esa imagen: capas, digest y tag. «CI/CD y registro de imágenes» corre la tercera paridad, de punta a punta por el gateway real, antes de staging.
- «Kubernetes» manda cada imagen al tipo de GPU de su engine, y «Rollout seguro» prueba al
challengercon tráfico real antes de moverle el aliaschampion.
Palabras que vas a oír
EsencialWords you will hear
Estos son los conceptos que presentó esta lección. Cada uno tiene su tarjeta con la definición completa.
ONNXONNX (Open Neural Network Exchange)Un formato de archivo para modelos que leen muchas herramientas, no solo PyTorch. Guarda el grafo de operaciones, los pesos y la firma de la entrada y la salida, y abrirlo no corre código.Más +
Entrenar y servir viven en mundos distintos: PyTorch y Python de un lado, un servidor en C++ como Triton del otro. ONNX es el formato de entrega entre los dos. Un archivo .onnx es un mensaje de protobuf con tres partes: el grafo (operadores como Conv, Relu, Add), los pesos y la firma (nombre, tipo y forma de cada entrada y salida). Declara su opset, la versión de los operadores que usa. Lo pueden correr ONNX Runtime y otros, y lo puede compilar TensorRT. A diferencia de un pickle, es solo datos.
Ejemplo. El model.onnx de Alba pesa ≈ 98 MB (≈ 24.5 millones de pesos × 4 bytes en FP32), está en opset 17 y su firma es input FP32 [batch, 3, 224, 224] → logits FP32 [batch, 500].
OpsetopsetEl número de versión del conjunto de operadores que usa un archivo ONNX. Quien lo lee tiene que conocer esa versión; es parte del contrato del modelo.Más +
Los operadores de ONNX cambian con el tiempo: una versión nueva de un operador acepta otra opción o cambia un valor por omisión. Cada archivo declara su opset, y el programa que lo lee (ONNX Runtime, TensorRT) tiene que soportarlo. Por eso el opset se fija al exportar y se lee del archivo después: un exportador puede escribir uno distinto al pedido sin dar error. Cambiar de opset es un cambio del modelo, con su propia paridad.
Ejemplo. Alba exporta en opset 17 con el exportador viejo (dynamo=False). Con el exportador nuevo de PyTorch, pedir opset 17 puede dejar el archivo en 18, y el chequeo del script lo atrapa porque compara el opset escrito con 17.
Grafo del modelomodel graphLa lista de operaciones de una red y cómo se conectan: qué salida entra a qué operación. Es lo que guarda un archivo ONNX en vez de código.Más +
Una red neuronal, vista por dentro, es una cadena de operaciones: convolución, ReLU, suma, promedio, multiplicación de matrices. El grafo las nombra (cada una es un operador) y dice de dónde viene cada entrada. Con el grafo y los pesos, cualquier programa puede hacer las mismas cuentas sin el código de Python que las escribió. Un compilador como TensorRT lee el grafo, lo simplifica y junta operaciones (fusión).
Analogía. Una receta escrita como diagrama: cada caja es un paso (picar, freír, mezclar) y cada flecha dice qué ingrediente pasa al paso siguiente. Dónde se rompe: la receta no dice cuánto tarda cada paso en tu estufa; eso lo decide quien la compila para su cocina.
Ejemplo. En el grafo de la ResNet-50 de Alba, la salida de una convolución entra a una ReLU, y la de la ReLU a la siguiente convolución o a la suma de la conexión residual; al final, un promedio y una multiplicación de matrices dan los 500 logits.
Eje de batch dinámicodynamic batch axisDeclarar, al exportar un modelo, que la primera dimensión de la entrada y de la salida (cuántas fotos van juntas) puede cambiar. Sin eso, el archivo solo acepta un tamaño de batch.Más +
Al exportar, el modelo se corre una vez con un ejemplo, y las formas de ese ejemplo pueden quedar fijas. El eje de batch dinámico le pone nombre a la dimensión 0 (batch) en vez de un número, en la entrada y en la salida. Es una propiedad del archivo; no es el batching dinámico, que es lo que hace el servidor al juntar peticiones. Entre qué valores puede ir el batch lo fija después el perfil de optimización del engine.
Ejemplo. Alba exporta con un ejemplo de batch 2 y dynamic_axes={"input": {0: "batch"}, "logits": {0: "batch"}}, y el chequeo del script corre batch 1 y batch 32 para comprobar que la dimensión de verdad cambia.
ONNX RuntimeONNX Runtime (ORT)Un programa que carga un archivo ONNX y lo corre, en CPU o en GPU. Reparte las operaciones entre sus proveedores de ejecución (execution providers: CPU, CUDA, TensorRT…), y lo que uno no soporta pasa, sin error, al siguiente de la lista (al final, a la CPU).Más +
ONNX Runtime (ORT) sirve para correr un ONNX sin PyTorch. Optimiza el grafo y reparte sus nodos entre los execution providers que le pidas: CPU, CUDA, TensorRT, OpenVINO. Un nodo que el provider elegido no soporta se corre en el siguiente de la lista (al final, en la CPU), y el modelo sigue respondiendo bien, solo más lento: un fallo silencioso que solo delata la latencia. Se usa para servir modelos chicos en CPU y para revisar un export: correr el ONNX y compararlo con PyTorch.
Ejemplo. En el export de Alba, ORT corre el ONNX en CPU sobre 512 fotos, en batch 1 y 32, y lo compara con PyTorch: mismo top-1 en todas y una diferencia de logits del orden de 0.0001. No necesita GPU.
TensorRTTensorRTEl compilador de modelos de NVIDIA: lee un ONNX y produce un engine, el modelo listo para correr rápido en una GPU concreta, con operaciones juntadas, cuentas en FP16 y la forma más rápida de hacer cada capa en ese chip.Más +
TensorRT toma el grafo de un ONNX y lo compila. Su builder simplifica el grafo, junta operaciones (fusión), elige la precisión de cada capa (FP16 donde puede), cronometra varias implementaciones de cada capa en esa GPU y guarda las ganadoras en un engine. El engine queda atado a la GPU y a la versión de TensorRT. Se usa desde la línea de comandos con trtexec o desde Python.
Analogía. Un sastre que toma el patrón de un traje y lo corta a la medida de una persona: queda mejor que uno de talla, pero no le queda a otra. Dónde se rompe: el sastre mide a la persona una vez; TensorRT cronometra en la GPU, y dos cronometradas pueden dar trajes un poco distintos.
Ejemplo. Alba compila su ResNet-50 con TensorRT 10.3, dentro de la imagen nvcr.io/nvidia/tensorrt:24.08-py3, en una T4: el engine FP16 lleva ≈ 49 MB de pesos y una T4 llega con él a ≈ 1,200 fotos por segundo.
Engine de TensorRTTensorRT engine (.plan)El modelo compilado por TensorRT para una GPU y una versión concretas, guardado en un archivo .plan. Corre mucho más rápido que el modelo original, pero no carga en otra GPU ni con otra versión de TensorRT.Más +
Un engine es el resultado del builder de TensorRT: el grafo ya fusionado, la precisión de cada capa, los kernels elegidos cronometrando en la GPU y los pesos (en FP16 si se pidió). Acepta las formas de su perfil. Por omisión no es portable: depende de la compute capability de la GPU y del formato de esa versión de TensorRT (release). Por eso se construye en CI, en la GPU de destino, y se verifica con su huella antes de servirlo. Como sus números cambian un poco, pasa una paridad contra el modelo original.
Ejemplo. El model.plan de Alba se construye en una T4 con TensorRT 10.3, en FP16, con perfil 1/16/32; pesa de ≈ 50 a 150 MB y vive en classifier/1/model.plan, horneado en la imagen de Triton. En una L4 no carga.
Fusión de capaslayer fusionJuntar varias operaciones seguidas de una red (una convolución, su BatchNorm, su ReLU) en un solo kernel: un solo programa que corre en la GPU. Se lanzan menos kernels y los resultados intermedios no van y vuelven de la memoria.Más +
Sin fusionar, cada operación es al menos un kernel: la CPU lo lanza, la GPU lo corre y escribe su resultado en memoria para que el siguiente lo lea. Fusionar junta varias en una: un kernel que hace la convolución, aplica la BatchNorm y la ReLU y suma la conexión residual de un jalón. Lo hacen los compiladores como TensorRT y torch.compile. Ahorra lanzamientos y viajes a memoria; las cuentas son las mismas, aunque en otro orden.
Ejemplo. En PyTorch, sin fusionar, la ResNet-50 de Alba son 174 operaciones por batch; el engine de TensorRT las deja en ≈ 56 kernels.
Perfil de optimizaciónoptimization profileLas tres formas de entrada que se le dan a TensorRT para un eje variable (como el tamaño del batch): la mínima, la óptima y la máxima. El engine acepta cualquier forma entre la mínima y la máxima, y elige cómo hacer cada capa pensando en la óptima.Más +
Un ONNX con batch dinámico acepta cualquier batch, pero un engine necesita un rango, porque elige sus kernels cronometrando tamaños concretos. El perfil da tres: mínima (lo más chico que acepta), óptima (para la que se cronometra) y máxima (lo más grande; un batch mayor no entra). La máxima debe coincidir con el batch máximo del servidor. Si el tráfico real trae batches muy distintos de la óptima, conviene probar otra y quedarse con la de mejor p99.
Ejemplo. El engine de Alba tiene mínima 1, óptima 16 y máxima 32 (--minShapes=input:1x3x224x224, --optShapes=input:16x3x224x224, --maxShapes=input:32x3x224x224). En la hora pico los batches reales son de ≈ 1 a 3, así que el 16 es un punto de partida, no un dato.
trtexectrtexecLa herramienta de línea de comandos de TensorRT: construye un engine desde un ONNX y lo mide. Su número mide el engine solo, sin la fila del servidor ni la red.Más +
trtexec recibe un ONNX y opciones (--fp16, el perfil con --minShapes, --optShapes y --maxShapes) y guarda el engine con --saveEngine. Al final corre un benchmark con la forma de --shapes. Ese número sirve como chequeo de sanidad (el engine no está roto), pero no decide capacidad: no incluye la fila ni el batching del servidor, y a veces mide batches que en producción no llegan. Para eso está perf_analyzer.
Ejemplo. En Alba, build_engine.sh corre trtexec --onnx=model.onnx --saveEngine=model.plan --fp16 con el perfil 1/16/32 y un benchmark en batch 16, dentro de la imagen tensorrt:24.08-py3 (TensorRT 10.3), en la T4 del runner; tarda ≈ 2–5 min.
Compute capabilitycompute capabilityEl número con que NVIDIA identifica la arquitectura de cada generación de GPUs: 7.5 para la T4 (sm_75), 8.9 para la L4. Un engine de TensorRT construido para una no carga en otra.Más +
Cada generación de GPUs de NVIDIA entiende su propio juego de instrucciones, y se identifica con un número: 7.5 la T4, 8.0 la A100, 8.6 la A10G, 8.9 la L4, 9.0 la H100. Se escribe también sm_75, sm_89… Los kernels se compilan para una o varias de esas arquitecturas. Un engine es más estricto todavía: sus kernels se eligieron cronometrando en esa GPU. Por eso un engine se construye para cada tipo de GPU donde se va a servir.
Ejemplo. El engine de Alba es para sm_75, la T4. Si Alba agregara L4 (sm_89), haría falta un segundo engine, otra imagen y una regla para mandar cada imagen a su tipo de máquina.
Release de NGCNGC releaseUna entrega mensual de los contenedores de NVIDIA (TensorRT, Triton, PyTorch), nombrada por año y mes, como 24.08. Los de una misma release comparten la base: la misma CUDA y la misma TensorRT.Más +
NVIDIA publica sus programas en contenedores listos en su catálogo NGC, con una release al mes que se nombra AA.MM. Dentro de una release, el contenedor de TensorRT y el de Triton traen la misma versión de TensorRT y de CUDA. Para un engine, eso es lo que importa: si se construye con la release del servidor, el servidor lo puede cargar. Cambiar de release es un cambio del modelo: engine nuevo, paridad y latencia.
Ejemplo. Alba construye con nvcr.io/nvidia/tensorrt:24.08-py3 (TensorRT 10.3) y sirve con tritonserver:24.08-py3 (Ubuntu 22.04, CUDA 12.6). build_engine.sh fija NGC_RELEASE=24.08, y la release queda como tag de la versión en el registry.
Paridad del engineengine parityEl examen que comprueba que el modelo convertido que se va a servir responde lo mismo que el modelo que se evaluó: la misma primera sugerencia (top-1) en casi todas las fotos y logits casi iguales. No mide si el modelo es bueno, sino si es el mismo.Más +
Convertir un modelo (a ONNX, a un engine FP16) mueve un poco sus números. La paridad corre el original y el convertido sobre las mismas fotos y compara tres cosas: el acuerdo top-1, el solapamiento de las 5 primeras sugerencias y la diferencia máxima de logits. Si pasa, lo que midió el gate de calidad sigue valiendo para el engine. Es distinta de la prueba de paridad del preprocesamiento. Se corre en tres lugares: en CPU al exportar, con el engine en el servidor y de punta a punta por el gateway.
Analogía. La prueba de imprenta de un libro: la editorial compara lo impreso con el archivo aprobado antes del tiraje. Dónde se rompe: la prueba se espera idéntica; el engine no, y por eso la paridad mide cuánto cambia con umbrales.
Ejemplo. Alba corre el engine FP16 en Triton contra PyTorch FP32 en ≈ 10,000 fotos del golden set: top-1 igual en ≥ 99.5 % (a lo más 50 fotos cambian), top-5 que coincide en ≥ 99 % y diferencia máxima de logits ≤ 0.5 (lo normal es ≈ 0.01). Si falla, no se registra la versión y sigue el champion.
Acuerdo top-1top-1 agreementLa fracción de fotos en que dos versiones de un modelo dan la misma primera sugerencia. Es el número de la paridad que más se parece a lo que ve la persona usuaria.Más +
Se calcula como a1=
Ejemplo. En Alba, a1 ≥ 99.5 % sobre ≈ 10,000 fotos: 9,950 deben coincidir. Un engine con 97 % no es redondeo, es un bug.
Diferencia máxima de logitsmax logit differenceLa diferencia más grande, sin signo, entre un logit (la puntuación cruda de cada categoría) del modelo convertido y el del original, buscando en todas las fotos y todas las categorías. Delata un bug antes de que cambie una respuesta.Más +
Se calcula como d=
Ejemplo. En Alba, el chequeo del export (FP32 contra FP32) espera ≈ 0.0001, y la paridad del engine FP16 ve ≈ 0.01 con un tope de 0.5 para no dar falsas alarmas y atrapar un engine roto.
perf_analyzerperf_analyzerLa herramienta de NVIDIA que mide un servidor Triton desde afuera, como un cliente: manda peticiones a una tasa fija y reporta la latencia (percentiles p50, p99…) y el throughput. Su p99 es el que decide si un modelo cabe.Más +
perf_analyzer le habla a Triton por la red y mide cada petición de ida y vuelta, así que incluye la fila del servidor, la espera del batching dinámico y el cómputo. Con una tasa fija (carga abierta) mide lo que vivirá el gateway. Es la base de un gate de latencia: el p99 del modelo nuevo, a las tasas de diseño, comparado con el del modelo actual medido igual. No confundir con trtexec, que mide el engine solo.
Ejemplo. Alba corre perf_analyzer contra la imagen nueva de Triton en la T4 a 250 peticiones por segundo (la parte de una T4 en el pico de diseño) y a 500 (una zona caída). Pasa si el p99 no sube más de 10 % sobre el del champion a las dos tasas; también anota el throughput máximo, la VRAM y el tiempo de carga.
Huellas del buildbuild fingerprintLo que identifica un artefacto compilado y cómo se fabricó: la huella SHA-256 de cada archivo, la GPU y las versiones del software. Van al registro de modelos (registry) con la versión del modelo.Más +
Un engine depende de su ONNX, de la GPU y de la release con que se construyó. Las huellas guardan todo eso: el SHA-256 del ONNX y del .plan (para verificar que el archivo que se carga es el que pasó la paridad; un byte distinto da otra huella) y la GPU y las versiones (para saber, meses después, por qué no carga en una máquina nueva y para reconstruirlo igual). Si hubiera datos de calibración, su huella también.
Ejemplo. Las huellas de la versión 14 de Alba son el SHA-256 del ONNX y del plan, la GPU (T4, sm_75) y la release de NGC (24.08, TensorRT 10.3). Los pesos se verifican con su SHA-256 al cargarlos.
Chequeo
EsencialCheck
Intenta responder en tu cabeza antes de abrir cada respuesta.
1¿Qué guarda un archivo ONNX, y por qué Alba lee el opset del archivo después de exportar?Ver respuesta
El grafo de operadores, los pesos y la firma (nombres, tipos y formas de la entrada y la salida). Lee el opset porque el exportador puede escribir otro distinto al pedido sin dar error, y el opset es parte del contrato con quien lo lee.
2¿Por qué el engine de Alba no carga en una L4?Ver respuesta
Porque TensorRT eligió y cronometró sus kernels para la T4 (sm_75), y la L4 es otra arquitectura (sm_89). También dejaría de cargar con otra versión de TensorRT.
3¿Qué mide cada uno de los tres números de la paridad del engine?Ver respuesta
a1: en qué fracción de fotos coincide la primera sugerencia. o5: qué fracción de las 5 sugerencias coincide, en promedio. d: la diferencia más grande entre un logit del engine y el de PyTorch, que delata un bug antes de que cambie una respuesta.
4¿Por qué el examen del engine es de ≈ 10,000 fotos y no de 512?Ver respuesta
Porque FP16 sí cambia algunas fotos casi empatadas. Con 512 solo caben 2 cambios: un engine sano fallaría por mala suerte y uno roto podría pasar. Con 10,000 caben 50, y el margen entre lo sano y lo roto es de varias desviaciones.
5¿Por qué el gate de latencia usa
perf_analyzery notrtexec, y por qué mide a 500 por segundo?Ver respuestatrtexecmide el engine solo, sin la fila ni el batching de Triton.perf_analyzermide como un cliente, a tasa fija. A 500 porque es la carga de una T4 con una zona caída, y la cola de la latencia crece más rápido que el centro.6¿Cuándo queda registrada la versión como
challenger, y qué se guarda con ella?Ver respuestaAl final de esta estación, con la paridad y la latencia en verde. Se guardan el ONNX y el engine con sus huellas SHA-256, la GPU y la release, el
labels.jsoncon su huella, la versión del preprocesamiento, la firma, los reportes y los punteros de la corrida.