Create dominant model.py

dominant model.py

@@ -0,0 +1,270 @@
+# dominant_model.py — DOMINANT: Deep Anomaly Detection on Attributed Networks
+# Paper: Ding et al., IJCAI 2019
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from sklearn.metrics import (
+    roc_auc_score, average_precision_score,
+    f1_score, precision_score, recall_score
+)
+
+
+# ──────────────────────────────────────────────────────────────
+# GCN LAYER — implementação manual (sem torch-sparse)
+# ──────────────────────────────────────────────────────────────
+class GCNLayer(nn.Module):
+    def __init__(self, in_dim, out_dim, bias=True):
+        super().__init__()
+        self.W = nn.Linear(in_dim, out_dim, bias=bias)
+
+    def forward(self, x, edge_index, edge_weight, n_nos):
+        # Agregação de vizinhos: A_norm @ X @ W
+        h = self.W(x)  # [N, out]
+        row, col = edge_index
+        # Scatter weighted sum
+        agg = torch.zeros_like(h)
+        agg.scatter_add_(0, col.unsqueeze(1).expand_as(h[row]),
+                         h[row] * edge_weight.unsqueeze(1))
+        return agg
+
+
+# ──────────────────────────────────────────────────────────────
+# ENCODER — GCN compartilhado
+# ──────────────────────────────────────────────────────────────
+class GCNEncoder(nn.Module):
+    def __init__(self, in_dim, hidden_dim, embed_dim, dropout=0.3):
+        super().__init__()
+        self.gc1 = GCNLayer(in_dim, hidden_dim)
+        self.gc2 = GCNLayer(hidden_dim, embed_dim)
+        self.dropout = dropout
+        self.bn1 = nn.BatchNorm1d(hidden_dim)
+
+    def forward(self, x, edge_index, edge_weight, n_nos):
+        h = self.gc1(x, edge_index, edge_weight, n_nos)
+        h = self.bn1(F.relu(h))
+        h = F.dropout(h, p=self.dropout, training=self.training)
+        h = self.gc2(h, edge_index, edge_weight, n_nos)
+        return h  # [N, embed_dim]
+
+
+# ──────────────────────────────────────────────────────────────
+# ATTRIBUTE DECODER — reconstrói features originais
+# ──────────────────────────────────────────────────────────────
+class AttributeDecoder(nn.Module):
+    def __init__(self, embed_dim, hidden_dim, out_dim, dropout=0.3):
+        super().__init__()
+        self.gc1 = GCNLayer(embed_dim, hidden_dim)
+        self.gc2 = GCNLayer(hidden_dim, out_dim)
+        self.dropout = dropout
+
+    def forward(self, z, edge_index, edge_weight, n_nos):
+        h = F.relu(self.gc1(z, edge_index, edge_weight, n_nos))
+        h = F.dropout(h, p=self.dropout, training=self.training)
+        return self.gc2(h, edge_index, edge_weight, n_nos)
+
+
+# ──────────────────────────────────────────────────────────────
+# STRUCTURE DECODER — reconstrói adjacência via produto interno
+# ──────────────────────────────────────────────────────────────
+class StructureDecoder(nn.Module):
+    def __init__(self, embed_dim, hidden_dim, dropout=0.3):
+        super().__init__()
+        self.gc1 = GCNLayer(embed_dim, hidden_dim)
+        self.dropout = dropout
+
+    def forward(self, z, edge_index, edge_weight, n_nos):
+        h = F.relu(self.gc1(z, edge_index, edge_weight, n_nos))
+        h = F.dropout(h, p=self.dropout, training=self.training)
+        # Reconstrói A via produto interno: sigmoid(Z @ Z^T)
+        # Para eficiência, só calcula para arestas existentes
+        row, col = edge_index
+        scores = (h[row] * h[col]).sum(dim=1)
+        return torch.sigmoid(scores), h
+
+
+# ──────────────────────────────────────────────────────────────
+# DOMINANT COMPLETO
+# ──────────────────────────────────────────────────────────────
+class DOMINANT(nn.Module):
+    """
+    Deep Anomaly Detection on Attributed Networks.
+    Ding et al., IJCAI 2019.
+    
+    Loss = α × L_structure + (1-α) × L_attribute
+    Anomaly Score = α × err_struct(v) + (1-α) × err_attr(v)
+    """
+    def __init__(self, in_dim, hidden_dim=64, embed_dim=32,
+                 alpha=0.5, dropout=0.3):
+        super().__init__()
+        self.alpha = alpha
+        self.encoder  = GCNEncoder(in_dim, hidden_dim, embed_dim, dropout)
+        self.attr_dec = AttributeDecoder(embed_dim, hidden_dim, in_dim, dropout)
+        self.struct_dec = StructureDecoder(embed_dim, hidden_dim, dropout)
+
+    def forward(self, x, edge_index, edge_weight, n_nos):
+        # Encode
+        z = self.encoder(x, edge_index, edge_weight, n_nos)
+
+        # Decode atributos
+        x_hat = self.attr_dec(z, edge_index, edge_weight, n_nos)
+
+        # Decode estrutura
+        a_hat, h_struct = self.struct_dec(z, edge_index, edge_weight, n_nos)
+
+        return z, x_hat, a_hat, h_struct
+
+    def compute_loss(self, x, edge_index, x_hat, a_hat):
+        """
+        L_attr   = ||X - X̂||²  por nó
+        L_struct = BCE(A, Â)   por aresta → agregado por nó
+        """
+        row, col = edge_index
+
+        # Erro de atributo por nó
+        err_attr = ((x - x_hat) ** 2).mean(dim=1)  # [N]
+
+        # Erro de estrutura por aresta
+        a_true = torch.ones(edge_index.shape[1]).to(x.device)
+        err_edge = F.binary_cross_entropy(a_hat, a_true, reduction='none')
+
+        # Agrega erro estrutural por nó (média das arestas incidentes)
+        err_struct = torch.zeros(x.shape[0]).to(x.device)
+        count = torch.zeros(x.shape[0]).to(x.device)
+        err_struct.scatter_add_(0, row, err_edge)
+        count.scatter_add_(0, row, torch.ones_like(err_edge))
+        count = count.clamp(min=1)
+        err_struct = err_struct / count
+
+        # Loss total
+        loss = (self.alpha * err_struct + (1 - self.alpha) * err_attr).mean()
+        return loss, err_attr.detach(), err_struct.detach()
+
+    def anomaly_score(self, err_attr, err_struct):
+        """Score de anomalia combinado — maior = mais suspeito."""
+        score = self.alpha * err_struct + (1 - self.alpha) * err_attr
+        # Normaliza para [0, 1]
+        mn, mx = score.min(), score.max()
+        return (score - mn) / (mx - mn + 1e-8)
+
+
+# ──────────────────────────────────────────────────────────────
+# TRAINER
+# ──────────────────────────────────────────────────────────────
+class TrainerDOMINANT:
+    def __init__(self, data, edge_weight, hidden_dim=64, embed_dim=32,
+                 alpha=0.5, lr=0.005, dropout=0.3):
+        self.data        = data
+        self.edge_index  = data.edge_index
+        self.edge_weight = edge_weight
+        self.n_nos       = data.x.shape[0]
+
+        self.model = DOMINANT(
+            in_dim=data.x.shape[1],
+            hidden_dim=hidden_dim,
+            embed_dim=embed_dim,
+            alpha=alpha,
+            dropout=dropout,
+        )
+        self.opt = torch.optim.Adam(
+            self.model.parameters(), lr=lr, weight_decay=1e-4)
+        self.scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
+            self.opt, patience=10, factor=0.5, min_lr=1e-5)
+
+        self.historico = {'loss': [], 'auc': []}
+        self.melhor_auc    = 0.0
+        self.melhor_estado = None
+        self.scores_finais = None
+        self.embeddings    = None
+
+    def treinar_epoca(self):
+        self.model.train()
+        z, x_hat, a_hat, _ = self.model(
+            self.data.x, self.edge_index,
+            self.edge_weight, self.n_nos)
+        loss, err_attr, err_struct = self.model.compute_loss(
+            self.data.x, self.edge_index, x_hat, a_hat)
+        self.opt.zero_grad()
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)
+        self.opt.step()
+        return loss.item(), err_attr, err_struct
+
+    def avaliar(self, err_attr, err_struct):
+        scores = self.model.anomaly_score(err_attr, err_struct).numpy()
+        y_true = self.data.y.numpy()
+        auc = roc_auc_score(y_true, scores) if len(np.unique(y_true)) > 1 else 0.5
+        return auc, scores
+
+    def treinar(self, epocas=100, callback=None):
+        for ep in range(1, epocas + 1):
+            loss, err_attr, err_struct = self.treinar_epoca()
+            auc, scores = self.avaliar(err_attr, err_struct)
+            self.scheduler.step(loss)
+
+            self.historico['loss'].append(loss)
+            self.historico['auc'].append(auc)
+
+            if auc > self.melhor_auc:
+                self.melhor_auc    = auc
+                self.melhor_estado = {k: v.clone()
+                                      for k, v in self.model.state_dict().items()}
+                self.scores_finais = scores
+
+            if callback:
+                callback(ep, epocas, loss, auc)
+
+        if self.melhor_estado:
+            self.model.load_state_dict(self.melhor_estado)
+
+    def metricas_completas(self):
+        self.model.eval()
+        with torch.no_grad():
+            z, x_hat, a_hat, _ = self.model(
+                self.data.x, self.edge_index,
+                self.edge_weight, self.n_nos)
+            _, err_attr, err_struct = self.model.compute_loss(
+                self.data.x, self.edge_index, x_hat, a_hat)
+
+        scores = self.model.anomaly_score(err_attr, err_struct).numpy()
+        y_true = self.data.y.numpy()
+        self.embeddings = z.detach().numpy()
+        self.scores_finais = scores
+
+        # Threshold via percentil (top-k como na literatura)
+        k       = int(y_true.sum())
+        thresh  = np.sort(scores)[-k] if k > 0 else 0.5
+        preds   = (scores >= thresh).astype(int)
+
+        # Decomposição por tipo de erro
+        err_a = err_attr.numpy()
+        err_s = err_struct.numpy()
+
+        return {
+            'auc':          roc_auc_score(y_true, scores),
+            'ap':           average_precision_score(y_true, scores),
+            'f1':           f1_score(y_true, preds, zero_division=0),
+            'precision':    precision_score(y_true, preds, zero_division=0),
+            'recall':       recall_score(y_true, preds, zero_division=0),
+            'scores':       scores,
+            'y_true':       y_true,
+            'err_attr':     err_a,
+            'err_struct':   err_s,
+            'embeddings':   self.embeddings,
+            'thresh':       thresh,
+            'preds':        preds,
+        }
+
+    def get_top_anomalias(self, n=20):
+        """Retorna os nós mais anômalos com decomposição de erro."""
+        if self.scores_finais is None:
+            return []
+        top_idx = np.argsort(self.scores_finais)[::-1][:n]
+        result  = []
+        for idx in top_idx:
+            result.append({
+                'idx':       int(idx),
+                'score':     float(self.scores_finais[idx]),
+                'label_real': int(self.data.y[idx]),
+            })
+        return result