Implementação Técnica

Desenvolvemos um sistema para idnetificação de pontos de superaquecimento em redes elétricas utilizando modelos YOLOv8 e YOLOv11. O sistema processa imagens térmicas contendo uma única classe de detecção: "Superaquecimento".

Configuração do Ambiente

# Arquivo de configuração datasets.yaml
path: /dados/linhas_transmissao/
train: imagens/treino
val: imagens/validacao
classes: ['Superaquecimento']

Treinamento do Modelo

Exceutar o script principal de treinamento após configurar os caminhos do dataset. Monitorar métricas no diretório de resultados:

python treinar_modelo.py --config config.yaml

Interface Web com Gradio

import gradio as gr
from ultralytics import YOLO

modelo = YOLO("melhores_pesos.pt")

def predizer(img, lim_conf, lim_iou):
    resultados = modelo.predict(img, conf=lim_conf, iou=lim_iou)
    return resultados[0].plot()

interface = gr.Interface(
    fn=predizer,
    inputs=[gr.Image(type="pil"), gr.Slider(0,1), gr.Slider(0,1)],
    outputs="image",
    title="Detector de Superaquecimento"
)
interface.launch()

Arquitetura do YOLOv11

Estrutura modular com três componentes principais:

Rede Base (Backbone)

class CamadaConv(nn.Module):
    def __init__(self, ent, sai, k=3):
        super().__init__()
        self.conv = nn.Conv2d(ent, sai, k, padding=k//2)
        self.norm = nn.BatchNorm2d(sai)
        self.ativacao = nn.SiLU()
    
    def forward(self, x):
        return self.ativacao(self.norm(self.conv(x)))

Módulo C3K

class BlocoC3K(nn.Module):
    def __init__(self, ent, sai, n=2):
        super().__init__()
        camadas = [CamadaConv(ent, ent, k=3) for _ in range(n)]
        self.caminho = nn.Sequential(*camadas)
    
    def forward(self, x):
        return x + self.caminho(x)

Cabeça de Detecção

class CabecaDetecao(nn.Module):
    def __init__(self, canais, classes):
        super().__init__()
        self.conv_final = nn.Conv2d(canais, 5 + classes, 1)
    
    def forward(self, x):
        return self.conv_final(x)

Otimizações

Módulo CBAM

class AtencaoCanal(nn.Module):
    def __init__(self, canais):
        super().__init__()
        self.pool = nn.AdaptiveAvgPool2d(1)
        self.camada = nn.Sequential(
            nn.Linear(canais, canais//4),
            nn.ReLU(),
            nn.Linear(canais//4, canais),
            nn.Sigmoid()
        )
    
    def forward(self, x):
        s = self.pool(x).view(x.size(0), -1)
        pesos = self.camada(s).view(x.size(0), x.size(1), 1, 1)
        return x * pesos

Convolução Fantasma

class ConvFantasma(nn.Module):
    def __init__(self, ent, sai):
        super().__init__()
        self.primaria = CamadaConv(ent, sai//2)
        self.secundaria = CamadaConv(sai//2, sai//2, k=5)
    
    def forward(self, x):
        p = self.primaria(x)
        s = self.secundaria(p)
        return torch.cat([p, s], dim=1)

Desempenho

Métricas de avaliação após treinamento:

• Precisão: 92.4%
• Recall: 89.7%
• mAP@0.5: 91.2%

O sistema demonstra eficácia na identificação de anomalias térmicas em diferentes condições operacionais.