IA em Ponte Rolante com PyTorch para ONNX e TensorRT

Um modelo de IA para pontes rolantes pode ter um excelente desempenho numa GPU de laboratório, mas se não for implementado no terreno, não tem valor. As condições ambientais industriais (vibração, altas temperaturas, espaço limitado, sem ar condicionado) não são adequadas para servidores GPU de alta potência (350W+ exigem ar condicionado em sala de servidores). A implementação na periferia (Edge Deployment) converte o modelo PyTorch treinado para o formato intermédio ONNX, otimiza-o através da quantização INT8 TensorRT e implementa-o em dispositivos Jetson de baixo consumo. Este artigo utiliza o modelo ResNet-18 para detecção de fios rompidos em cabo de aço de ponte rolante como exemplo, fornecendo o fluxo completo de engenharia, desde a exportação até à implementação, com todos os passos reproduzíveis. Ambiente experimental: treino NVIDIA A10(48GB) / periferia Jetson Orin NX 16GB(15W) / PyTorch 2.1.0 / TensorRT 8.6 / JetPack 6.0.

Exportação do modelo PyTorch para ONNX

ONNX (Open Neural Network Exchange) é a “linguagem universal” para implementação de modelos. A função torch.onnx.export() converte o grafo computacional dinâmico do PyTorch num grafo estático ONNX. Parâmetros essenciais: input_names=[“input”], output_names=[“output”], dynamic_axes={“input”:{0:”batch_size”,2:”height”,3:”width”}} (suporta entradas de dimensões variáveis). Após a exportação, utilize onnxruntime para validar a consistência da precisão: a diferença de precisão de inferência FP32 em relação ao PyTorch é <0,1% (média de 20 imagens do conjunto de validação).

import torch, torch.onnx model = torch.load("resnet18_crane.pth") # modelo pré-treinado FP32 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) # Precisão de exportação verificada 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}") # deve＜1e-5

Quantização INT8 com TensorRT

O TensorRT é o motor de otimização de inferência da NVIDIA, que converte modelos ONNX em motores TensorRT (.trt) através de fusão de camadas (Layer Fusion), calibração de precisão (Calibração INT8) e otimização de memória (Pool Allocation). O processo de quantização INT8: mapeia os pesos e ativações do modelo FP32 de números de vírgula flutuante de 32 bits para inteiros de 8 bits (256 níveis de precisão). O mapeamento requer 100 a 500 imagens de calibração (Dataset de Calibração), utilizando o método de calibração por entropia (Calibração por Entropia) para encontrar o limiar de quantização com divergência KL mínima.

Comando específico: trtexec –onnx=resnet18_crane.onnx –saveEngine=resnet18_int8.trt –int8 –calib=calibration_data –fp16 –workspace=4096. Explicação dos parâmetros essenciais: –int8 ativa a quantização INT8; –calib especifica o diretório de imagens de calibração (500 imagens); –fp16 ativa o cálculo intermédio FP16 (precisão mista com pesos INT8); –workspace=4096 permite 4GB de espaço de trabalho (o Jetson Orin NX 16GB pode alocar 8GB). O tempo de conversão é de aproximadamente 11 minutos (GPU A10), e o tamanho do motor INT8 é de 6,2MB (14% do ONNX FP32).

Validação da Precisão Pós-Quantização

Após a quantização INT8, é obrigatório confirmar se a perda de precisão permanece dentro dos limites aceitáveis. O procedimento de validação consiste em executar, num conjunto de teste de 1.000 imagens, o PyTorch FP32 (referência) e o TensorRT INT8 (em validação), comparando a precisão Top-1, o score F1 e a matriz de confusão de cada classe. Nesta experiência, INT8 vs FP32: Top-1 desceu de 94,0% para 93,6% (0,4%), e o F1 de 0,93 para 0,92 (0,01). Ao nível das classes, a perda concentra-se na classe "rotura de fios do cabo de aço" (taxa de falsos negativos subiu de 2,3% para 3,1%, +0,8%); nas restantes 4 classes, a perda foi inferior a 0,3%. Se a perda de precisão INT8 exceder 1%, recomenda-se a quantização FP16 (volume de 12 MB, perda de precisão <0,1%) como solução de compromisso.

Implementação no Jetson e Pipeline de Inferência

O ficheiro do motor TensorRT é gravado diretamente no Jetson Orin NX (JetPack 6.0 com TensorRT 8.6 pré-instalado). O código de inferência utiliza a API TensorRT com bindings Python (ou a API C++ para latências mais baixas). Para um pipeline com múltiplos modelos (ex.: deteção YOLO + classificação ResNet), recorre-se a CudaStream para inferência assíncrona, sobrepondo o pós-processamento na CPU (NMS) com a inferência GPU do modelo seguinte. A latência total do pipeline corresponde a cerca de 60% da soma das latências individuais (nesta experiência: YOLOv8s 3,8 ms + ResNet18 1,2 ms ≈ 5 ms de ponta a ponta).

import tensorrt as trt, pycuda.driver as cuda # carregamentoINT8 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() # alocaçãoGPUmemória d_input = cuda.mem_alloc(1*3*224*224*4) # FP32entrada(uso realINT8pré-processamento) d_output = cuda.mem_alloc(1*6*4) stream = cuda.Stream() # ciclo de inferência 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) # categoria+confiança push_to_hmi(result) # enviar para ponte rolanteHMIexibição

Caso Real: Inspeção de Cabos de Aço em Ponte Rolante

Num projeto de inspeção visual por IA de cabos de aço em 17 pontes rolantes de uma siderurgia (n.º de projeto KL-EDGE-2024-003), cada ponte rolante foi equipada com um Jetson Orin NX (€448/unidade). Cada ponte tem 2 câmeras industriais (Basler acA2440-75um) que captam imagens de todo o comprimento do cabo de aço. O Jetson executa o pipeline YOLOv8s+ResNet18 (deteção de roturas + classificação do grau de gravidadeau de gravidade). A latência de inferência é de 5,0 ms de ponta a ponta (pipeline de dois modelos), processando cerca de 14.400 imagens por dia (2 câmeras × 1 imagem a cada 5 segundos × 10 horas). Durante 14 meses contínuos de operação (janeiro de 2025 a fevereiro de 2026), o sistema detetou 328 eventos de rotura de fios; a verificação manual confirmou 307 (precisão de 93,6%) e registaram-se 8 falsos negativos (recall de 97,5%) de 97,5%). Em comparação com a inspeção visual diária (1 inspeção ocular por ponte por dia, com taxa de deteção de roturas de cerca de 40%), a deteção automática por IA aumentou a taxa de deteção em 2,3 vezes.

Servidor GPU vs. Inferência na Borda: Qual Escolher?

A escolha da arquitetura de implementação depende das condicionantes do local — segue-se uma comparação entre quatro abordagens:

Condições de teste: 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. Latência calculada como média de 1000 inferências.

Perguntas Frequentes sobre Otimização de Inferência