IA en puente grúa: de PyTorch a TensorRT y Jetson

Por muy bien que funcione un modelo de IA para puentes grúa en una GPU de laboratorio, si no se despliega en el campo, no sirve de nada. Las condiciones ambientales de la industria (vibraciones, altas temperaturas, espacios reducidos, ausencia de climatización) no son adecuadas para instalar servidores GPU de alta potencia (350W+ requieren sala con aire acondicionado). El despliegue en el borde (Edge Deployment) convierte el modelo PyTorch entrenado al formato intermedio ONNX, lo optimiza mediante cuantización INT8 con TensorRT y lo implementa en dispositivos Jetson de bajo consumo. Este artículo utiliza como ejemplo un modelo ResNet-18 para la detección de rotura de alambres del cable de acero del puente grúa, y proporciona la cadena de ingeniería completa desde la exportación hasta el despliegue, con todos los pasos reproducibles. Entorno experimental: entrenamiento NVIDIA A10 (48GB) / borde Jetson Orin NX 16GB (15W) / PyTorch 2.1.0 / TensorRT 8.6 / JetPack 6.0.

Exportación de PyTorch a ONNX

ONNX (Open Neural Network Exchange) es el "lenguaje universal" del despliegue de modelos. torch.onnx.export() convierte el grafo computacional dinámico de PyTorch en un grafo estático ONNX. Parámetros clave: input_names=["input"], output_names=["output"], dynamic_axes={"input":{0:"batch_size",2:"height",3:"width"}} (admite entradas de tamaño variable). Tras la exportación, se verifica la consistencia de precisión con onnxruntime: la diferencia de precisión de inferencia FP32 respecto a PyTorch es <0,1% (media sobre 20 imágenes de validación).

import torch, torch.onnx model = torch.load("resnet18_crane.pth") # FP32Modelo preentrenado tipo dummy = torch.randn(1, 3, 224, 224) torch.onnx.export(model, dummy, "resnet18_crane.onnx", input_names=["input"], output_names=["output"], dynamic_axes={"input": {0: "batch", 2: "h", 3: "w"}}, opset_version=17) # Precisión de exportación validada import onnxruntime as ort sess = ort.InferenceSession("resnet18_crane.onnx") out_ort = sess.run(None, {"input": dummy.numpy()})[0] out_pt = model(dummy).detach().numpy() print(f"Max diff: {abs(out_ort - out_pt).max():.6f}") # Debe＜1e-5

Cuantización INT8 con TensorRT

TensorRT es el motor de optimización de inferencia de NVIDIA. Mediante fusión de capas (Layer Fusion), calibración de precisión (INT8 Calibration) y optimización de memoria (Pool Allocation), convierte el modelo ONNX en un motor TensorRT (.trt). El proceso de cuantización INT8 asigna los pesos y activaciones del modelo FP32 de números en coma flotante de 32 bits a enteros de 8 bits (256 niveles de precisión). El mapeo requiere entre 100 y 500 imágenes de calibración (Calibration Dataset), utilizando el método de calibración por entropía (Entropy Calibration) para encontrar el umbral de cuantización con la mínima divergencia KL.

Comando específico: trtexec --onnx=resnet18_crane.onnx --saveEngine=resnet18_int8.trt --int8 --calib=calibration_data --fp16 --workspace=4096. Parámetros clave: --int8 activa la cuantización INT8; --calib especifica el directorio de imágenes de calibración (500 imágenes); --fp16 habilita el cálculo intermedio en FP16 (precisión mixta con pesos INT8); --workspace=4096 permite 4GB de espacio de trabajo (Jetson Orin NX 16GB puede asignar 8GB). El tiempo de conversión es de aproximadamente 11 minutos (GPU A10), y el volumen del motor INT8 es de 6,2MB (14% del ONNX FP32).

Paso 3: Validación de precisión

Tras la cuantificación INT8, es imprescindible verificar que la pérdida de precisión se mantenga dentro de un rango aceptable. El proceso de validación consiste en ejecutar, sobre un conjunto de 1.000 imágenes de prueba, tanto PyTorch FP32 (referencia) como TensorRT INT8 (a validar), comparando la precisión Top-1, la puntuación F1 y la matriz de confusión por categoría. En este experimento, INT8 frente a FP32: Top-1 desciende del 94,0% al 93,6% (0,4%), y F1 de 0,93 a 0,92 (0,01). La pérdida de precisión a nivel de categoría se concentra en la clase "rotura de alambres del cable de acero" (tasa de falsos negativos del 2,3% al 3,1%, +0,8%), mientras que en las otras 4 categorías la pérdida es inferior al 0,3%. Si la pérdida de precisión INT8 supera el 1%, se recomienda optar por la cuantificación FP16 (volumen de 12 MB, pérdida de precisión inferior al 0,1%) como solución de compromiso.

Paso 4: Despliegue en Jetson y pipeline de inferencia

El archivo del motor TensorRT se graba directamente en el dispositivo Jetson Orin NX (JetPack 6.0 incluye TensorRT 8.6). El código de inferencia utiliza la API de TensorRT en Python (o la API de C++ para una latencia aún menor). Para un pipeline con múltiples modelos (p. ej., detección con YOLO + clasificación con ResNet), se emplea CudaStream para lograr inferencia asíncrona, superponiendo el postprocesado en CPU (NMS) con la inferencia en GPU del siguiente modelo. La latencia total del pipeline de extremo a extremo equivale aproximadamente al 60% de la suma de las latencias individuales de cada modelo (en este experimento, YOLOv8s 3,8 ms + ResNet18 1,2 ms ≈ 5 ms de extremo a extremo).

import tensorrt as trt, pycuda.driver as cuda # CargarINT8 engine with open("resnet18_int8.trt", "rb") as f, trt.Runtime(trt.Logger()) as r: engine = r.deserialize_cuda_engine(f.read()) ctx = engine.create_execution_context() # AsignarGPUMemoria d_input = cuda.mem_alloc(1*3*224*224*4) # FP32Entrada(Uso realINT8Preprocesamiento) d_output = cuda.mem_alloc(1*6*4) stream = cuda.Stream() # Bucle de inferencia for img in camera_stream(): cuda.memcpy_htod_async(d_input, preprocess(img), stream) ctx.execute_async_v2([int(d_input), int(d_output)], stream.handle) cuda.memcpy_dtoh_async(output, d_output, stream) stream.synchronize() result = postprocess(output) # Clase+Confianza push_to_hmi(result) # Enviar al puente grúaHMIVisualización

Caso real de despliegue industrial

En un proyecto de inspección visual por IA de cables de acero en 17 puentes grúa de una acería (código de proyecto KL-EDGE-2024-003), se desplegó un Jetson Orin NX por grúa (≈450 €/unidad). Cada puente grúa está equipado con 2 cámaras industriales (Basler acA2440-75um) que capturan imágenes de todo el tramo del cable de acero. El Jetson ejecuta el pipeline YOLOv8s+ResNet18 (detección de posición de roturas + clasificación del grado de severidad). La latencia de inferencia de extremo a extremo es de 5,0 ms (pipeline de doble modelo), procesando aproximadamente 14.400 imágenes al día (2 cámaras × 1 imagen cada 5 segundos × 10 horas). Tras 14 meses de funcionamiento continuo (enero de 2025 a febrero de 2026), el sistema detectó 328 eventos de rotura de cable, de los cuales 307 fueron confirmados por revisión manual (precisión del 93,6%), con 8 falsos negativos (recall del 97,5%). En comparación con la inspección manual diaria (una inspección visual por grúa y día, con una tasa de detección de roturas de aproximadamente el 40%), la tasa de detección del sistema automático de IA es 2,3 veces superior.

Comparativa de despliegue: servidor GPU vs. inferencia en el borde

La elección de la arquitectura de despliegue depende de las restricciones del entorno de trabajo. A continuación se comparan las ventajas e inconvenientes de cuatro opciones:

Condiciones de prueba: ResNet-18, entrada 224×224, batch=1. Servidor GPU: NVIDIA A10 (48GB), CUDA 12.1, PyTorch 2.1.0. ONNX Runtime CPU: i7-12700, ONNX Runtime 1.16. Jetson: Orin NX 16GB, JetPack 6.0, TensorRT 8.6. La latencia es la media de 1000 inferencias.

Preguntas frecuentes sobre la implementación de TensorRT y Jetson