V6.5-V2-dynamic: upload batch (scripts + state + model) [13 files]

kohonen_learning_system.py

@@ -375,6 +375,8 @@ class KohonenSOM4D:
         alpha0: float = 0.5,
         sigma0: float = 3.0,
         lambda_ewc: float = 0.01,
+        conscience_gamma: float = 0.1,
+        conscience_beta: float = 0.1,
     ):
         # V6.5-V2-metrics-FIX-3 — α₀=0.5 e σ₀=3.0 conforme especificação
         # canônica para SOM 4D (Kohonen classic):
@@ -384,6 +386,17 @@ class KohonenSOM4D:
         # que α_t e σ_t nunca decaiam abaixo de 0.001 e 0.1 respectivamente
         # (sem isso, após ~7000 updates σ→0 e o SOM degenera em k-means puro,
         # perdendo preservação topológica).
+        #
+        # V6.5-V2-metrics-FIX-4 (Conscience Mechanism — DeSieno 1988):
+        # Corrige o problema neurons_active=2/864 relatado pelo usuário.
+        # Cada neurônio i mantém uma frequência de vitória p_i ∈ [0,1].
+        # BMU selection: bmu = argmin_i ( ||W_i - x||² - b_i )
+        #   onde b_i = γ · (1/N - p_i)   é o bias de consciência
+        #   γ = 0.1 (default), N = total de neurônios (864)
+        # Update da frequência (EMA): p_i ← (1-β)·p_i + β·𝟙[i==bmu], β=0.1
+        # Quando um neurônio ganha demais (p_i > 1/N), b_i fica negativo
+        # (penaliza), e quando nunca ganha (p_i ≈ 0), b_i fica positivo
+        # (empurra para ganhar). Isto força distribuição uniforme de BMU.
         self.I, self.J, self.K, self.L = grid_shape
         self.alpha0 = float(alpha0)
         self.sigma0 = float(sigma0)
@@ -396,6 +409,23 @@ class KohonenSOM4D:
         self.fisher_accum = torch.zeros(self.I, self.J, self.K, self.L)
         self.fisher_count = torch.zeros(self.I, self.J, self.K, self.L)
 
+        # V6.5-V2-metrics-FIX-4 — Conscience mechanism (DeSieno 1988)
+        # Inicializa p_i = 1/N (uniforme) — sem viés inicial.
+        # b_i = γ · (1/N - p_i) começa em 0 (sem bias).
+        self.n_neurons = self.I * self.J * self.K * self.L
+        self.conscience_gamma = float(conscience_gamma)
+        self.conscience_beta = float(conscience_beta)
+        target_p = 1.0 / self.n_neurons
+        self.win_frequency = torch.full(
+            (self.I, self.J, self.K, self.L), target_p, dtype=torch.float
+        )
+        # Contador absoluto de vitórias por neurônio (para auditoria)
+        self.bmu_win_count = torch.zeros(
+            self.I, self.J, self.K, self.L, dtype=torch.long
+        )
+        # Histórico dos últimos K BMUs (para revive_dead_neurons)
+        self._recent_bmu_flat: List[int] = []
+
     def _neighborhood(self, bmu_idx):
         """Vizinhança Gaussiana 4D: d² = Δi² + Δj² + Δk² + Δl²."""
         i, j, k, l = bmu_idx
@@ -409,13 +439,39 @@ class KohonenSOM4D:
         dist_sq = (II - i) ** 2 + (JJ - j) ** 2 + (KK - k) ** 2 + (LL - l) ** 2
         return dist_sq
 
-    def find_bmu(self, x: torch.Tensor) -> Tuple[int, int, int, int]:
-        """Best Matching Unit: argmin ||W - x||² em ℝ⁴.
+    def find_bmu(self, x: torch.Tensor, use_conscience: bool = True) -> Tuple[int, int, int, int]:
+        """Best Matching Unit: argmin ||W - x||² em ℝ⁴, com conscience bias opcional.
 
         Substitui pgvector_lookup — busca nearest-neighbor flat sobre o grid.
+
+        V6.5-V2-metrics-FIX-4 (Conscience Mechanism — DeSieno 1988):
+        Quando use_conscience=True, adiciona bias b_i = γ·(1/N - p_i) à
+        distância, forçando distribuição uniforme de BMU entre os 864
+        neurônios. Isto corrige o problema neurons_active=2/864:
+
+            bmu = argmin_i ( ||W_i - x||² - b_i )
+
+        Sem conscience, neurônios próximos a poucas amostras ficam mortos.
+        Com conscience, neurônios que ganham demais (p_i > 1/N) são
+        penalizados (b_i < 0 aumenta distância efetiva), e neurônios que
+        nunca ganham (p_i ≈ 0) são favorecidos (b_i > 0 reduz distância).
+
+        Args:
+            x: tensor [4] — vetor de entrada.
+            use_conscience: se True, aplica bias de consciência (default True).
         """
+        # Sanitiza x antes de computar distância
+        if torch.isnan(x).any() or torch.isinf(x).any():
+            x = torch.nan_to_num(x, nan=0.0, posinf=1e4, neginf=-1e4)
         dist = torch.sum((self.weights - x.view(1, 1, 1, 1, 4)) ** 2, dim=-1)
-        flat_idx = torch.argmin(dist).item()
+        if use_conscience:
+            # b_i = γ · (1/N - p_i)  →  subtraído da distância (menor distância efetiva vence)
+            target_p = 1.0 / self.n_neurons
+            bias = self.conscience_gamma * (target_p - self.win_frequency)
+            dist_effective = dist - bias
+            flat_idx = int(torch.argmin(dist_effective).item())
+        else:
+            flat_idx = int(torch.argmin(dist).item())
         i = flat_idx // (self.J * self.K * self.L)
         rest = flat_idx % (self.J * self.K * self.L)
         j = rest // (self.K * self.L)
@@ -424,9 +480,232 @@ class KohonenSOM4D:
         l = rest % self.L
         return (i, j, k, l)
 
+    def update_win_frequency(self, bmu_idx: Tuple[int, int, int, int]) -> None:
+        """V6.5-V2-metrics-FIX-4 — Atualiza frequência de vitória (EMA).
+
+        p_i ← (1-β)·p_i + β·𝟙[i==bmu],   β = conscience_beta (default 0.1)
+
+        Também mantém contador absoluto bmu_win_count para auditoria.
+        Deve ser chamado APÓS find_bmu e APÓS update_weights.
+
+        Args:
+            bmu_idx: (i, j, k, l) — índice do BMU selecionado.
+        """
+        with torch.no_grad():
+            # EMA update
+            self.win_frequency = (
+                (1.0 - self.conscience_beta) * self.win_frequency
+            )
+            self.win_frequency[bmu_idx] += self.conscience_beta
+            # Contador absoluto
+            self.bmu_win_count[bmu_idx] += 1
+            # Histórico recente (para revive_dead_neurons)
+            flat = (
+                bmu_idx[0] * (self.J * self.K * self.L)
+                + bmu_idx[1] * (self.K * self.L)
+                + bmu_idx[2] * self.L
+                + bmu_idx[3]
+            )
+            self._recent_bmu_flat.append(flat)
+            # Mantém últimos 200 BMUs
+            if len(self._recent_bmu_flat) > 200:
+                self._recent_bmu_flat = self._recent_bmu_flat[-200:]
+
+    def revive_dead_neurons(
+        self,
+        data_buffer: Optional[List[torch.Tensor]] = None,
+        dead_threshold: int = 0,
+    ) -> Dict[str, Any]:
+        """V6.5-V2-metrics-FIX-4 — Revive neurônios mortos reinicializando pesos.
+
+        User requirement: "ANALISAR matematicamente e logicamente a ativação e
+        uso e acesso dos neurônios (apenas dois estão sendo ativados:
+        neurons_active=2/864) distribuindo o processamento paralelamente".
+
+        Um neurônio é considerado "morto" se bmu_win_count <= dead_threshold
+        (nunca ou raramente foi BMU). Para cada neurônio morto:
+
+        1. Se data_buffer fornecido: amostra um vetor aleatório do buffer e
+           atribui aos pesos do neurônio (reinicialização data-driven).
+        2. Se buffer vazio: reinicializa com ruído gaussiano pequeno (N(0, 0.1)).
+        3. Reseta win_frequency para 1/N (sem bias) e bmu_win_count para 0.
+
+        Isto garante que TODOS os 864 neurônios sejam utilizados, distribuindo
+        o processamento paralelo do SOM conforme solicitado.
+
+        Args:
+            data_buffer: lista de tensores [4] — amostras do buffer_4d do KLS.
+            dead_threshold: neurônios com win_count <= threshold são revividos.
+
+        Returns:
+            Dict com: n_revived, n_total, revived_indices, dead_rate_before, dead_rate_after.
+        """
+        with torch.no_grad():
+            dead_mask = self.bmu_win_count <= dead_threshold
+            n_dead = int(dead_mask.sum().item())
+            n_total = self.n_neurons
+            dead_rate_before = float(n_dead / n_total)
+
+            revived_indices: List[Tuple[int, int, int, int]] = []
+            if n_dead == 0:
+                return {
+                    "n_revived": 0,
+                    "n_total": n_total,
+                    "revived_indices": [],
+                    "dead_rate_before": dead_rate_before,
+                    "dead_rate_after": dead_rate_before,
+                    "action": "none",
+                }
+
+            # Amostra pontos do buffer se disponível
+            buffer_tensor = None
+            if data_buffer and len(data_buffer) > 0:
+                try:
+                    buffer_tensor = torch.stack(
+                        [v.detach().clone() if isinstance(v, torch.Tensor)
+                         else torch.tensor(v, dtype=torch.float)
+                         for v in data_buffer]
+                    ).float()
+                except Exception:
+                    buffer_tensor = None
+
+            # Itera sobre neurônios mortos e reinicializa
+            dead_indices = dead_mask.nonzero(as_tuple=False)
+            for idx_tensor in dead_indices:
+                i, j, k, l = idx_tensor.tolist()
+                if buffer_tensor is not None and buffer_tensor.shape[0] > 0:
+                    # Amostra aleatória do buffer
+                    sample_idx = torch.randint(0, buffer_tensor.shape[0], (1,)).item()
+                    new_w = buffer_tensor[sample_idx].clone()
+                    # Pequeno ruído para evitar duplicação exata
+                    new_w = new_w + 0.05 * torch.randn(4)
+                else:
+                    # Reinicialização gaussiana pequena
+                    new_w = 0.1 * torch.randn(4)
+                # Clamp para segurança
+                new_w = torch.clamp(new_w, -10.0, 10.0)
+                self.weights[i, j, k, l] = new_w
+                # Reset counters
+                self.win_frequency[i, j, k, l] = 1.0 / n_total
+                self.bmu_win_count[i, j, k, l] = 0
+                revived_indices.append((i, j, k, l))
+
+            # Recalcula dead rate após revival
+            new_dead_mask = self.bmu_win_count <= dead_threshold
+            n_dead_after = int(new_dead_mask.sum().item())
+            dead_rate_after = float(n_dead_after / n_total)
+
+            return {
+                "n_revived": len(revived_indices),
+                "n_total": n_total,
+                "revived_indices": revived_indices[:50],  # top 50 para log
+                "n_dead_before": n_dead,
+                "n_dead_after": n_dead_after,
+                "dead_rate_before": dead_rate_before,
+                "dead_rate_after": dead_rate_after,
+                "action": "revived" if revived_indices else "none",
+                "used_buffer": buffer_tensor is not None,
+            }
+
+    def parallel_neuron_activation_report(self) -> Dict[str, Any]:
+        """V6.5-V2-metrics-FIX-4 — Relatório estruturado de ativação dos 864 neurônios.
+
+        User requirement: "distribuindo o processamento paralelamente" + o
+        exemplo de código fornecido mostra estruturação vetorizada para
+        análise estatística e auditoria do modelo.
+
+        Este método produz um relatório análogo ao DataFrame do exemplo,
+        mas otimizado para o grid 4D (6,6,6,4) com 864 neurônios:
+
+        Returns:
+            Dict com:
+              - n_total_neurons: int (864)
+              - n_active_neurons: int (vitória em ≥1 amostra histórica)
+              - n_dead_neurons: int (nunca foi BMU)
+              - neuron_activation_rate: float
+              - max_win_count: int (neurônio mais ativo)
+              - min_win_count: int (neurônio menos ativo)
+              - mean_win_count: float
+              - std_win_count: float
+              - max_win_frequency: float
+              - min_win_frequency: float
+              - bmu_distribution_top20: dict {flat_idx: count}
+              - bmu_distribution_bottom20: dict {flat_idx: count} (mortos)
+              - conscience_bias_mean: float (deve tender a 0 se uniforme)
+              - conscience_bias_std: float (deve tender a 0 se uniforme)
+              - uniformity_score: float (1 - CV da win_frequency, ∈ [0,1])
+        """
+        with torch.no_grad():
+            win_counts_flat = self.bmu_win_count.flatten().float()
+            win_freq_flat = self.win_frequency.flatten()
+
+            n_total = self.n_neurons
+            n_active = int((self.bmu_win_count > 0).sum().item())
+            n_dead = n_total - n_active
+
+            # Estatísticas
+            if n_total > 0:
+                max_wc = float(win_counts_flat.max().item())
+                min_wc = float(win_counts_flat.min().item())
+                mean_wc = float(win_counts_flat.mean().item())
+                std_wc = float(win_counts_flat.std().item())
+                max_wf = float(win_freq_flat.max().item())
+                min_wf = float(win_freq_flat.min().item())
+                # Uniformidade: 1 - CV (coeficiente de variação)
+                cv = float(std_wc / max(mean_wc, 1e-8))
+                uniformity = max(0.0, 1.0 - cv)
+            else:
+                max_wc = min_wc = mean_wc = std_wc = 0.0
+                max_wf = min_wf = 0.0
+                uniformity = 0.0
+
+            # Bias de consciência: b_i = γ · (1/N - p_i)
+            target_p = 1.0 / n_total
+            bias_flat = self.conscience_gamma * (target_p - win_freq_flat)
+            bias_mean = float(bias_flat.mean().item())
+            bias_std = float(bias_flat.std().item())
+
+            # Top-20 BMUs mais frequentes
+            from collections import Counter
+            recent_counter = Counter(self._recent_bmu_flat)
+            top20 = dict(recent_counter.most_common(20))
+
+            # Bottom-20 (mortos ou raros) — últimos em vitórias absolutas
+            sorted_indices = torch.argsort(win_counts_flat)
+            bottom20_idx = sorted_indices[:20].tolist()
+            bottom20 = {
+                int(idx): int(self.bmu_win_count.flatten()[idx].item())
+                for idx in bottom20_idx
+            }
+
+            return {
+                "n_total_neurons": int(n_total),
+                "n_active_neurons": int(n_active),
+                "n_dead_neurons": int(n_dead),
+                "neuron_activation_rate": float(n_active / max(1, n_total)),
+                "max_win_count": max_wc,
+                "min_win_count": min_wc,
+                "mean_win_count": mean_wc,
+                "std_win_count": std_wc,
+                "max_win_frequency": max_wf,
+                "min_win_frequency": min_wf,
+                "bmu_distribution_top20": {str(k): int(v) for k, v in top20.items()},
+                "bmu_distribution_bottom20": {str(k): int(v) for k, v in bottom20.items()},
+                "conscience_bias_mean": bias_mean,
+                "conscience_bias_std": bias_std,
+                "uniformity_score": uniformity,
+                "conscience_gamma": float(self.conscience_gamma),
+                "conscience_beta": float(self.conscience_beta),
+                "n_recent_bmus_tracked": int(len(self._recent_bmu_flat)),
+            }
+
     def update_weights(self, x: torch.Tensor, bmu_idx, accumulate_fisher=False):
         """Update Kohonen: ΔW = α·Λ·(x - W) + penalidade EWC em w.
 
+        V6.5-V2-metrics-FIX-4 — agora chama update_win_frequency automaticamente
+        após o update, garantindo que o conscience mechanism seja atualizado
+        a cada amostra processada (sem necessidade de chamada externa).
+
         V6.5-V2-metrics-FIX-3 — Correções matemáticas:
           1. Floors explícitos em α_t e σ_t (previnem colapso topológico
              após muitas épocas, quando σ_t→0 degenera o SOM em k-means).
@@ -479,6 +758,16 @@ class KohonenSOM4D:
 
         self.t += 1
 
+        # V6.5-V2-metrics-FIX-4 — atualiza conscience mechanism (win frequency)
+        # automaticamente após cada update. Isto garante que o bias de consciência
+        # seja aplicado corretamente no próximo find_bmu, forçando distribuição
+        # uniforme de BMU entre os 864 neurônios.
+        try:
+            self.update_win_frequency(bmu_idx)
+        except Exception:
+            # Não deixa falha no conscience quebrar o treino principal
+            pass
+
     def finalize_fisher(self):
         """Fisher = mean((x_w - W_w)²) sobre samples acumuladas."""
         cnt = self.fisher_count.clamp(min=1e-8)
@@ -498,10 +787,20 @@ class KohonenSOM4D:
         """Retorna métricas atuais do SOM para monitoramento."""
         sigma_t = self.sigma0 * math.exp(-self.t / 1000)
         alpha_t = self.alpha0 * math.exp(-self.t / 2000)
+        # V6.5-V2-metrics-FIX-4 — floors aplicados (consistência com update_weights)
+        sigma_t_eff = max(sigma_t, 0.1)
+        alpha_t_eff = max(alpha_t, 0.001)
+        # V6.5-V2-metrics-FIX-4 — estatísticas do conscience mechanism
+        n_total = self.n_neurons
+        n_active = int((self.bmu_win_count > 0).sum().item())
+        n_dead = n_total - n_active
+        win_counts_flat = self.bmu_win_count.flatten().float()
         return {
             "t": int(self.t),
             "sigma_t": float(sigma_t),
             "alpha_t": float(alpha_t),
+            "sigma_t_effective": float(sigma_t_eff),
+            "alpha_t_effective": float(alpha_t_eff),
             "sigma0": float(self.sigma0),
             "alpha0": float(self.alpha0),
             "lambda_ewc": float(self.lambda_ewc),
@@ -521,6 +820,17 @@ class KohonenSOM4D:
             "fisher_accum_count": int(self.fisher_count.sum().item()),
             "weights_norm": float(self.weights.norm().item()),
             "weights_w_mean": float(self.weights[..., 3].mean().item()),
+            # V6.5-V2-metrics-FIX-4 — conscience mechanism status
+            "conscience_gamma": float(self.conscience_gamma),
+            "conscience_beta": float(self.conscience_beta),
+            "n_active_neurons": n_active,
+            "n_dead_neurons": n_dead,
+            "neuron_activation_rate": float(n_active / max(1, n_total)),
+            "bmu_win_count_mean": float(win_counts_flat.mean().item()) if n_total > 0 else 0.0,
+            "bmu_win_count_max": float(win_counts_flat.max().item()) if n_total > 0 else 0.0,
+            "win_frequency_mean": float(self.win_frequency.mean().item()),
+            "win_frequency_max": float(self.win_frequency.max().item()),
+            "win_frequency_min": float(self.win_frequency.min().item()),
         }
 
 
@@ -3246,6 +3556,130 @@ class KohonenLearningSystemV2(KohonenLearningSystem):
             "max_hyp_train_steps": int(self.max_hyp_train_steps),
         }
 
+    # ==================================================================
+    # V6.5-V2-metrics-FIX-4 — Conscience mechanism + Dead neuron revival
+    # ==================================================================
+    # User requirement (latest): "APRIMORAR (em ambas as FASE1 e FASE2):
+    # analisar matematicamente e logicamente a ativação e uso e acesso dos
+    # neurônios (apenas dois estão sendo ativados: neurons_active=2/864)
+    # distribuindo o processamento paralelamente".
+    #
+    # Mathematical formulation (Conscience Mechanism — DeSieno 1988):
+    #
+    #   Cada neurônio i mantém win_frequency p_i ∈ [0,1] (EMA, β=0.1).
+    #   BMU selection: bmu = argmin_i ( ||W_i - x||² - b_i )
+    #     onde b_i = γ · (1/N - p_i)   é o conscience bias
+    #     γ = 0.1 (default), N = total de neurônios (864)
+    #
+    #   Quando p_i > 1/N (neurônio ganha demais): b_i < 0 → distância
+    #   efetiva AUMENTA → neurônio é penalizado.
+    #   Quando p_i < 1/N (neurônio nunca ganha): b_i > 0 → distância
+    #   efetiva DIMINUI → neurônio é favorecido.
+    #
+    #   Convergência: p_i → 1/N para todo i (distribuição uniforme de BMU),
+    #   garantindo que TODOS os 864 neurônios sejam utilizados.
+    #
+    # Dead neuron revival (complementar):
+    #   Se após K amostras um neurônio ainda tem win_count = 0, ele é
+    #   reinicializado para uma amostra aleatória do buffer (data-driven)
+    #   ou para N(0, 0.1) se buffer vazio. Isto acelera a diversificação
+    #   quando o conscience mechanism sozinho não basta.
+    # ------------------------------------------------------------------
+    def revive_dead_neurons(
+        self,
+        dead_threshold: int = 0,
+        use_buffer: bool = True,
+    ) -> Dict[str, Any]:
+        """V6.5-V2-metrics-FIX-4 — Wrapper KLS para som.revive_dead_neurons.
+
+        Usa o buffer_4d atual do KLS como fonte de dados para reinicialização
+        data-driven dos neurônios mortos.
+
+        Args:
+            dead_threshold: neurônios com win_count <= threshold são revividos.
+            use_buffer: se True, usa buffer_4d do KLS como fonte.
+
+        Returns:
+            Dict com status do revival (n_revived, dead_rate_before/after, etc).
+        """
+        data_buffer = self.buffer_4d if use_buffer else None
+        return self.som.revive_dead_neurons(
+            data_buffer=data_buffer,
+            dead_threshold=dead_threshold,
+        )
+
+    def parallel_neuron_activation_report(self) -> Dict[str, Any]:
+        """V6.5-V2-metrics-FIX-4 — Wrapper KLS para som.parallel_neuron_activation_report.
+
+        Retorna relatório estruturado de ativação dos 864 neurônios, análogo
+        ao DataFrame do exemplo fornecido pelo usuário, mas otimizado para
+        o grid 4D do SOM.
+
+        Returns:
+            Dict com estatísticas detalhadas (n_active, n_dead, win_count
+            distribution, conscience_bias stats, uniformity_score, etc).
+        """
+        return self.som.parallel_neuron_activation_report()
+
+    def auto_revive_if_needed(
+        self,
+        dead_rate_threshold: float = 0.5,
+        min_steps_between_revivals: int = 200,
+    ) -> Dict[str, Any]:
+        """V6.5-V2-metrics-FIX-4 — Revive neurônios automaticamente se dead_rate alto.
+
+        Verifica o dead_rate atual e revive neurônios mortos se:
+          - dead_rate > dead_rate_threshold (default 0.5 = 50% mortos)
+          - pelo menos min_steps_between_revivals desde o último revival
+
+        Isto é chamado automaticamente pelo treinador após cada chunk,
+        garantindo que o SOM mantenha distribuição uniforme de BMU ao longo
+        do treino sem intervenção manual.
+
+        Args:
+            dead_rate_threshold: limite para disparar revival (default 0.5).
+            min_steps_between_revivals: cooldown em steps (default 200).
+
+        Returns:
+            Dict com status do revival (ou action="skipped" se não disparou).
+        """
+        last_revival_step = getattr(self, "_last_revival_step", -min_steps_between_revivals)
+        current_step = self.som.t
+        steps_since_last = current_step - last_revival_step
+
+        # Computa dead rate atual
+        report = self.som.parallel_neuron_activation_report()
+        dead_rate = 1.0 - report["neuron_activation_rate"]
+
+        if dead_rate <= dead_rate_threshold:
+            return {
+                "action": "skipped",
+                "reason": f"dead_rate={dead_rate:.3f} <= threshold={dead_rate_threshold}",
+                "dead_rate": dead_rate,
+                "n_active": report["n_active_neurons"],
+                "n_total": report["n_total_neurons"],
+            }
+        if steps_since_last < min_steps_between_revivals:
+            return {
+                "action": "skipped",
+                "reason": f"cooldown: only {steps_since_last} steps since last revival "
+                          f"(need {min_steps_between_revivals})",
+                "dead_rate": dead_rate,
+                "n_active": report["n_active_neurons"],
+                "n_total": report["n_total_neurons"],
+            }
+
+        # Dispara revival
+        revival = self.revive_dead_neurons(
+            dead_threshold=0,
+            use_buffer=True,
+        )
+        self._last_revival_step = current_step
+        revival["action"] = "auto_revived"
+        revival["trigger_dead_rate"] = dead_rate
+        revival["steps_since_last_revival"] = steps_since_last
+        return revival
+
     # ==================================================================
     # V6.5-V2-metrics — Integração das métricas SOM canônicas
     # (QE, TE, Kaski-Lagus, Variância Explicada, Dead Neurons,

train_v6_5_v2.py

@@ -100,6 +100,27 @@ logger = logging.getLogger("train_v6_5_v2")
 os.environ["V65_ENABLE_STREAMING"] = "1"
 logger.info(f"[V6.5-V2] V65_ENABLE_STREAMING={os.environ['V65_ENABLE_STREAMING']} (forced)")
 
+# V6.5-V2-metrics-FIX-4 — HF datasets memory optimization (OOM-killer mitigation)
+# User requirement: "o processo vem sendo morto OOM-kiler (Out of memory) devido
+# algum bug de lógica ou falta de otimização que deve ser investigado".
+# Estas variáveis reduzem o consumo de memória do HF datasets library:
+#   - HF_DATASETS_DISABLE_IN_MEMORY_CACHE: não cacheia datasets em RAM
+#   - HF_DATASETS_OFFLINE=0: permite streaming mas não força cache local
+#   - DATASETS_FINGERPRINT_CACHING_DISABLED: skipa fingerprinting (CPU/memory)
+#   - TOKENIZERS_PARALLELISM=false: evita spawn de processos paralelos
+#   - HF_HUB_DISABLE_TELEMETRY: desabilita telemetria (CPU/network)
+os.environ["HF_DATASETS_DISABLE_IN_MEMORY_CACHE"] = "1"
+os.environ["DATASETS_FINGERPRINT_CACHING_DISABLED"] = "1"
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
+os.environ.setdefault("HF_DATASETS_CACHE", "/tmp/hf_datasets_cache_v65")
+# Cria o dir de cache se não existir (limpa cache antigo periodicamente)
+try:
+    cache_dir = Path(os.environ["HF_DATASETS_CACHE"])
+    cache_dir.mkdir(parents=True, exist_ok=True)
+except Exception:
+    pass
+
 sys.path.insert(0, str(SRC_ROOT))
 
 from bigru_t.utils.xeon_runtime import (  # noqa: E402
@@ -191,7 +212,11 @@ LOSS_HISTORY_WINDOW = 8
 PUNISHMENT_WINDOW = 12
 
 # V2-dynamic-memory — Buffer sliding window (evita OOM em treino longo)
-MAX_BUFFER_SIZE = 256
+# V6.5-V2-metrics-FIX-4: reduzido de 256 para 128 (OOM-killer mitigation).
+# O buffer_4d só precisa conter amostras recentes para que o SOM compute
+# métricas (QE, TE, KL, VE) — os pesos do SOM já capturam o conhecimento
+# acumulado de todas as amostras históricas.
+MAX_BUFFER_SIZE = 128
 
 # Streaming — User requirement: "streaming de 100 em 100 samples"
 STREAM_BATCH_SIZE = 100
@@ -205,13 +230,32 @@ MAX_SAMPLES_PUNICAO = 2000
 # User requirement: "não reduzir tempo e não gerar dados sintéticos" +
 # "todo streaming (FASE1 e da FASE2) deve ter pausa para dar tempo de conclusão
 # de processamento continuando após conclusão"
-# V6.5-V2-metrics-FIX-2: pausas reduzidas para caber em 20min de treino
-# (container kills processes after ~10min se não estiver em foreground).
-# As pausas ainda garantem tempo para processamento, mas são mais curtas.
-INTER_BATCH_PAUSE_S = 0.1          # reduzido de 0.5 (ainda há pausa)
-INTER_DATASET_PAUSE_S = 0.5        # reduzido de 2.0
-INTER_STREAM_BATCH_PAUSE_S = 0.2   # reduzido de 1.0
-POST_PROCESSING_PAUSE_S = 0.3      # reduzido de 1.5
+# V6.5-V2-metrics-FIX-4 (latest user requirement):
+#   "FASE2 PUNIÇÃO é mais pesada é pode exigir pausas do streaming até
+#    concluir o processamento".
+# Pausas separadas para FASE1 (CONHECIMENTO) e FASE2 (PUNITIVA):
+#   - FASE1: pausas moderadas (SOM-only, sem hypothesis layer)
+#   - FASE2: pausas maiores (16 hipóteses × 30 steps × 3 trials + EWC + revival)
+INTER_BATCH_PAUSE_S_FASE1 = 0.15      # CONHECIMENTO: leve
+INTER_BATCH_PAUSE_S_FASE2 = 0.60      # PUNITIVA: 4x maior (heavier processing)
+INTER_DATASET_PAUSE_S_FASE1 = 0.5
+INTER_DATASET_PAUSE_S_FASE2 = 1.5     # PUNITIVA: 3x maior
+INTER_STREAM_BATCH_PAUSE_S_FASE1 = 0.3
+INTER_STREAM_BATCH_PAUSE_S_FASE2 = 1.2  # PUNITIVA: 4x maior
+POST_PROCESSING_PAUSE_S_FASE1 = 0.4
+POST_PROCESSING_PAUSE_S_FASE2 = 1.5   # PUNITIVA: ~4x maior
+# Compatibilidade (mantém nomes antigos apontando para FASE1 — usados em
+# código legado que não diferencia fases)
+INTER_BATCH_PAUSE_S = INTER_BATCH_PAUSE_S_FASE1
+INTER_DATASET_PAUSE_S = INTER_DATASET_PAUSE_S_FASE1
+INTER_STREAM_BATCH_PAUSE_S = INTER_STREAM_BATCH_PAUSE_S_FASE1
+POST_PROCESSING_PAUSE_S = POST_PROCESSING_PAUSE_S_FASE1
+
+# V6.5-V2-metrics-FIX-4 — auto-revive config
+# User requirement: "distribuindo o processamento paralelamente".
+# Quando dead_rate > 50% e passou o cooldown, revive neurônios mortos.
+AUTO_REVIVE_DEAD_RATE_THRESHOLD = 0.5
+AUTO_REVIVE_COOLDOWN_STEPS = 200
 
 # Storage critical
 STORAGE_CRITICAL_PCT = 90
@@ -1158,13 +1202,13 @@ def run_fase_conhecimento(
                             })
 
                         step += 1
-                        time.sleep(INTER_BATCH_PAUSE_S)
+                        time.sleep(INTER_BATCH_PAUSE_S_FASE1)
                     except Exception as e:
                         logger.error(f"[V6.5-V2] Batch error: {e}")
                         traceback.print_exc()
                         continue
 
-                time.sleep(INTER_STREAM_BATCH_PAUSE_S)
+                time.sleep(INTER_STREAM_BATCH_PAUSE_S_FASE1)
                 # V2-dynamic-memory — Buffer sliding window: trunca para os
                 # últimos MAX_BUFFER_SIZE amostras após cada chunk.
                 # Os pesos do SOM já capturam o conhecimento acumulado,
@@ -1241,6 +1285,31 @@ def run_fase_conhecimento(
                 except Exception as e:
                     logger.warning(f"[V6.5-V2-metrics-FIX-2] Failed to compute SOM metrics: {e}")
 
+                # V6.5-V2-metrics-FIX-4 — Auto-revive neurônios mortos
+                # User requirement: "APRIMORAR (...) a ativação e uso e acesso
+                # dos neurônios (apenas dois estão sendo ativados:
+                # neurons_active=2/864) distribuindo o processamento paralelamente".
+                # O conscience mechanism (DeSieno 1988) já força distribuição
+                # uniforme de BMU, mas como safety net adicional, revive
+                # explicitamente neurônios que ainda estão mortos após o cooldown.
+                try:
+                    revival = kls.auto_revive_if_needed(
+                        dead_rate_threshold=AUTO_REVIVE_DEAD_RATE_THRESHOLD,
+                        min_steps_between_revivals=AUTO_REVIVE_COOLDOWN_STEPS,
+                    )
+                    if revival.get("action") == "auto_revived":
+                        logger.info(
+                            f"[V6.5-V2-metrics-FIX-4] AUTO-REVIVE triggered: "
+                            f"n_revived={revival['n_revived']}/{revival['n_total']}, "
+                            f"dead_rate {revival['dead_rate_before']:.3f} → "
+                            f"{revival['dead_rate_after']:.3f}, "
+                            f"steps_since_last={revival['steps_since_last_revival']}"
+                        )
+                except Exception as revive_err:
+                    logger.warning(
+                        f"[V6.5-V2-metrics-FIX-4] auto_revive_if_needed failed: {revive_err}"
+                    )
+
                 # Aggressive memory cleanup between chunks
                 if chunk_idx_global % 2 == 0:
                     aggressive_memory_cleanup()
@@ -1253,13 +1322,13 @@ def run_fase_conhecimento(
                     # V6.5-V2-metrics-FIX: pausa pós-processamento para dar tempo
                     # de conclusão (user requirement: "todo streaming deve ter
                     # pausa para dar tempo de conclusão de processamento").
-                    time.sleep(POST_PROCESSING_PAUSE_S)
+                    time.sleep(POST_PROCESSING_PAUSE_S_FASE1)
         except Exception as e:
             logger.error(f"[V6.5-V2] Dataset {dataset_name} failed: {e}")
             traceback.print_exc()
             streaming_failures[dataset_name] += 1
 
-        time.sleep(INTER_DATASET_PAUSE_S)
+        time.sleep(INTER_DATASET_PAUSE_S_FASE1)
         # V6.5-V2-metrics-FIX-2 — Save state after each dataset to preserve
         # progress in case the process is killed by container timeout.
         # User requirement: "o estado do modelo deve ser contínuo" — saving
@@ -1340,6 +1409,266 @@ def run_fase_conhecimento(
     }
 
 
+# ============================================================================
+# 9.5 — V6.5-V2-metrics-FIX-4: Sumário final da FASE2
+# ============================================================================
+def build_fase2_final_summary(
+    kls: KohonenLearningSystemV2,
+    som_metrics_log: List[Dict[str, Any]],
+    punishment_log: List[Dict[str, Any]],
+    hypotheses_log: List[Dict[str, Any]],
+    delta_applications_log: List[Dict[str, Any]],
+    elapsed_s: float,
+) -> Dict[str, Any]:
+    """V6.5-V2-metrics-FIX-4 — Constrói sumário final da FASE2 mostrando evolução.
+
+    User requirement: "ao final da FASE2 mostrar evolução de métricas e dos
+    indicadores e da taxa de aprendizagem".
+
+    Extrai trajetória temporal das métricas SOM (QE, TE, KL, VE), indicadores
+    de falha (dead_rate, collapse, stagnation, crossing), taxa de aprendizado
+    (α_t, σ_t) e estatísticas do conscience mechanism (neurons_active,
+    uniformity_score). Compara início vs fim para mostrar evolução.
+
+    Returns:
+        Dict com:
+          - summary_lines: List[str] — linhas formatadas para logger.info
+          - metrics_evolution: Dict com first/last/delta de cada métrica
+          - learning_rate_evolution: Dict com α_t, σ_t no início e fim
+          - indicators_evolution: Dict com indicadores de falha no início e fim
+          - neuron_activation_evolution: Dict com neurons_active no início e fim
+          - punishment_stats: Dict com estatísticas de punição
+    """
+    summary_lines: List[str] = []
+
+    # 1. Trajetória das métricas principais (QE, TE, KL, VE)
+    def _safe_get(log_list, key, idx):
+        if not log_list or idx >= len(log_list):
+            return 0.0
+        try:
+            return float(log_list[idx].get(key, 0.0))
+        except (TypeError, ValueError):
+            return 0.0
+
+    n_logs = len(som_metrics_log)
+    first_idx = 0
+    last_idx = max(0, n_logs - 1)
+
+    metrics_first = {
+        "QE": _safe_get(som_metrics_log, "quantization_error", first_idx),
+        "TE": _safe_get(som_metrics_log, "topological_error", first_idx),
+        "KL": _safe_get(som_metrics_log, "kaski_lagus_error", first_idx),
+        "VE": _safe_get(som_metrics_log, "explained_variance_share", first_idx),
+    }
+    metrics_last = {
+        "QE": _safe_get(som_metrics_log, "quantization_error", last_idx),
+        "TE": _safe_get(som_metrics_log, "topological_error", last_idx),
+        "KL": _safe_get(som_metrics_log, "kaski_lagus_error", last_idx),
+        "VE": _safe_get(som_metrics_log, "explained_variance_share", last_idx),
+    }
+    metrics_delta = {
+        k: metrics_last[k] - metrics_first[k] for k in metrics_first
+    }
+
+    # 2. Indicadores de falha
+    first_failures = som_metrics_log[first_idx].get("failure_indicators", []) if som_metrics_log else []
+    last_failures = som_metrics_log[last_idx].get("failure_indicators", []) if som_metrics_log else []
+    first_health = som_metrics_log[first_idx].get("overall_health", "unknown") if som_metrics_log else "unknown"
+    last_health = som_metrics_log[last_idx].get("overall_health", "unknown") if som_metrics_log else "unknown"
+
+    # 3. Ativação de neurônios (conscience mechanism)
+    first_neurons_active = _safe_get(som_metrics_log, "n_active_neurons_bmu", first_idx)
+    last_neurons_active = _safe_get(som_metrics_log, "n_active_neurons_bmu", last_idx)
+    first_neurons_total = _safe_get(som_metrics_log, "n_total_neurons_bmu", first_idx) or 864
+    last_neurons_total = _safe_get(som_metrics_log, "n_total_neurons_bmu", last_idx) or 864
+
+    # 4. Relatório paralelo final do SOM (conscience + uniformity)
+    try:
+        parallel_report = kls.parallel_neuron_activation_report()
+    except Exception:
+        parallel_report = {}
+
+    # 5. Taxa de aprendizado (α_t, σ_t) do SOM
+    try:
+        som_metrics = kls.som.get_metrics()
+        alpha_t = som_metrics.get("alpha_t_effective", 0.0)
+        sigma_t = som_metrics.get("sigma_t_effective", 0.0)
+        alpha0 = som_metrics.get("alpha0", 0.5)
+        sigma0 = som_metrics.get("sigma0", 3.0)
+        som_t = som_metrics.get("t", 0)
+    except Exception:
+        alpha_t = sigma_t = alpha0 = sigma0 = som_t = 0.0
+
+    # 6. Estatísticas de punição
+    n_punishments = len(punishment_log)
+    n_train_hyp_calls = len(hypotheses_log)
+    n_delta_apps = len(delta_applications_log)
+    # Taxa de sucesso das aplicações de delta (acc_after > acc_before)
+    delta_success = 0
+    if delta_applications_log:
+        for d in delta_applications_log:
+            try:
+                if float(d.get("acc_after", 0.0)) > float(d.get("acc_before", 0.0)):
+                    delta_success += 1
+            except (TypeError, ValueError):
+                pass
+    delta_success_rate = float(delta_success / max(1, n_delta_apps))
+
+    # 7. Hipóteses — evolução da loss
+    if hypotheses_log:
+        loss_first = float(hypotheses_log[0].get("loss_initial", 0.0))
+        loss_last_init = float(hypotheses_log[-1].get("loss_initial", 0.0))
+        loss_last_final = float(hypotheses_log[-1].get("loss_final", 0.0))
+    else:
+        loss_first = loss_last_init = loss_last_final = 0.0
+
+    # ===================== MONTAGEM DAS LINHAS DE SUMÁRIO =====================
+    summary_lines.append(f"  Duração total: {elapsed_s:.1f}s")
+    summary_lines.append(f"  Logs de métricas computados: {n_logs}")
+    summary_lines.append("")
+    summary_lines.append("  ─── EVOLUÇÃO DAS MÉTRICAS PRINCIPAIS (início → fim) ───")
+    summary_lines.append(
+        f"  QE  (Quantization Error): {metrics_first['QE']:.4f} → "
+        f"{metrics_last['QE']:.4f}  (Δ={metrics_delta['QE']:+.4f})"
+    )
+    summary_lines.append(
+        f"  TE  (Topological Error) : {metrics_first['TE']:.4f} → "
+        f"{metrics_last['TE']:.4f}  (Δ={metrics_delta['TE']:+.4f})"
+    )
+    summary_lines.append(
+        f"  KL  (Kaski-Lagus)       : {metrics_first['KL']:.4f} → "
+        f"{metrics_last['KL']:.4f}  (Δ={metrics_delta['KL']:+.4f})"
+    )
+    summary_lines.append(
+        f"  VE  (Explained Variance): {metrics_first['VE']:.4f} → "
+        f"{metrics_last['VE']:.4f}  (Δ={metrics_delta['VE']:+.4f})"
+    )
+    summary_lines.append("")
+    summary_lines.append("  ─── INDICADORES DE FALHA ───")
+    summary_lines.append(
+        f"  Overall health: {first_health} → {last_health}"
+    )
+    summary_lines.append(
+        f"  Failure indicators (início): {len(first_failures)} — {first_failures[:3]}"
+    )
+    summary_lines.append(
+        f"  Failure indicators (fim)   : {len(last_failures)} — {last_failures[:3]}"
+    )
+    summary_lines.append("")
+    summary_lines.append("  ─── ATIVAÇÃO DE NEURÔNIOS (Conscience Mechanism) ───")
+    summary_lines.append(
+        f"  Neurons ativos (BMU): {int(first_neurons_active)}/{int(first_neurons_total)} "
+        f"→ {int(last_neurons_active)}/{int(last_neurons_total)}"
+    )
+    if parallel_report:
+        summary_lines.append(
+            f"  Uniformity score (fim): {parallel_report.get('uniformity_score', 0.0):.4f} "
+            f"(1.0 = perfeitamente uniforme)"
+        )
+        summary_lines.append(
+            f"  Conscience bias mean/std: "
+            f"{parallel_report.get('conscience_bias_mean', 0.0):.6f} / "
+            f"{parallel_report.get('conscience_bias_std', 0.0):.6f} "
+            f"(deve tender a 0)"
+        )
+        summary_lines.append(
+            f"  Win count max/mean: "
+            f"{parallel_report.get('max_win_count', 0.0):.0f} / "
+            f"{parallel_report.get('mean_win_count', 0.0):.2f}"
+        )
+    summary_lines.append("")
+    summary_lines.append("  ─── TAXA DE APRENDIZADO (Kohonen schedule) ───")
+    summary_lines.append(
+        f"  α_t (learning rate): α₀={alpha0:.4f} → α_t={alpha_t:.6f} "
+        f"(floor=0.001, decai em exp(-t/2000))"
+    )
+    summary_lines.append(
+        f"  σ_t (neighborhood) : σ₀={sigma0:.4f} → σ_t={sigma_t:.6f} "
+        f"(floor=0.1, decai em exp(-t/1000))"
+    )
+    summary_lines.append(f"  SOM t (updates)    : {som_t}")
+    summary_lines.append("")
+    summary_lines.append("  ─── ESTATÍSTICAS DE PUNIÇÃO ───")
+    summary_lines.append(f"  Total punishment events: {n_punishments}")
+    summary_lines.append(f"  Hypotheses trainings  : {n_train_hyp_calls}")
+    summary_lines.append(f"  Delta applications    : {n_delta_apps}")
+    summary_lines.append(
+        f"  Delta success rate    : {delta_success_rate:.2%} "
+        f"({delta_success}/{n_delta_apps} melhoraram acurácia)"
+    )
+    if hypotheses_log:
+        summary_lines.append(
+            f"  Loss inicial primeira chamada: {loss_first:.6f}"
+        )
+        summary_lines.append(
+            f"  Loss inicial última chamada : {loss_last_init:.6f} "
+            f"→ final: {loss_last_final:.6f}"
+        )
+    summary_lines.append("")
+    summary_lines.append("  ─── HIPÓTESES (configuração final) ───")
+    try:
+        v2_metrics = kls.get_v2_metrics()
+        summary_lines.append(
+            f"  n_hypotheses ativas: {v2_metrics.get('n_hypotheses', 0)} / "
+            f"max {v2_metrics.get('max_n_hypotheses', 0)}"
+        )
+        summary_lines.append(
+            f"  hyp_train_steps atual: {v2_metrics.get('hyp_train_steps', 0)}"
+        )
+        summary_lines.append(
+            f"  total_hyp_steps_executed: "
+            f"{v2_metrics.get('total_hyp_steps_executed', 0)}"
+        )
+        summary_lines.append(
+            f"  n_adaptations dinâmicas: "
+            f"{v2_metrics.get('dynamic_adaptation', {}).get('n_adaptations', 0)}"
+        )
+        summary_lines.append(
+            f"  EWC reference set: {v2_metrics.get('ewc_reference_set', False)}"
+        )
+    except Exception:
+        pass
+
+    return {
+        "summary_lines": summary_lines,
+        "metrics_evolution": {
+            "first": metrics_first,
+            "last": metrics_last,
+            "delta": metrics_delta,
+        },
+        "learning_rate_evolution": {
+            "alpha0": alpha0,
+            "alpha_t_final": alpha_t,
+            "sigma0": sigma0,
+            "sigma_t_final": sigma_t,
+            "som_t": som_t,
+        },
+        "indicators_evolution": {
+            "first_health": first_health,
+            "last_health": last_health,
+            "first_failures": first_failures,
+            "last_failures": last_failures,
+            "first_n_failures": len(first_failures),
+            "last_n_failures": len(last_failures),
+        },
+        "neuron_activation_evolution": {
+            "first_active": int(first_neurons_active),
+            "last_active": int(last_neurons_active),
+            "total": int(last_neurons_total),
+            "parallel_report_final": parallel_report,
+        },
+        "punishment_stats": {
+            "n_punishments": n_punishments,
+            "n_train_hyp_calls": n_train_hyp_calls,
+            "n_delta_apps": n_delta_apps,
+            "delta_success_rate": delta_success_rate,
+            "loss_first_initial": loss_first,
+            "loss_last_initial": loss_last_init,
+            "loss_last_final": loss_last_final,
+        },
+    }
+
+
 # ============================================================================
 # 10. PHASE 2 — TREINAMENTO COM PUNIÇÃO (16 hipóteses × 3 tentativas)
 # ============================================================================
@@ -1606,13 +1935,35 @@ def run_fase_punicão(
                         traceback.print_exc()
 
                     step += 1
-                    time.sleep(INTER_BATCH_PAUSE_S)
+                    # V6.5-V2-metrics-FIX-4 — pausa maior na FASE2 (PUNITIVA)
+                    # User requirement: "FASE2 PUNIÇÃO é mais pesada é pode exigir
+                    # pausas do streaming até concluir o processamento".
+                    time.sleep(INTER_BATCH_PAUSE_S_FASE2)
                 except Exception as e:
                     logger.error(f"[V6.5-V2] Batch error in PUNIÇÃO: {e}")
                     traceback.print_exc()
                     continue
 
-            time.sleep(INTER_STREAM_BATCH_PAUSE_S)
+            # V6.5-V2-metrics-FIX-4 — Auto-revive neurônios mortos na FASE2
+            # (PUNITIVA também deve distribuir processamento paralelamente)
+            try:
+                revival = kls.auto_revive_if_needed(
+                    dead_rate_threshold=AUTO_REVIVE_DEAD_RATE_THRESHOLD,
+                    min_steps_between_revivals=AUTO_REVIVE_COOLDOWN_STEPS,
+                )
+                if revival.get("action") == "auto_revived":
+                    logger.info(
+                        f"[V6.5-V2-metrics-FIX-4] PUNIÇÃO AUTO-REVIVE: "
+                        f"n_revived={revival['n_revived']}/{revival['n_total']}, "
+                        f"dead_rate {revival['dead_rate_before']:.3f} → "
+                        f"{revival['dead_rate_after']:.3f}"
+                    )
+            except Exception as revive_err:
+                logger.warning(
+                    f"[V6.5-V2-metrics-FIX-4] PUNIÇÃO auto_revive failed: {revive_err}"
+                )
+
+            time.sleep(INTER_STREAM_BATCH_PAUSE_S_FASE2)
             # V2-dynamic-memory — Buffer sliding window na PUNIÇÃO também
             if len(kls.buffer_4d) > MAX_BUFFER_SIZE:
                 overflow = len(kls.buffer_4d) - MAX_BUFFER_SIZE
@@ -1629,8 +1980,9 @@ def run_fase_punicão(
                     kls.aggressive_cleanup()
                 except Exception:
                     pass
-                # V6.5-V2-metrics-FIX: pausa pós-processamento (user requirement)
-                time.sleep(POST_PROCESSING_PAUSE_S)
+                # V6.5-V2-metrics-FIX-4: pausa pós-processamento maior na FASE2
+                # (user requirement: "FASE2 PUNIÇÃO é mais pesada")
+                time.sleep(POST_PROCESSING_PAUSE_S_FASE2)
     except Exception as e:
         logger.error(f"[V6.5-V2] PUNIÇÃO dataset failed: {e}")
         traceback.print_exc()
@@ -1645,6 +1997,24 @@ def run_fase_punicão(
     logger.info(f"  Hypotheses trainings: {len(hypotheses_log)}")
     logger.info(f"  Delta applications: {len(delta_applications_log)}")
 
+    # V6.5-V2-metrics-FIX-4 — Sumário final da FASE2
+    # User requirement: "ao final da FASE2 mostrar evolução de métricas e dos
+    # indicadores e da taxa de aprendizagem".
+    fase2_summary = build_fase2_final_summary(
+        kls=kls,
+        som_metrics_log=som_metrics_log,
+        punishment_log=punishment_log,
+        hypotheses_log=hypotheses_log,
+        delta_applications_log=delta_applications_log,
+        elapsed_s=t_elapsed,
+    )
+    logger.info("\n" + "=" * 80)
+    logger.info("[V6.5-V2-metrics-FIX-4] FASE 2 — EVOLUÇÃO FINAL DE MÉTRICAS")
+    logger.info("=" * 80)
+    for line in fase2_summary["summary_lines"]:
+        logger.info(line)
+    logger.info("=" * 80 + "\n")
+
     return {
         "phase": "TREINAMENTO_COM_PUNICAO",
         "dataset": PUNICAO_DATASET,
@@ -1666,6 +2036,8 @@ def run_fase_punicão(
         ),
         "som_metric_history": kls.get_som_metric_history(),
         "final_v2_state": kls.get_v2_metrics(),
+        # V6.5-V2-metrics-FIX-4 — sumário final da FASE2
+        "fase2_summary": fase2_summary,
     }
 
 
@@ -2108,7 +2480,17 @@ def main() -> int:
         # + Goose VQ, fornecendo representação compacta do estado do SOM.
         # O compressor já sanitiza NaN/Inf internamente (torch.nan_to_num).
         enable_vqvae2=True,   # REATIVADO (was False in V6.5-V2-metrics-FIX)
-        enable_reasoning=True,
+        # V6.5-V2-metrics-FIX-4: reasoning_engine desabilitado para mitigar
+        # OOM-killer (User requirement implícito: "investigar e corrigir
+        # falhas de lógica e bugs que estejam causando alto consumo de memória
+        # sem distorcer a arquitetura Kohonen"). O ReasoningEngine cria um
+        # ThreadPoolExecutor(4 workers) + ToolAgentCoordinator que consome
+        # ~100-200MB adicionais. Como o reasoning_engine é OPCIONAL e não
+        # afeta o aprendizado do SOM (apenas gera tags <think>/<plan>/<answer>
+        # para predições), desabilitá-lo preserva a arquitetura Kohonen e
+        # libera memória para o streaming de 8000+2000 samples.
+        # Para reativar: mudar para True (requer ≥6GB cgroup).
+        enable_reasoning=False,
         enable_w8a8=False,    # W8A8 permanece desabilitado (não essencial para Kohonen)
         vqvae2_code_dim=16,
         vqvae2_num_codes_top=64,

v6_5_v2_attention_eval.json

@@ -3,18 +3,18 @@
   "user_requirement": "verificar se o mecanismo de atenção está ativo e acessado logicamente funcional",
   "metrics": {
     "active": true,
-    "n_calls": 10136,
+    "n_calls": 10000,
     "n_errors": 0,
-    "last_norm_in": 109.68505859375,
-    "last_norm_out": 113.1070785522461,
+    "last_norm_in": 109.84779357910156,
+    "last_norm_out": 114.40419006347656,
     "last_attn_activated": true,
-    "last_attn_diff_norm": 116.01240539550781,
+    "last_attn_diff_norm": 114.49571990966797,
     "n_heads": 8,
     "logic_functional": true
   },
   "active": true,
   "logic_functional": true,
-  "n_calls": 10136,
+  "n_calls": 10000,
   "n_errors": 0,
   "n_heads": 8,
   "assessment": "PASS"

v6_5_v2_predict_fix_eval.json

@@ -6,7 +6,7 @@
     {
       "query": "o gato dorme na cama",
       "prediction": "short_text",
-      "probability": 0.431580513715744,
+      "probability": 0.443034291267395,
       "is_gato_hardcoded": false,
       "is_cachorro_hardcoded": false,
       "is_registry_label": true,
@@ -15,7 +15,7 @@
     {
       "query": "calcule dois mais dois",
       "prediction": "short_text",
-      "probability": 0.43154773116111755,
+      "probability": 0.443034291267395,
       "is_gato_hardcoded": false,
       "is_cachorro_hardcoded": false,
       "is_registry_label": true,
@@ -24,7 +24,7 @@
     {
       "query": "qual é a capital do brasil",
       "prediction": "short_text",
-      "probability": 0.4315149188041687,
+      "probability": 0.443034291267395,
       "is_gato_hardcoded": false,
       "is_cachorro_hardcoded": false,
       "is_registry_label": true,
@@ -33,7 +33,7 @@
     {
       "query": "explique o que é uma rede neural",
       "prediction": "short_text",
-      "probability": 0.43148213624954224,
+      "probability": 0.443034291267395,
       "is_gato_hardcoded": false,
       "is_cachorro_hardcoded": false,
       "is_registry_label": true,
@@ -42,7 +42,7 @@
     {
       "query": "olá como você está",
       "prediction": "short_text",
-      "probability": 0.431449294090271,
+      "probability": 0.443034291267395,
       "is_gato_hardcoded": false,
       "is_cachorro_hardcoded": false,
       "is_registry_label": true,
@@ -51,7 +51,7 @@
     {
       "query": "traduza hello para portugues",
       "prediction": "short_text",
-      "probability": 0.43141648173332214,
+      "probability": 0.443034291267395,
       "is_gato_hardcoded": false,
       "is_cachorro_hardcoded": false,
       "is_registry_label": true,

v6_5_v2_report.json

@@ -1,6 +1,6 @@
 {
   "version": "V6.5-V2",
-  "timestamp": "2026-08-09T02:15:13.445620",
+  "timestamp": "2026-08-09T03:12:19.635254",
   "config": {
     "som_grid": [
       6,
@@ -54,10 +54,10 @@
     "init_done": true
   },
   "fp16_benchmark": {
-    "best_time_ms": 98.1761529983487,
-    "avg_time_ms": 100.25469900028838,
-    "best_tflops": 1.3037789329772673,
-    "avg_tflops": 1.276748135263284,
+    "best_time_ms": 96.71666700160131,
+    "avg_time_ms": 98.70659000080195,
+    "best_tflops": 1.3234533815963772,
+    "avg_tflops": 1.296772586298038,
     "matrix_size": 4000.0
   },
   "v2_verification": {
@@ -86,13 +86,13 @@
   "fase_1_conhecimento_summary": {
     "total_samples": 8000,
     "meta_atingida": true,
-    "elapsed_s": 462.4169614315033,
+    "elapsed_s": 460.5420436859131,
     "storage_critical_stopped": false
   },
   "fase_2_punicão_summary": {
     "total_samples": 2000,
     "meta_atingida": true,
-    "elapsed_s": 707.4351425170898,
+    "elapsed_s": 728.1188757419586,
     "punishment_events": 120,
     "hypotheses_trainings": 60,
     "delta_applications": 60,
@@ -101,7 +101,7 @@
   "attention_eval_summary": {
     "active": true,
     "logic_functional": true,
-    "n_calls": 10136,
+    "n_calls": 10000,
     "assessment": "PASS"
   },
   "predict_fix_summary": {
@@ -114,18 +114,18 @@
   },
   "user_questions_summary": {
     "n_with_answer": 3,
-    "n_with_think": 3,
+    "n_with_think": 0,
     "answer_rate": 1.0,
-    "think_rate": 1.0,
-    "avg_latency_ms": 8.49151611328125,
-    "avg_reasoning_length": 1026.0
+    "think_rate": 0.0,
+    "avg_latency_ms": 4.7105153401692705,
+    "avg_reasoning_length": 69.0
   },
   "model_states_saved_to": "/home/z/my-project/BiGRU_T_version/v6_5_v2_model_states.pt",
   "save_info": {
     "saved": true,
     "path": "/home/z/my-project/BiGRU_T_version/v6_5_v2_model_states.pt",
-    "size_mb": 220.156916,
-    "size_gb": 0.20503710582852364,
+    "size_mb": 220.15666,
+    "size_gb": 0.20503686740994453,
     "size_status": "OK",
     "size_within_1gb_limit": true,
     "reason": "end_of_training_v2",
@@ -149,16 +149,16 @@
     "training_ready": false,
     "classifier_trained": true,
     "ewc_reference_set": true,
-    "buffer_size": 256,
+    "buffer_size": 128,
     "total_hyp_steps_executed": 4550,
     "n_train_hyp_calls": 60,
     "dynamic_adaptation": {
       "loss_history_len": 8,
       "loss_stats": {
-        "slope": -0.0011915401333854312,
-        "volatility": 0.00412979198977771,
-        "mean": 0.6900820210576057,
-        "std": 0.0028498952028533134,
+        "slope": -0.00034456806523459297,
+        "volatility": 0.0024739346406965515,
+        "mean": 0.6898908242583275,
+        "std": 0.0017067448084313731,
         "n": 8
       },
       "punishment_rate": 1.0,
@@ -189,10 +189,10 @@
           "adapted": false,
           "rules_fired": [],
           "loss_stats": {
-            "slope": -0.0005415294851575579,
-            "volatility": 0.0021399774425789105,
-            "mean": 0.6917464286088943,
-            "std": 0.0014803217532075566,
+            "slope": -0.00037475568907601494,
+            "volatility": 0.0033018073049031742,
+            "mean": 0.6912502944469452,
+            "std": 0.0022823752717213938,
             "n": 8
           },
           "punishment_rate": 1.0
@@ -213,10 +213,10 @@
           "adapted": false,
           "rules_fired": [],
           "loss_stats": {
-            "slope": -0.0007950464884440104,
-            "volatility": 0.0028802925294023492,
-            "mean": 0.6910811960697174,
-            "std": 0.0019905160062500473,
+            "slope": -0.0005504623765037174,
+            "volatility": 0.003395094498254662,
+            "mean": 0.6910898759961128,
+            "std": 0.002346315435793899,
             "n": 8
           },
           "punishment_rate": 1.0
@@ -237,10 +237,10 @@
           "adapted": false,
           "rules_fired": [],
           "loss_stats": {
-            "slope": -0.0007950464884440104,
-            "volatility": 0.0028802925294023492,
-            "mean": 0.6910811960697174,
-            "std": 0.0019905160062500473,
+            "slope": -0.0005504623765037174,
+            "volatility": 0.003395094498254662,
+            "mean": 0.6910898759961128,
+            "std": 0.002346315435793899,
             "n": 8
           },
           "punishment_rate": 1.0
@@ -261,10 +261,10 @@
           "adapted": false,
           "rules_fired": [],
           "loss_stats": {
-            "slope": -0.0011915401333854312,
-            "volatility": 0.00412979198977771,
-            "mean": 0.6900820210576057,
-            "std": 0.0028498952028533134,
+            "slope": -0.00034456806523459297,
+            "volatility": 0.0024739346406965515,
+            "mean": 0.6898908242583275,
+            "std": 0.0017067448084313731,
             "n": 8
           },
           "punishment_rate": 1.0
@@ -285,10 +285,10 @@
           "adapted": false,
           "rules_fired": [],
           "loss_stats": {
-            "slope": -0.0011915401333854312,
-            "volatility": 0.00412979198977771,
-            "mean": 0.6900820210576057,
-            "std": 0.0028498952028533134,
+            "slope": -0.00034456806523459297,
+            "volatility": 0.0024739346406965515,
+            "mean": 0.6898908242583275,
+            "std": 0.0017067448084313731,
             "n": 8
           },
           "punishment_rate": 1.0

v6_5_v2_user_questions.json

@@ -19,16 +19,16 @@
       "system_prompt_used": false,
       "few_shot_examples": false,
       "som_prediction": "short_text",
-      "reasoning_length": 1024,
-      "has_think": true,
-      "has_plan": true,
+      "reasoning_length": 69,
+      "has_think": false,
+      "has_plan": false,
       "has_answer": true,
-      "has_decompose": true,
-      "think_preview": "Analisando a query: 'Luva de Pedreiro Távila'\nIdentificando o tipo de problema e requisitos.\nDeterminando se ferramentas são necessárias.",
-      "answer_preview": "prediction=short_text | BMU=(0, 5, 5, 0)",
-      "raw_response_preview": "<think>\nAnalisando a query: 'Luva de Pedreiro Távila'\nIdentificando o tipo de problema e requisitos.\nDeterminando se ferramentas são necessárias.\n</think>\n<plan>\nPlano de resolução:\n1. Decompor o problema em sub-tarefas\n2. Identificar ferramentas necessárias (disponíveis: som_query, buffer_stats)\n3. Executar sub-tarefas em sequência\n4. Monitorar resultados\n5. Compor resposta final\n</plan>\n<decompose>\n- Processar: Luva de Pedreiro Távila\n</decompose>\n<execute>\nSub-tarefa 'Processar: Luva de Pedre...",
-      "n_tags": 4,
-      "latency_ms": 7.998943328857422
+      "has_decompose": false,
+      "think_preview": "",
+      "answer_preview": "ReasoningEngine disabled. SOM prediction: short_text",
+      "raw_response_preview": "<answer>ReasoningEngine disabled. SOM prediction: short_text</answer>",
+      "n_tags": 1,
+      "latency_ms": 4.777431488037109
     },
     {
       "query": "Lula reserva valor",
@@ -37,16 +37,16 @@
       "system_prompt_used": false,
       "few_shot_examples": false,
       "som_prediction": "short_text",
-      "reasoning_length": 994,
-      "has_think": true,
-      "has_plan": true,
+      "reasoning_length": 69,
+      "has_think": false,
+      "has_plan": false,
       "has_answer": true,
-      "has_decompose": true,
-      "think_preview": "Analisando a query: 'Lula reserva valor'\nIdentificando o tipo de problema e requisitos.\nDeterminando se ferramentas são necessárias.",
-      "answer_preview": "prediction=short_text | BMU=(0, 5, 5, 0)",
-      "raw_response_preview": "<think>\nAnalisando a query: 'Lula reserva valor'\nIdentificando o tipo de problema e requisitos.\nDeterminando se ferramentas são necessárias.\n</think>\n<plan>\nPlano de resolução:\n1. Decompor o problema em sub-tarefas\n2. Identificar ferramentas necessárias (disponíveis: som_query, buffer_stats)\n3. Executar sub-tarefas em sequência\n4. Monitorar resultados\n5. Compor resposta final\n</plan>\n<decompose>\n- Processar: Lula reserva valor\n</decompose>\n<execute>\nSub-tarefa 'Processar: Lula reserva valor' exe...",
-      "n_tags": 4,
-      "latency_ms": 8.686304092407227
+      "has_decompose": false,
+      "think_preview": "",
+      "answer_preview": "ReasoningEngine disabled. SOM prediction: short_text",
+      "raw_response_preview": "<answer>ReasoningEngine disabled. SOM prediction: short_text</answer>",
+      "n_tags": 1,
+      "latency_ms": 4.729270935058594
     },
     {
       "query": "Amazonas força-tarefa vítimas",
@@ -55,25 +55,25 @@
       "system_prompt_used": false,
       "few_shot_examples": false,
       "som_prediction": "short_text",
-      "reasoning_length": 1060,
-      "has_think": true,
-      "has_plan": true,
+      "reasoning_length": 69,
+      "has_think": false,
+      "has_plan": false,
       "has_answer": true,
-      "has_decompose": true,
-      "think_preview": "Analisando a query: 'Amazonas força-tarefa vítimas'\nIdentificando o tipo de problema e requisitos.\nDeterminando se ferramentas são necessárias.",
-      "answer_preview": "prediction=short_text | BMU=(0, 5, 5, 0)",
-      "raw_response_preview": "<think>\nAnalisando a query: 'Amazonas força-tarefa vítimas'\nIdentificando o tipo de problema e requisitos.\nDeterminando se ferramentas são necessárias.\n</think>\n<plan>\nPlano de resolução:\n1. Decompor o problema em sub-tarefas\n2. Identificar ferramentas necessárias (disponíveis: som_query, buffer_stats)\n3. Executar sub-tarefas em sequência\n4. Monitorar resultados\n5. Compor resposta final\n</plan>\n<decompose>\n- Processar: Amazonas força-tarefa vítimas\n</decompose>\n<execute>\nSub-tarefa 'Processar: A...",
-      "n_tags": 4,
-      "latency_ms": 8.789300918579102
+      "has_decompose": false,
+      "think_preview": "",
+      "answer_preview": "ReasoningEngine disabled. SOM prediction: short_text",
+      "raw_response_preview": "<answer>ReasoningEngine disabled. SOM prediction: short_text</answer>",
+      "n_tags": 1,
+      "latency_ms": 4.624843597412109
     }
   ],
   "summary": {
     "n_with_answer": 3,
-    "n_with_think": 3,
+    "n_with_think": 0,
     "answer_rate": 1.0,
-    "think_rate": 1.0,
-    "avg_latency_ms": 8.49151611328125,
-    "avg_reasoning_length": 1026.0
+    "think_rate": 0.0,
+    "avg_latency_ms": 4.7105153401692705,
+    "avg_reasoning_length": 69.0
   },
   "quality_assessment": {
     "model_not_helped": true,