Modernizando Ferramentas de Inspeção Inline (PIG): Como Integrar IA ao Legado .NET

A integridade estrutural de dutos de transporte depende criticamente de operações de inspeção inline (ILI, do inglês Inline Inspection). No centro dessa operação estão os Intelligent PIGs (Pipeline Inspection Gauges), dispositivos que percorrem quilômetros de tubulações coletando gigabytes de dados sensoriais — como perda de fluxo magnético (MFL) e ultrassom — para identificar corrosões, trincas e deformações.

Historicamente, muitas dessas ferramentas de análise interna foram construídas sobre o ecossistema .NET legado (C# ou VB.NET). Embora robustas para a interface gráfica e processamento sequencial básico, essas aplicações sofrem gargalos severos de escalabilidade analítica quando confrontadas com volumes massivos de dados brutos e com a necessidade de triagem preditiva automatizada.

Neste artigo, você entenderá como desacoplar a camada analítica de um software de inspeção .NET legado e implementar um pipeline de inteligência artificial em Python para classificação e detecção automática de anomalias.

O Desafio da Inspeção Tradicional de Dutos

Em softwares de inspeção desenvolvidos há alguns anos, o fluxo de trabalho típico envolve:

1. Download dos dados brutos dos sensores após a corrida do PIG.
2. Carregamento desses arquivos massivos na memória da aplicação desktop .NET.
3. Aplicação de filtros manuais e limiares estáticos de tolerância por analistas de integridade.

Esse modelo gera dois gargalos evidentes: tempo de análise humana para milhões de pontos de medição e altas taxas de falsos positivos, causadas por ruídos mecânicos e variações na geometria do duto.

A solução não exige reescrever toda a aplicação .NET do zero. O caminho mais eficiente consiste em manter a interface de domínio em .NET e delegar a inferência analítica a modelos de Machine Learning e Deep Learning orquestrados em Python.

Arquitetura da Solução: Coexistência .NET e Python AI

Como especialista em IA aplicada à indústria pesada, observo que a transição mais segura para softwares críticos de engenharia é a arquitetura híbrida de alto desempenho. Em vez de chamadas lentas entre processos, adotamos o padrão ONNX (Open Neural Network Exchange) ou serviços locais de inferência com IPC (Inter-Process Communication) de baixa latência.

Fluxo Operacional Modernizado

text
[Sensores do PIG (MFL / UT)] ↓
[Aplicação .NET (Parsing & Pré-processamento)] ↓ (Exportação de Tensores / IPC)
[Motor de Inferência Python / ONNX Runtime] ↓ (Detecção de Corrosão e Trincas)
[Dashboard .NET (Visualização de Anomalias Classificadas)]

Implementando a Detecção de Anomalias com Python

Para ilustrar o processo analítico, consideremos a leitura de densidade de fluxo magnético (MFL). Vamos construir uma rotina em Python que aplica janelamento de sinal e executa uma rede pré-treinada para detecção de anomalias morfológicas.

1. Pré-processamento de Sinais do PIG

python
import numpy as np
from scipy.signal import butter, filtfilt

def filtrarsinalmfl(dadosbrutos: np.ndarray, taxaamostragem: float = 1000.0) -> np.ndarray:
“””
Aplica filtro passa-faixa para remover ruídos de vibração mecânica
mantendo as assinaturas de corrosão.
“””
nyquist = 0.5 * taxaamostragem
low = 5.0 / nyquist
high = 150.0 / nyquist
b, a = butter(4, [low, high], btype=’band’)
return filtfilt(b, a, dadosbrutos)

def criarjanelastemporais(sinal: np.ndarray, tamanhojanela: int = 128, passo: int = 32) -> np.ndarray:
“””
Gera tensores em janelas deslizantes para entrada no modelo de inferência.
“””
janelas = [] for i in range(0, len(sinal) – tamanhojanela, passo):
janelas.append(sinal[i : i + tamanhojanela])
return np.expanddims(np.array(janelas), axis=-1)

2. Exportando e Integrando via ONNX

Modelos treinados em frameworks modernos como PyTorch ou TensorFlow podem ser compilados diretamente para o formato ONNX. A vantagem técnica central é que o próprio runtime do .NET possui suporte nativo ao ONNX Runtime, permitindo carregar o modelo treinado em Python diretamente dentro do código C# sem sobrecarga de rede.

python
import torch
import torch.nn as nn

class AnomalyDetector(nn.Module):
def init(self):
super().init()
self.conv = nn.Sequential(
nn.Conv1d(1, 16, kernelsize=5, padding=2),
nn.ReLU(),
nn.MaxPool1d(2),
nn.Conv1d(16, 32, kernelsize=3, padding=1),
nn.ReLU(),
nn.AdaptiveAvgPool1d(1)
)
self.fc = nn.Linear(32, 2) # Classes: Normal vs. Anomalia

def forward(self, x):
    x = x.permute(0, 2, 1)  # Ajuste de dimensões para Conv1d
    features = self.conv(x).squeeze(-1)
    return self.fc(features)

Exportação para uso compartilhado

modelo = AnomalyDetector()
modelo.eval()
dummy_input = torch.randn(1, 128, 1)

torch.onnx.export(
modelo,
dummyinput,
“detectorpigmfl.onnx”,
inputnames=[‘leiturasensor’],
outputnames=[‘probabilidadeanomalia’],
dynamicaxes={‘leiturasensor’: {0: ‘batchsize’}, ‘probabilidadeanomalia’: {0: ‘batchsize’}}
)

3. Consumo Eficiente no .NET (C#)

No lado da aplicação legada, basta incluir o pacote NuGet Microsoft.ML.OnnxRuntime e processar blocos de inspeção com alto throughput:

csharp
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.ML.OnnxRuntime;
using Microsoft.ML.OnnxRuntime.Tensors;

public class InspecaoAI
{
private readonly InferenceSession _session;

public InspecaoAI(string modelPath)
{
    // Carrega o grafo compilado diretamente na memória da aplicação .NET
    _session = new InferenceSession(modelPath);
}

public float[] AvaliarJanelaSensor(float[] dadosJanela)
{
    var tensor = new DenseTensor<float>(dadosJanela, new[] { 1, dadosJanela.Length, 1 });
    var inputs = new List<NamedOnnxValue>
    {
        NamedOnnxValue.CreateFromTensor("leitura_sensor", tensor)
    };

    using var results = _session.Run(inputs);
    return results.First().AsEnumerable<float>().ToArray();
}

}

Benefícios da Modernização em Camadas

1. Preservação de Investimento: As regras de negócio e interfaces visuais consolidadas no .NET não precisam ser descartadas.
2. Velocidade de Processamento: Modelos exportados em ONNX executam em C++ otimizado internamente, aproveitando aceleração por hardware (GPU/AVX).
3. Precisão Analítica: O time de ciência de dados trabalha livremente no ecossistema Python (Pandas, SciPy, PyTorch) enquanto o software de produção consome os artefatos diretamente.

Próximos Passos para o seu Sistema de Inspeção

A modernização de sistemas industriais exige um equilíbrio fino entre confiabilidade operacional e inovação algorítmica. Atualizar ferramentas de PIG para suportar IA transforma relatórios de inspeção demorados em diagnósticos quase instantâneos.

Se a sua empresa opera softwares legados em .NET ou necessita implementar pipelines avançados de IA para análise sensorial e de integridade estrutural, entre em contato para uma consultoria técnica especializada. Vamos desenhar uma arquitetura de alta performance sob medida para o seu caso de uso.