Este artigo foi escrito para compor a documentação de justificativas das escolhas de algorítimos para o projeto de conclusão do EmbarcaTech, Rack Inteligente.

1 — Introdução à Detecção de Anomalias

A detecção de anomalias é uma técnica fundamental em sistemas inteligentes, especialmente em aplicações embarcadas, onde a capacidade de identificar comportamentos inesperados pode evitar falhas catastróficas, reduzir custos de manutenção e aumentar a confiabilidade de equipamentos. Em termos simples, uma anomalia é qualquer comportamento que se desvia significativamente do padrão habitual — seja uma vibração fora do normal em um transformador, um ruído inesperado em um motor, um pacote estranho em uma rede, ou mesmo uma leitura de sensor fora do perfil típico em um microcontrolador.

Existem três grandes abordagens estatísticas e de aprendizado de máquina amplamente usadas: Isolation Forest, One-Class SVM e PCA (Principal Component Analysis) aplicado para detecção de anomalias. Cada uma utiliza uma estratégia diferente no processo de modelagem, o que é particularmente útil quando queremos embarcar parte do processamento em microcontroladores ou realizar inferência em sistemas híbridos MCU+edge AI.

No contexto embarcado, a detecção de anomalias precisa de métodos eficientes, com baixo custo computacional e que funcionem bem mesmo quando há poucos dados rotulados. Por isso, os algoritmos apresentados neste artigo são especialmente adequados para aplicações como: predição de falhas, filtragem inteligente de dados, diagnóstico vibroacústico, análise de corrente, segurança cibernética embarcada e controle inteligente em malha fechada.

2 — Isolation Forest

O Isolation Forest é um algoritmo extremamente eficiente para detecção de anomalias porque trabalha de forma inversa aos métodos tradicionais: enquanto outros modelos tentam aprender o que é normal, o Isolation Forest tenta isolar o que é anômalo. Ele faz isso construindo diversas árvores aleatórias onde, a cada divisão, um subconjunto dos dados é particionado. Como pontos anômalos estão mais afastados do comportamento típico, eles tendem a ser isolados em poucas divisões — o que torna o método rápido e naturalmente escalável, inclusive para execução em hardware limitado.

Do ponto de vista matemático, cada árvore consiste em divisões recursivas sobre atributos escolhidos aleatoriamente. O número de divisões necessárias para isolar um dado ponto define um “caminho”, cuja média entre diversas árvores gera a pontuação de anomalia. Pontos com caminho médio curto são classificados como anômalos. Esse processo reduz significativamente a necessidade de modelos complexos e evita cálculos pesados como matrizes do tipo kernel, o que é uma vantagem para implementações embarcadas.

Em aplicações reais, o Isolation Forest é útil para detectar vibrações incomuns, oscilações de corrente fora do perfil, leituras inconsistentes de sensores, e até anomalias em tráfego de rede. Embora seja mais comum executar o treinamento fora do microcontrolador, é totalmente possível embarcar o processo de inferência, já que cada árvore pode ser representada como uma sequência de comparações simples — rápidas e leves para um Cortex-M7, ESP32 ou até um RP2040.

Exemplo em Python (Treinamento no PC, Inferência Portável para MCU)

from sklearn.ensemble import IsolationForest
import numpy as np

# Dados simulados: comportamento normal (cluster) + anomalias
rng = np.random.RandomState(42)
normal = 0.3 * rng.randn(200, 2)
anomalias = rng.uniform(low=-4, high=4, size=(10, 2))
dados = np.concatenate([normal, anomalias], axis=0)

# Treinamento
modelo = IsolationForest(contamination=0.05, random_state=42)
modelo.fit(dados)

# Inferência
teste = np.array([[0.1, 0.2], [3, 3]])  # normal vs anômalo
pred = modelo.predict(teste)

print(pred)  # saída: [1, -1]  → -1 = anomalia

from sklearn.ensemble import IsolationForest
import numpy as np

# Dados simulados: comportamento normal (cluster) + anomalias
rng = np.random.RandomState(42)
normal = 0.3 * rng.randn(200, 2)
anomalias = rng.uniform(low=-4, high=4, size=(10, 2))
dados = np.concatenate([normal, anomalias], axis=0)

# Treinamento
modelo = IsolationForest(contamination=0.05, random_state=42)
modelo.fit(dados)

# Inferência
teste = np.array([[0.1, 0.2], [3, 3]])  # normal vs anômalo
pred = modelo.predict(teste)

print(pred)  # saída: [1, -1]  → -1 = anomalia

Exemplo Embarcado (C) — Inferência de uma Árvore Simplificada

Este exemplo representa uma única árvore já convertida para C (deploy embarcado). Imagine que a árvore aprendida gerou as condições:

• if x₀ < 0.25 → vá para esquerda
• else → vá para direita
• se x₁ > 0.8 no nó seguinte → classifica como anomalia

// Estrutura simplificada de uma árvore do Isolation Forest
int isolation_tree_infer(float x0, float x1) {
    if (x0 < 0.25f) {
        if (x1 > 0.80f) {
            return -1; // anomalia
        } else {
            return 1;  // normal
        }
    } else {
        if (x1 > 1.2f) {
            return -1; // anomalia
        } else {
            return 1;  // normal
        }
    }
}

// Estrutura simplificada de uma árvore do Isolation Forest
int isolation_tree_infer(float x0, float x1) {
    if (x0 < 0.25f) {
        if (x1 > 0.80f) {
            return -1; // anomalia
        } else {
            return 1;  // normal
        }
    } else {
        if (x1 > 1.2f) {
            return -1; // anomalia
        } else {
            return 1;  // normal
        }
    }
}

Esse tipo de lógica pode ser executado facilmente em microcontroladores sem FPU ou com poucos recursos, bastando exportar as árvores do modelo e convertê-las em comparações encadeadas.

Seção 3 — One-Class SVM

O One-Class SVM é um método clássico e robusto para detecção de anomalias baseado em fronteiras de decisão. Enquanto um SVM convencional separa duas classes distintas, o One-Class SVM tenta aprender apenas a região onde os dados “normais” se concentram. A ideia central é encontrar uma superfície (hiperplano ou hiperfronteira) que envolva a maior parte do conjunto de dados, deixando pontos distantes dessa região como anômalos.

Matematicamente, ele busca maximizar a margem entre os dados e a origem no espaço transformado pelo kernel. Isso significa que ele depende fortemente da função kernel — normalmente o RBF (Radial Basis Function) — para projetar os dados em um espaço onde as fronteiras possam ser bem delimitadas. Essa característica o torna muito poderoso, porém mais custoso computacionalmente que o Isolation Forest, especialmente na fase de inferência, já que envolve cálculos exponenciais e somas ponderadas sobre vetores de suporte.

Em aplicações embarcadas, o One-Class SVM é mais adequado quando:

• o conjunto de dados normal é bem definido;
• há pouco ruído;
• a anomalia possui características sutis;
• os dados têm baixa dimensionalidade.

Treinar o modelo em um computador e exportar um SVM simplificado para microcontroladores é viável, desde que a quantidade de vetores de suporte seja pequena.

Exemplo em Python — Treinamento e Teste

from sklearn.svm import OneClassSVM
import numpy as np

# Dados normais
rng = np.random.RandomState(10)
normal = 0.2 * rng.randn(200, 2)

# Anomalias
anom = rng.uniform(low=-3, high=3, size=(10, 2))

# Treina o modelo
model = OneClassSVM(kernel="rbf", gamma=0.1, nu=0.05)
model.fit(normal)

# Testa
test = np.vstack([normal[:5], anom[:2]])
pred = model.predict(test)

print(pred)  # -1 indica anomalia

from sklearn.svm import OneClassSVM
import numpy as np

# Dados normais
rng = np.random.RandomState(10)
normal = 0.2 * rng.randn(200, 2)

# Anomalias
anom = rng.uniform(low=-3, high=3, size=(10, 2))

# Treina o modelo
model = OneClassSVM(kernel="rbf", gamma=0.1, nu=0.05)
model.fit(normal)

# Testa
test = np.vstack([normal[:5], anom[:2]])
pred = model.predict(test)

print(pred)  # -1 indica anomalia

Exemplo de Inferência Simplificada em C (Kernel RBF)

Este é um exemplo reduzido da fórmula RBF usada na inferência:

\[
K(x, v_i) = e^{-\gamma |x – v_i|^2}
\]

Onde cada \(v_i\) é um vetor de suporte.

A soma ponderada dos kernels determina a decisão final.

#include <math.h>

#define GAMMA 0.1f

// Vetor de suporte simplificado (exemplo)
float sv[][2] = {
    {0.1f,  0.2f},
    {-0.1f, 0.0f},
    {0.05f, 0.1f}
};

// Coeficientes alpha do SVM
float alpha[] = {0.5f, -0.3f, 0.8f};

float rbf(float x0, float x1, float v0, float v1) {
    float dx = x0 - v0;
    float dy = x1 - v1;
    float dist2 = dx*dx + dy*dy;
    return expf(-GAMMA * dist2);
}

int oneclass_svm_infer(float x0, float x1) {
    float sum = 0.0f;

    for (int i = 0; i < 3; i++) {
        sum += alpha[i] * rbf(x0, x1, sv[i][0], sv[i][1]);
    }

    return (sum > 0.0f) ? 1 : -1; // -1 = anomalia
}

#include <math.h>

#define GAMMA 0.1f

// Vetor de suporte simplificado (exemplo)
float sv[][2] = {
    {0.1f,  0.2f},
    {-0.1f, 0.0f},
    {0.05f, 0.1f}
};

// Coeficientes alpha do SVM
float alpha[] = {0.5f, -0.3f, 0.8f};

float rbf(float x0, float x1, float v0, float v1) {
    float dx = x0 - v0;
    float dy = x1 - v1;
    float dist2 = dx*dx + dy*dy;
    return expf(-GAMMA * dist2);
}

int oneclass_svm_infer(float x0, float x1) {
    float sum = 0.0f;

    for (int i = 0; i < 3; i++) {
        sum += alpha[i] * rbf(x0, x1, sv[i][0], sv[i][1]);
    }

    return (sum > 0.0f) ? 1 : -1; // -1 = anomalia
}

Esse tipo de código é viável em um Cortex-M4F ou M7 com FPU; para microcontroladores mais modestos, é possível pré-computar tabelas ou usar aproximações de exponencial (como fast exp).

4 — PCA Embarcado para Detecção de Anomalias

A Análise de Componentes Principais (PCA, Principal Component Analysis) é uma técnica matemática poderosa para redução de dimensionalidade e detecção de anomalias. Diferentemente do Isolation Forest e do One-Class SVM, o PCA não cria fronteiras ou árvores, mas transforma os dados originais em novas direções (componentes principais) que retêm a maior variância possível. Isso permite identificar padrões fundamentais e detectar pontos que se desviam significativamente desse padrão.

A ideia básica é decompor os dados em uma combinação linear de componentes ortogonais. Para detectar anomalias, observamos o erro de reconstrução: quando projetamos um ponto nos componentes principais e tentamos reconstruí-lo, pontos normais tendem a ter um erro pequeno, enquanto pontos anômalos produzem erros muito maiores. Essa abordagem é extremamente eficiente para sistemas embarcados porque permite pré-calcular toda a estrutura no computador e embarcar apenas duas operações: multiplicação de matrizes e cálculo de erro.

Matematicamente, se ( x ) é o vetor original e ( W ) é a matriz dos autovetores (componentes), o processo é:

1. Projeção no espaço PCA:

\[
z = W^T (x – \mu)
\]

2. Reconstrução aproximada:

\[
\hat{x} = Wz + \mu
\]

3. Erro de reconstrução:

\[
e = | x – \hat{x} |^2
\]

Se o erro (e) ultrapassar um limiar definido, classificamos como anomalia.

Essa abordagem é usada em vibração, acústica, qualidade de energia e em sistemas industriais embarcados com pouco poder computacional, pois envolve apenas multiplicações e somas — operações extremamente eficientes em microcontroladores.

Exemplo em Python — PCA para Identificar Anomalias

import numpy as np
from sklearn.decomposition import PCA

# Dados normais
rng = np.random.RandomState(1)
normal = rng.normal(0, 0.3, size=(300, 3))

# Anomalias
anom = rng.uniform(-3, 3, size=(10, 3))
dados = np.vstack([normal, anom])

# PCA com 2 componentes
pca = PCA(n_components=2)
pca.fit(normal)

# Função de erro de reconstrução
def reconstruction_error(x):
    z = pca.transform([x])
    x_hat = pca.inverse_transform(z)
    return np.linalg.norm(x - x_hat)

# Testando
for i in range(5):
    print("Erro:", reconstruction_error(dados[i]))

import numpy as np
from sklearn.decomposition import PCA

# Dados normais
rng = np.random.RandomState(1)
normal = rng.normal(0, 0.3, size=(300, 3))

# Anomalias
anom = rng.uniform(-3, 3, size=(10, 3))
dados = np.vstack([normal, anom])

# PCA com 2 componentes
pca = PCA(n_components=2)
pca.fit(normal)

# Função de erro de reconstrução
def reconstruction_error(x):
    z = pca.transform([x])
    x_hat = pca.inverse_transform(z)
    return np.linalg.norm(x - x_hat)

# Testando
for i in range(5):
    print("Erro:", reconstruction_error(dados[i]))

Você perceberá que os erros das amostras anômalas são muito maiores.

Exemplo Embarcado (C) — Inferência PCA Simplificada

Os autovetores e a média já foram calculados no PC. Agora, usamos apenas matrizes pequenas no microcontrolador:

#include <math.h>

// Matriz de autovetores (2 componentes, 3 dimensões)
float W[2][3] = {
    {0.58f, 0.57f, 0.58f},
    {-0.72f, 0.01f, 0.69f}
};

// Média dos dados (calculada previamente)
float mu[3] = {0.02f, -0.01f, 0.03f};

float reconstruction_error(float x[3]) {
    float x_centered[3];
    for (int i = 0; i < 3; i++)
        x_centered[i] = x[i] - mu[i];

    // Projeção
    float z[2] = {0};
    for (int i = 0; i < 2; i++)
        for (int j = 0; j < 3; j++)
            z[i] += W[i][j] * x_centered[j];

    // Reconstrução
    float x_hat[3] = {0};
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 2; j++)
            x_hat[i] += W[j][i] * z[j];

    for (int i = 0; i < 3; i++)
        x_hat[i] += mu[i];

    // Erro
    float e = 0;
    for (int i = 0; i < 3; i++) {
        float d = x[i] - x_hat[i];
        e += d * d;
    }

    return e;
}

#include <math.h>

// Matriz de autovetores (2 componentes, 3 dimensões)
float W[2][3] = {
    {0.58f, 0.57f, 0.58f},
    {-0.72f, 0.01f, 0.69f}
};

// Média dos dados (calculada previamente)
float mu[3] = {0.02f, -0.01f, 0.03f};

float reconstruction_error(float x[3]) {
    float x_centered[3];
    for (int i = 0; i < 3; i++)
        x_centered[i] = x[i] - mu[i];

    // Projeção
    float z[2] = {0};
    for (int i = 0; i < 2; i++)
        for (int j = 0; j < 3; j++)
            z[i] += W[i][j] * x_centered[j];

    // Reconstrução
    float x_hat[3] = {0};
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 2; j++)
            x_hat[i] += W[j][i] * z[j];

    for (int i = 0; i < 3; i++)
        x_hat[i] += mu[i];

    // Erro
    float e = 0;
    for (int i = 0; i < 3; i++) {
        float d = x[i] - x_hat[i];
        e += d * d;
    }

    return e;
}

Essa função pode ser usada diretamente em qualquer microcontrolador, bastando definir um limiar adequado de erro para classificar anomalias.

5 — Comparação Entre Métodos e Aplicações Práticas

A escolha entre Isolation Forest, One-Class SVM e PCA depende profundamente do tipo de aplicação, da quantidade de dados disponíveis, da complexidade do sinal e principalmente das restrições computacionais típicas de sistemas embarcados. Cada método tem pontos fortes e limitações, e compreender essas nuances permite projetar sistemas mais eficientes e robustos.

O Isolation Forest é, em geral, o mais eficiente para dados de alta dimensionalidade e cenários onde as anomalias tendem a ser valores extremos ou isolados. Sua natureza baseada em árvores o torna leve na etapa de inferência, já que consiste em uma sequência de comparações simples — ideal em MCUs como RP2040, ESP32-C3/S3 e Cortex-M. Entretanto, sua interpretação pode ser menos intuitiva do que a de modelos lineares ou baseados em geometria. Já o One-Class SVM apresenta excelente desempenho em situações onde os dados normais são bem estruturados e a anomalia é sutil, porém o custo computacional do kernel RBF e a dependência da quantidade de vetores de suporte tornam a inferência mais cara. É um candidato natural quando a inferência ocorre em edge devices mais robustos ou quando se usa aceleradores como o NPU do ESP32-P4, HPM6xxx, STM32N6 ou NPUs externos.

O PCA se destaca em contextos embarcados devido à sua simplicidade computacional e capacidade de reduzir drasticamente a dimensionalidade dos dados, mantendo a essência do comportamento normal. Em aplicações industriais, como vibração e acústica, onde há forte redundância entre sinais, o PCA é extremamente eficaz em capturar esse padrão e detectar desvios, principalmente quando se usa o erro de reconstrução como métrica. Seu treinamento é mais pesado, mas a inferência exige apenas multiplicações de matrizes, algo trivial para um Cortex-M7, M33, ESP32-S3 ou mesmo um RP2040.

Aplicações práticas em sistemas embarcados

• Manutenção preditiva de motores e transformadores
  PCA e Isolation Forest são largamente utilizados para vibrações e ruídos mecânicos. PCA detecta sutis alterações espectrais, enquanto Isolation Forest identifica comportamentos fora do padrão global.
• Segurança cibernética embarcada
  Em gateways IoT e sistemas críticos, One-Class SVM é eficiente para detectar tráfego malicioso que difere levemente do comportamento normal.
• Sensores de ambiente (temperatura, pressão, corrente, aceleração)
  Isolation Forest e PCA executam facilmente em MCUs com pouco recurso, monitorando continuamente leituras de sensores.
• Detecção de falhas em robôs, veículos autônomos e drones
  PCA pode identificar alterações no perfil de movimento; Isolation Forest detecta leituras inesperadas de IMUs, LiDARs ou encoders.
• Sistemas embarcados de análise de energia elétrica
  PCA é excelente para detectar distorções e harmônicos incomuns; SVM é útil quando há pouca variabilidade na rede elétrica monitorada.

Seção 6 — Conclusão e Boas Práticas de Implementação em Sistemas Embarcados

A detecção de anomalias é uma peça central para sistemas embarcados modernos, especialmente aqueles voltados à manutenção preditiva, diagnóstico inteligente, proteção de equipamentos e segurança operacional. Isolation Forest, One-Class SVM e PCA representam três abordagens complementares que oferecem um conjunto sólido de ferramentas para identificar comportamentos inesperados em tempo real.

Quando bem aplicados, esses algoritmos permitem antecipar falhas mecânicas, detectar desvios elétricos, capturar padrões incomuns em vibração/acústica, identificar leituras suspeitas de sensores ou mesmo reforçar a segurança cibernética em ambientes IoT/IIoT — tudo isso com execução eficiente em microcontroladores acessíveis.

Do ponto de vista prático, algumas recomendações ajudam a garantir que o sistema funcione de maneira consistente:

A primeira boa prática é sempre realizar o treinamento dos modelos fora do microcontrolador, preferencialmente em uma estação de trabalho ou servidor dedicado. Os dados coletados devem ser limpos, normalizados e analisados para garantir que representam adequadamente o “comportamento normal” do sistema. Após o treinamento, os parâmetros essenciais — árvores, vetores de suporte ou autovetores — devem ser exportados para o firmware em representações compactas.

Outra recomendação importante é monitorar os limites numéricos. Em MCUs, operações com ponto flutuante podem gerar erros acumulados; por isso, quando possível, considere quantização, uso de ponto fixo, ou tabelas de aproximação para funções como exponencial (no caso do SVM). Em sistemas de baixa potência, evitar funções matemáticas custosas ajuda a manter a latência e o consumo energético sob controle.

A terceira prática consiste em calibrar limiares de detecção dinamicamente. Em vez de usar um limiar fixo, o sistema pode calcular estatísticas ao longo do tempo — como média móvel ou desvio padrão — para adaptar-se a mudanças naturais no ambiente. A detecção de anomalias fica mais robusta em ambientes ruidosos ou sujeitos a variações não controladas.

Por fim, é essencial validar o sistema com dados reais do ambiente final. Testes em bancada podem não refletir ruídos, variações térmicas, jitter dos sensores ou interferências eletromagnéticas típicas de campo. O processo de testes deve incluir cenários-limite para garantir que o sistema responde não apenas ao “anomalo ideal”, mas também a desvios graduais e quase imperceptíveis — aqueles que, na prática, causam a maior parte das falhas industriais.

The post Detecção de Anomalias em Sistemas Embarcados: Isolation Forest, One-Class SVM e PCA com Exemplos Práticos first appeared on MCU & FPGA.

Neste cenário, as Redes Neurais Convolucionais (Convolutional Neural Networks – CNNs) vêm ganhando espaço como uma das abordagens mais eficazes para analisar dados complexos como imagens, espectros de frequência e séries temporais com múltiplas variáveis. Originadas no campo da visão computacional, as CNNs evoluíram para lidar com diversos tipos de sinais, incluindo os acústicos e vibracionais. Sua capacidade de extrair automaticamente características relevantes (features) do sinal as torna ideais para tarefas de classificação, detecção de padrões e diagnóstico.

O presente artigo tem como objetivo apresentar, de forma progressiva e acessível, desde os fundamentos básicos até os conceitos avançados das CNNs, contextualizando sua aplicação na análise de sinais provenientes de sensores acústicos acoplados a transformadores. O texto também detalha como essas redes foram integradas ao simulador desenvolvido no projeto “Análise da Saúde de Transformadores com Base em Ruídos de Magnetostricção”, disponível publicamente no repositório GitHub: rapporttecnologia/simulador_magnetostriccao.

Ao longo do artigo, serão abordados conceitos essenciais de pré-processamento de sinais, arquiteturas de redes neurais, comparação com outros modelos de aprendizado profundo e técnicas específicas para treinar e avaliar CNNs aplicadas a dados vibracionais. A proposta é proporcionar uma compreensão sólida do papel das CNNs neste domínio, estimulando sua adoção em sistemas embarcados e aplicações industriais reais.

O que é uma Rede Neural Convolucional (CNN)?

Redes Neurais Convolucionais (CNNs, do inglês Convolutional Neural Networks) são um tipo específico de rede neural artificial projetada para lidar com dados estruturados espacialmente ou temporalmente, como imagens, sinais de áudio e séries temporais multicanais. Elas se destacam por sua habilidade em extrair automaticamente padrões e características relevantes dos dados, dispensando a necessidade de engenharia manual de atributos — tarefa que, tradicionalmente, exigia profundo conhecimento do domínio de aplicação.

A principal diferença entre uma CNN e uma rede neural densa (ou totalmente conectada) reside na operação de convolução. Em vez de conectar cada neurônio de uma camada a todos os neurônios da camada anterior, a CNN utiliza filtros ou kernels que percorrem localmente os dados de entrada, capturando padrões locais com eficiência. Essa operação simula, de certo modo, o funcionamento da visão em sistemas biológicos, onde diferentes regiões do campo visual são processadas de forma independente e combinadas em níveis superiores de abstração.

Essas redes são compostas por blocos fundamentais: camadas convolucionais, responsáveis por aplicar os filtros e extrair features locais; camadas de ativação, que introduzem não linearidade no sistema (como a função ReLU); camadas de pooling, que reduzem a dimensionalidade e extraem características mais robustas; e camadas totalmente conectadas, que realizam a classificação ou regressão com base nos features aprendidos.

Apesar de serem amplamente conhecidas por sua aplicação em reconhecimento de imagens, as CNNs também se mostraram extremamente eficientes na análise de sinais 1D — como os ruídos de magnetostricção captados por sensores —, desde que os dados sejam corretamente estruturados como vetores temporais ou representações espectrais (ex.: espectrogramas).

No contexto deste artigo e do simulador em desenvolvimento, as CNNs são treinadas para identificar padrões em sinais acústicos complexos, permitindo classificar o estado de saúde dos transformadores com base na vibração que emitem. Isso representa um avanço importante frente a técnicas tradicionais de análise espectral manual ou filtros lineares, especialmente quando se trata de ruídos de baixa amplitude ou de difícil interpretação visual.

O que é uma Rede Neural Convolucional (CNN)?

Redes Neurais Convolucionais (CNNs, do inglês Convolutional Neural Networks) são um tipo específico de rede neural artificial projetada para lidar com dados estruturados espacialmente ou temporalmente, como imagens, sinais de áudio e séries temporais multicanais. Elas se destacam por sua habilidade em extrair automaticamente padrões e características relevantes dos dados, dispensando a necessidade de engenharia manual de atributos — tarefa que, tradicionalmente, exigia profundo conhecimento do domínio de aplicação.

A principal diferença entre uma CNN e uma rede neural densa (ou totalmente conectada) reside na operação de convolução. Em vez de conectar cada neurônio de uma camada a todos os neurônios da camada anterior, a CNN utiliza filtros ou kernels que percorrem localmente os dados de entrada, capturando padrões locais com eficiência. Essa operação simula, de certo modo, o funcionamento da visão em sistemas biológicos, onde diferentes regiões do campo visual são processadas de forma independente e combinadas em níveis superiores de abstração.

Essas redes são compostas por blocos fundamentais: camadas convolucionais, responsáveis por aplicar os filtros e extrair features locais; camadas de ativação, que introduzem não linearidade no sistema (como a função ReLU); camadas de pooling, que reduzem a dimensionalidade e extraem características mais robustas; e camadas totalmente conectadas, que realizam a classificação ou regressão com base nos features aprendidos.

Apesar de serem amplamente conhecidas por sua aplicação em reconhecimento de imagens, as CNNs também se mostraram extremamente eficientes na análise de sinais 1D — como os ruídos de magnetostricção captados por sensores —, desde que os dados sejam corretamente estruturados como vetores temporais ou representações espectrais (ex.: espectrogramas).

No contexto deste artigo e do simulador em desenvolvimento, as CNNs são treinadas para identificar padrões em sinais acústicos complexos, permitindo classificar o estado de saúde dos transformadores com base na vibração que emitem. Isso representa um avanço importante frente a técnicas tradicionais de análise espectral manual ou filtros lineares, especialmente quando se trata de ruídos de baixa amplitude ou de difícil interpretação visual.

Entendendo a Função ReLU

A função ReLU (Rectified Linear Unit – Unidade Linear Retificada) é uma função de ativação amplamente utilizada em redes neurais profundas, especialmente em Redes Neurais Convolucionais (CNNs). Sua popularidade se deve à simplicidade computacional e à eficácia em acelerar o treinamento e melhorar a convergência de modelos profundos.

Matematicamente, a ReLU é definida pela seguinte equação: f(x)=max⁡(0,x)f(x) = \max(0, x)f(x)=max(0,x)

Ou seja, se o valor de entrada xxx for positivo, ele é mantido; se for negativo, é convertido em zero. Esse comportamento cria uma espécie de filtro não linear que elimina valores negativos, preservando apenas os sinais “ativos”.

Por que ReLU é importante?

Nas CNNs, cada filtro convolucional gera uma saída que representa a resposta a certos padrões locais no dado de entrada (por exemplo, bordas em uma imagem, ou frequências específicas em um espectrograma). Após essa operação, a ReLU é aplicada para reforçar a presença desses padrões (valores positivos) e suprimir sinais que não contribuem significativamente (valores negativos).

Além disso, a ReLU evita problemas como o desvanecimento do gradiente (vanishing gradient), comum em funções sigmoides ou tanh, permitindo que os gradientes se propaguem com maior estabilidade durante o treinamento. Isso contribui para redes mais profundas e precisas.

Exemplo prático em sinais

Imagine que uma CNN está processando o espectro acústico de um transformador. Algumas regiões podem apresentar padrões de vibração característicos de falhas incipientes. A convolução aplicada sobre essas regiões produzirá valores maiores, enquanto regiões sem relevância (como ruído de fundo) gerarão valores próximos ou abaixo de zero. Ao aplicar a ReLU, a rede preserva apenas os padrões significativos, facilitando a detecção de anomalias.

Visualização

Gráfico da função ReLU:

O gráfico mostra claramente que ReLU é zero para qualquer entrada negativa e cresce linearmente para entradas positivas, o que a torna ideal para ativar seletivamente os neurônios relevantes.

Espectrograma: Visualizando o Sinal no Tempo e na Frequência

O espectrograma é uma representação visual da densidade espectral de potência de um sinal ao longo do tempo. Diferentemente da Transformada de Fourier tradicional, que mostra como a energia do sinal está distribuída em diferentes frequências, o espectrograma adiciona uma dimensão temporal, permitindo observar como essas frequências evoluem ao longo do tempo.

Essa ferramenta é extremamente útil para análise de sinais não estacionários, como os ruídos de magnetostricção em transformadores, que podem apresentar variações abruptas ou padrões periódicos característicos de falhas mecânicas ou elétricas.

Como é calculado um espectrograma?

O espectrograma é obtido por meio da Short-Time Fourier Transform (STFT) — a Transformada de Fourier de Curta Duração. A ideia é dividir o sinal original em pequenas janelas de tempo (chamadas janelas de análise), aplicar a Transformada de Fourier em cada uma delas e, em seguida, empilhar os espectros gerados em sequência.

O resultado é uma matriz bidimensional onde:

• O eixo horizontal representa o tempo (posição da janela),
• O eixo vertical representa as frequências,
• As cores (ou intensidades) representam a amplitude ou energia associada a cada frequência naquele instante.

Matematicamente, a STFT é definida como: \[X(t, f) = \int_{-\infty}^{\infty} x(\tau) w(\tau – t) e^{-j2\pi f \tau} d\tau\]

onde:

• \(x(\tau)\) é o sinal original,
• \(w(\tau – t)\) é a janela centrada no tempo t,
• f é a frequência de interesse.

Aplicação no projeto

No projeto de análise da saúde de transformadores, os sinais acústicos captados pelos sensores são primeiro convertidos em espectrogramas. Esses espectrogramas são tratados como imagens, o que torna possível o uso de CNNs para detectar padrões específicos, como assinaturas de falhas, arcos elétricos, ou vibrações anormais. Essa abordagem é especialmente vantajosa, pois facilita a generalização do modelo para novos tipos de anomalias e diferentes equipamentos.

Além disso, o espectrograma permite destacar componentes harmônicas, ruídos de fundo, variações sazonais ou transitórias — todos elementos difíceis de isolar em análises puramente temporais ou espectrais.

Comparações entre CNNs e Outras Arquiteturas de Redes Neurais

Embora as Redes Neurais Convolucionais (CNNs) sejam extremamente eficazes na análise de dados com estrutura espacial ou temporal, elas não são a única opção. Outras arquiteturas, como Redes Neurais Densas (MLPs), Redes Neurais Recorrentes (RNNs), LSTM (Long Short-Term Memory) e, mais recentemente, Transformers, também são utilizadas para tarefas envolvendo séries temporais, sinais e classificação de padrões. Cada uma possui vantagens e limitações específicas, que merecem ser exploradas no contexto da análise de ruídos por magnetostricção.

Redes Neurais Densas (MLPs)

As redes densas ou Multilayer Perceptrons conectam cada neurônio de uma camada à totalidade da camada anterior. Elas funcionam bem para dados tabulares ou vetores fixos, mas não conseguem explorar relações locais em sinais contínuos. Por exemplo, ao analisar um espectrograma, uma MLP trataria cada ponto como independente, ignorando a estrutura temporal e espectral do dado. Isso leva à perda de contexto e aumento exponencial do número de parâmetros.

Redes Recorrentes (RNNs) e LSTM

As redes recorrentes, como as RNNs e suas variantes LSTM, foram projetadas para lidar com sequências temporais. Elas mantêm uma espécie de “memória” interna que permite capturar dependências ao longo do tempo. Embora sejam boas para tarefas como previsão de séries temporais ou transcrição de áudio, apresentam limitações para sinais muito longos ou com variações espaciais complexas, como os espectrogramas gerados no projeto. Além disso, seu treinamento é mais demorado e sensível a problemas como explosão ou desaparecimento do gradiente.

Transformers

Arquiteturas baseadas em Transformers surgiram como alternativa às RNNs, utilizando mecanismos de atenção para capturar relações de longo alcance em dados sequenciais. Embora extremamente eficazes em NLP (Processamento de Linguagem Natural), sua aplicação em sinais acústicos ainda está em fase de experimentação e exige grande poder computacional. Em sistemas embarcados, seu uso é limitado devido ao alto custo de inferência.

Vantagens das CNNs no projeto

Em contrapartida, as CNNs se mostram altamente adequadas para a tarefa de classificar espectrogramas de ruídos de transformadores. Elas exigem menos recursos computacionais, são mais fáceis de treinar, e capturam automaticamente padrões locais (por exemplo, harmônicos ou transientes). Essa capacidade de extração de features espaciais torna as CNNs ideais para transformar um problema de análise de sinal em um problema de visão computacional — um campo amplamente dominado por essa arquitetura.

No projeto “Análise da Saúde de Transformadores com Base em Ruídos de Magnetostricção”, a CNN supera as demais abordagens pela combinação de desempenho, velocidade de inferência e facilidade de visualização dos resultados — fatores essenciais para sua aplicação em tempo real e em ambientes industriais.

Transformers como Alternativa às CNNs na Análise de Sinais

Os Transformers representam uma arquitetura de rede neural revolucionária originalmente concebida para o processamento de linguagem natural (NLP), mas que rapidamente se estendeu para áreas como visão computacional, áudio e análise de séries temporais. Seu principal diferencial reside no mecanismo de atenção — mais especificamente, a atenção auto-regressiva (self-attention), que permite à rede aprender relações complexas e de longo alcance dentro de uma sequência de dados.

Como funcionam os Transformers?

Diferentemente das CNNs, que processam dados de forma local (janela por janela, filtro por filtro), os Transformers consideram simultaneamente todas as partes da entrada. Isso significa que, ao analisar um espectrograma ou uma série temporal, um Transformer pode, teoricamente, correlacionar eventos distantes no tempo ou no espaço, o que é altamente vantajoso para padrões dispersos — como falhas intermitentes ou ressonâncias harmônicas sutis nos sinais de magnetostricção.

O componente chave é o bloco de atenção: \[\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V\]

onde Q (queries), K (keys) e V (values) são derivados da entrada. A saída pondera as diferentes partes do sinal com base na relevância mútua entre elas.

Vantagens no projeto

• Capacidade de capturar relações de longo alcance entre trechos do sinal, o que pode ser útil para detectar padrões que se repetem de forma espaçada.
• Modelagem temporal mais precisa que CNNs puras, especialmente em séries temporais não estacionárias.
• Flexibilidade multimodal — Transformers podem ser adaptados para analisar simultaneamente espectrogramas, dados de sensores e até metadados (como horário ou temperatura).

Desvantagens no projeto

• Alta demanda computacional: Transformers requerem significativamente mais poder de processamento, tanto para treinamento quanto para inferência. Isso ocorre porque o mecanismo de atenção quadrático em relação ao número de entradas exige mais memória e ciclos de CPU/GPU.
• Treinamento mais sensível a overfitting, exigindo bases de dados maiores e técnicas mais avançadas de regularização.
• Inferência mais lenta, o que compromete a aplicação embarcada em dispositivos como Raspberry Pi ou microcontroladores com TensorFlow Lite.

Comparativo prático com CNN

Impacto no projeto

No simulador de diagnóstico por magnetostricção disponível em rapporttecnologia/simulador_magnetostriccao, o uso de CNNs permite a execução do modelo em tempo real em sistemas com baixo consumo energético, como Raspberry Pi, Jetson Nano ou até mesmo microcontroladores avançados com suporte a inferência neural (ex.: STM32N6 com acelerador ST-NN).

Já os Transformers, embora promissores, ainda são mais adequados para execução em estações de trabalho com GPU (ex.: Nvidia RTX, Google Colab) ou servidores em nuvem, o que limita sua aplicação em cenários de campo onde recursos são restritos. Sua adoção pode ser interessante em etapas offline do projeto, como na análise posterior de grandes volumes de dados coletados, ou em um sistema híbrido onde a CNN atua embarcada e o Transformer opera em segundo plano para casos complexos.

Preparação do Sinal para Análise com CNNs

A eficácia de uma Rede Neural Convolucional depende, em grande parte, da qualidade da entrada fornecida. No caso da análise de ruídos de magnetostricção captados por sensores acústicos, é essencial transformar esses sinais brutos em representações que preservem as características relevantes para a detecção de falhas. Este processo envolve diversas etapas de pré-processamento e conversão, até que os dados estejam prontos para serem utilizados no treinamento ou inferência com CNNs.

1. Aquisição do Sinal

O primeiro passo é a aquisição dos dados acústicos com amostragem adequada. No projeto, utilizam-se microfones piezoelétricos ou MEMS de alta sensibilidade, conectados a microcontroladores com ADC (Conversor Analógico-Digital) de alta resolução. A frequência de amostragem recomendada deve ser ao menos o dobro da maior frequência esperada no sinal (teorema de Nyquist), o que normalmente significa 20 kHz ou mais para ruídos industriais.

Exemplo de código para captura com ADC + DMA no RP2040 ou STM32:

// pseudo-código simplificado
adc_config();
dma_config();
start_sampling();

2. Filtragem e Normalização

Uma vez captado, o sinal pode conter ruídos externos, como interferência elétrica ou vibração ambiental. A filtragem passa-baixa, passa-banda ou notch (anti-ruído) pode ser aplicada para isolar as frequências de interesse. Além disso, a normalização do sinal para o intervalo [0,1] ou [-1,1] garante que o treinamento da rede não seja afetado por amplitudes desbalanceadas.

# Exemplo de normalização em Python
signal = signal / np.max(np.abs(signal))

3. Segmentação Temporal

O sinal contínuo é então dividido em janelas (segmentos) fixos de tempo, geralmente entre 0,5s a 2s. Cada janela representará uma amostra independente para o treinamento da CNN. Isso facilita a criação de datasets balanceados, inclusive com múltiplos exemplos por gravação de campo.

# Segmentação do sinal
window_size = 2048
segments = [signal[i:i+window_size] for i in range(0, len(signal)-window_size, step)]

4. Conversão em Espectrogramas

Cada segmento é transformado em um espectrograma, utilizando a STFT (Short-Time Fourier Transform) ou a escala de Mel (no caso de sinais perceptivos). O espectrograma gerado é então salvo como uma imagem (em tons de cinza ou RGB), compatível com a entrada de CNNs.

import matplotlib.pyplot as plt
from scipy.signal import spectrogram

f, t, Sxx = spectrogram(segment, fs=fs)
plt.pcolormesh(t, f, 10 * np.log10(Sxx))
plt.axis('off')
plt.savefig("sample.png", bbox_inches='tight', pad_inches=0)

5. Criação dos Conjuntos de Dados

As imagens geradas são organizadas em diretórios por classes: por exemplo, normal/, falha_leve/, falha_grave/. Essa estrutura é compatível com funções de carregamento automático de imagens em bibliotecas como TensorFlow, Keras e PyTorch, que assumem um modelo de classificação supervisada.

dataset/
├── normal/
│   ├── 001.png
│   ├── 002.png
├── falha_leve/
│   ├── 001.png
│   ├── 002.png

Treinando uma CNN para Diagnóstico de Transformadores

Após o preparo do sinal e conversão dos segmentos em espectrogramas, o próximo passo é treinar uma Rede Neural Convolucional (CNN) capaz de classificar automaticamente o estado dos transformadores com base nos padrões acústicos. Essa etapa envolve a definição da arquitetura da rede, o carregamento dos dados, o treinamento supervisionado e a validação dos resultados.

1. Bibliotecas e Ambiente

Para esse processo, as bibliotecas mais indicadas são:

• TensorFlow/Keras – para construção e treinamento do modelo;
• NumPy e Matplotlib – para manipulação de dados e visualização;
• scikit-learn – para métricas de avaliação.

O ambiente pode ser um Jupyter Notebook, Google Colab (com GPU ativada), ou uma estação de trabalho com Python ≥ 3.8.

bashCopiarEditarpip install tensorflow numpy matplotlib scikit-learn

2. Carregando os Dados de Imagem

Assumindo que os espectrogramas estejam organizados em diretórios por classe, é possível utilizar ImageDataGenerator do Keras para leitura automática e normalização das imagens.

from tensorflow.keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(validation_split=0.2, rescale=1./255)

train_generator = datagen.flow_from_directory(
    'dataset/',
    target_size=(128, 128),
    batch_size=32,
    class_mode='categorical',
    subset='training'
)

val_generator = datagen.flow_from_directory(
    'dataset/',
    target_size=(128, 128),
    batch_size=32,
    class_mode='categorical',
    subset='validation'
)

3. Definindo a Arquitetura da CNN

Aqui está um exemplo básico de CNN adequada para espectrogramas monocromáticos 128×128:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout

model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(128, 128, 3)),
    MaxPooling2D(2, 2),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D(2, 2),
    Flatten(),
    Dense(128, activation='relu'),
    Dropout(0.5),
    Dense(train_generator.num_classes, activation='softmax')
])

4. Compilando e Treinando o Modelo

model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

history = model.fit(
    train_generator,
    epochs=20,
    validation_data=val_generator
)

Durante o treinamento, o modelo ajusta os filtros convolucionais para reconhecer padrões específicos de cada classe (ruído normal, falhas leves, falhas críticas), aprendendo diretamente dos dados sem necessidade de rotinas manuais de extração de features.

5. Avaliação e Interpretação dos Resultados

Após o treinamento, os resultados podem ser avaliados com base em métricas como acurácia, matriz de confusão e curva ROC. O modelo pode ser salvo em formato .h5 para inferência posterior, inclusive embarcada.

model.save("modelo_transformador.h5")

Implementando a Inferência em Sistemas Embarcados

Após o treinamento da Rede Neural Convolucional (CNN) em um ambiente de alto desempenho (como uma estação com GPU ou Google Colab), o próximo desafio é implementar o modelo em dispositivos embarcados que realizam a inferência localmente, como Raspberry Pi, Jetson Nano, ESP32 com coprocessador, ou MCUs STM32 com suporte a unidades neurais. Essa etapa exige a conversão e otimização do modelo, visando reduzir seu tamanho, consumo de energia e tempo de resposta.

1. Conversão para TensorFlow Lite

O TensorFlow Lite (TFLite) é uma versão compacta do TensorFlow voltada para inferência em dispositivos embarcados. Ele permite converter o modelo .h5 treinado em um formato binário leve (.tflite), que pode ser carregado diretamente no dispositivo.

import tensorflow as tf

# Carregar modelo treinado
model = tf.keras.models.load_model('modelo_transformador.h5')

# Converter para TFLite
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

# Salvar em disco
with open('modelo_transformador.tflite', 'wb') as f:
    f.write(tflite_model)

Opcionalmente, é possível aplicar técnicas de quantização (como float16, int8) para reduzir ainda mais o tamanho do modelo e acelerar sua execução:

pythonCopiarEditarconverter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model_quant = converter.convert()

2. Inferência em Raspberry Pi ou Jetson

Em dispositivos Linux embarcados como o Raspberry Pi 4, a inferência com TFLite pode ser feita com Python ou C++. Bibliotecas como tflite_runtime ou o próprio TensorFlow permitem carregar o modelo e executar a classificação.

import numpy as np
import tensorflow as tf
from PIL import Image

interpreter = tf.lite.Interpreter(model_path="modelo_transformador.tflite")
interpreter.allocate_tensors()

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Pré-processar imagem
img = Image.open("espectrograma.png").resize((128, 128))
input_data = np.expand_dims(np.array(img, dtype=np.float32) / 255.0, axis=0)

# Inferência
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()
output = interpreter.get_tensor(output_details[0]['index'])

3. Execução em Microcontroladores

Para MCUs como os da família STM32N6 (com acelerador ST-Neural ART) ou até RP2040 com interfaces externas, é possível usar o TensorFlow Lite for Microcontrollers. Nesse caso, o modelo é convertido para um array C/C++ com xxd ou xxd -i:

bashCopiarEditarxxd -i modelo_transformador.tflite > modelo.h

E o modelo é embutido no firmware:

#include "modelo.h"
// Código para inicializar o interpretador e executar a inferência

A biblioteca TFLite-Micro cuida da execução do modelo mesmo sem sistema operacional, embora com algumas limitações: apenas quantização int8, sem suporte a camadas complexas (ex: convoluções dilatadas).

4. Impactos e Otimizações

• Velocidade: A inferência com TFLite é rápida (tipicamente < 100ms) em Raspberry Pi, e até < 10ms com GPU/Coprocessador.
• Consumo: O uso local evita comunicação contínua com servidores, reduzindo energia e melhorando privacidade.
• Custo: Dispositivos baratos (< R$ 300) podem rodar o modelo com precisão próxima ao ambiente de treinamento.
• Escalabilidade: A abordagem permite replicar sensores autônomos em diversos pontos da rede elétrica.

Conclusão

A aplicação de Redes Neurais Convolucionais (CNNs) à análise de ruídos de magnetostricção representa um avanço significativo no diagnóstico não invasivo da saúde de transformadores. Ao transformar sinais acústicos em representações espectrais, e posteriormente aplicar técnicas de aprendizado profundo, torna-se possível detectar padrões sutis que indicam falhas mecânicas ou elétricas incipientes, com precisão superior às abordagens tradicionais.

Neste artigo, percorremos desde os fundamentos das CNNs até as suas aplicações práticas no projeto “Análise da Saúde de Transformadores com Base em Ruídos de Magnetostricção”. Discutimos em detalhes o processo de preparação do sinal, a construção do espectrograma, o treinamento supervisionado da rede, e sua posterior implementação em sistemas embarcados. Também comparamos, de forma crítica, as CNNs com outras arquiteturas como Transformers, destacando seus pontos fortes e limitações no contexto de execução em tempo real e em ambientes com recursos restritos.

A integração com o simulador disponível em rapporttecnologia/simulador_magnetostriccao permite que pesquisadores e engenheiros explorem e reproduzam os resultados obtidos, promovendo reprodutibilidade científica e abrindo espaço para otimizações contínuas.

Ao democratizar o uso de inteligência artificial em sistemas de monitoramento industriais, especialmente em dispositivos de baixo custo, este trabalho contribui não apenas para o avanço tecnológico, mas também para a sustentabilidade e confiabilidade da infraestrutura elétrica. Com a contínua evolução das arquiteturas de redes neurais, espera-se que soluções ainda mais eficientes e precisas estejam ao alcance de projetos similares nos próximos anos.

The post CNNs na Análise de Ruídos em Transformadores com IA first appeared on MCU & FPGA.