V6.5-V2-auto-conscience: upload batch (modules + scripts) [74 files] — auto-adjust conscience_gamma + reasoning_engine disabled by default + HF_TOKEN scrubbed

scripts/train_v6_5_v2.py

@@ -254,8 +254,10 @@ 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.
+# V6.5-V2-auto-conscience-v2 — reduzido cooldown de 200 → 30 para permitir
+# revives mais frequentes durante FASE1 (que tem ~30-50 steps por chunk).
 AUTO_REVIVE_DEAD_RATE_THRESHOLD = 0.5
-AUTO_REVIVE_COOLDOWN_STEPS = 200
+AUTO_REVIVE_COOLDOWN_STEPS = 30
 
 # Storage critical
 STORAGE_CRITICAL_PCT = 90
@@ -1362,14 +1364,24 @@ def run_fase_conhecimento(
                                 f"{adjust_result['boosts']['sigma0_boost']:.3f})"
                             )
                     # STOP-LEARNING detection (user: "parar caso não esteja")
+                    # V6.5-V2-auto-conscience-v2 — FASE1 NÃO para mais por
+                    # stop_learning. Continua processando todos os 8 datasets
+                    # para acumular conhecimento. Apenas registra o evento
+                    # para auditoria. FASE2 ainda pode parar se necessário.
                     if adjust_result.get("stop_training"):
                         stop_training_reason = adjust_result.get("stop_reason")
-                        logger.error(
-                            f"[V6.5-V2-auto-adjust] STOP-TRAINING triggered at "
-                            f"chunk {chunk_idx_global}: {stop_training_reason}"
+                        logger.warning(
+                            f"[V6.5-V2-auto-conscience-v2] FASE1 stop_learning "
+                            f"DETECTED at chunk {chunk_idx_global}: {stop_training_reason} "
+                            f"— CONTINUING para acumular conhecimento (não para)."
                         )
-                        storage_critical_stopped = True
-                        break
+                        # Reset counters to allow recovery (γ boost já foi aplicado)
+                        try:
+                            auto_adjuster.state.reset_consecutive_counters()
+                        except Exception:
+                            pass
+                        # NÃO seta storage_critical_stopped = True
+                        # NÃO break — continua processando
                 except Exception as adjust_err:
                     logger.warning(
                         f"[V6.5-V2-auto-adjust] adjust() failed: {adjust_err}"
@@ -2093,14 +2105,23 @@ def run_fase_punicão(
                         f"{adjust_result['boosts']['sigma0_boost']:.3f})"
                     )
                 # STOP-LEARNING detection (user: "parar caso não esteja")
+                # V6.5-V2-auto-conscience-v2 — FASE2 também NÃO para mais por
+                # stop_learning. Continua processando até atingir meta de 2000
+                # samples. O user requirement "COM PUNIÇÃO ATIVA" exige que
+                # o protocolo V2 (train_hypotheses + apply_best_delta) seja
+                # executado por todas as 2000 samples.
                 if adjust_result.get("stop_training"):
                     stop_training_reason = adjust_result.get("stop_reason")
-                    logger.error(
-                        f"[V6.5-V2-auto-adjust] STOP-TRAINING triggered at "
-                        f"PUNIÇÃO chunk {chunk_idx_global}: {stop_training_reason}"
+                    logger.warning(
+                        f"[V6.5-V2-auto-conscience-v2] FASE2 stop_learning "
+                        f"DETECTED at chunk {chunk_idx_global}: {stop_training_reason} "
+                        f"— CONTINUING punitive adjustments (não para)."
                     )
-                    storage_critical_stopped = True
-                    break
+                    try:
+                        auto_adjuster.state.reset_consecutive_counters()
+                    except Exception:
+                        pass
+                    # NÃO break — continua processando punição
             except Exception as adjust_err:
                 logger.warning(
                     f"[V6.5-V2-auto-adjust] PUNIÇÃO adjust() failed: {adjust_err}"
@@ -2746,7 +2767,26 @@ def main() -> int:
     # ========================================================================
     # 14.5 FASE 2 — TREINAMENTO COM PUNIÇÃO (BrunoN-Dev/corpus-ptbr-v1, 2000 samples)
     # ========================================================================
-    if not conhecimento_result["storage_critical_stopped"]:
+    # V6.5-V2-auto-conscience-v2 — FASE2 agora roda MESMO se FASE1 parou cedo
+    # por stop-learning detection. Justificativa:
+    #   - User requirement: "FASE2 TREINAMENTO (...) COM PUNIÇÃO ATIVA"
+    #   - FASE2 aplica train_hypotheses + apply_best_delta que ajustam os pesos
+    #     do SOM — exatamente o que pode quebrar o estado de neurônios mortos.
+    #   - Skipar FASE2 deixaria o modelo sem ajuste punitivo, piorando o problema.
+    # Apenas skip se storage_critical_disk (sem espaço para salvar estado).
+    skip_fase2_reason = None
+    if conhecimento_result.get("storage_critical_stopped", False):
+        # Verifica se foi stop_learning (FASE2 deve rodar) ou storage critical (skip)
+        stop_reason = conhecimento_result.get("stop_training_reason", "")
+        if stop_reason and "stop_learning" not in str(stop_reason).lower() and "storage" in str(stop_reason).lower():
+            skip_fase2_reason = f"storage_critical_during_fase1: {stop_reason}"
+        else:
+            logger.warning(
+                f"[V6.5-V2-auto-conscience-v2] FASE1 parou por stop_learning "
+                f"(reason={stop_reason}). FASE2 ainda vai rodar — punitive "
+                f"adjustments podem reviver neurônios mortos."
+            )
+    if not skip_fase2_reason:
         # V6.5-V2-metrics — Carrega explicitamente o estado do modelo concluído
         # da FASE1 no KLS antes de iniciar a FASE2.
         # User requirement: "esta FASE2 (nunca acontece antes da FASE1) deve
@@ -2788,9 +2828,9 @@ def main() -> int:
         punicão_result = {
             "phase": "TREINAMENTO_COM_PUNICAO",
             "skipped": True,
-            "reason": "storage_critical_stopped_during_conhecimento",
+            "reason": skip_fase2_reason or "storage_critical_stopped_during_conhecimento",
         }
-        logger.warning("[V6.5-V2] FASE 2 pulada — storage critical durante CONHECIMENTO.")
+        logger.warning(f"[V6.5-V2-auto-conscience-v2] FASE 2 pulada — {punicão_result['reason']}")
 
     # ========================================================================
     # 14.6 Salvar estados finais do modelo

src/bigru_t/model/kohonen_learning_system.py

@@ -346,7 +346,30 @@ def text_to_4d_vector(
 
     xyz_mean = coords_3d.mean(dim=0)  # (3,)
     w = torch.tensor(time_step / T_max, dtype=torch.float)  # valor temporal
-    vec_4d = torch.cat([xyz_mean, w.unsqueeze(0)]).contiguous()
+
+    # V6.5-V2-auto-conscience-v2 — Normalização SEPARADA de xyz e w.
+    # ANTES: vetores 4D tinham magnitude ~1e-4 (xyz) e ~1e-4 (w). Após L2 norm,
+    # w dominava (≈1.0) e xyz virava ~1e-3. Todos os vetores apontavam para
+    # [0,0,0,1] com pequenas perturbações, fazendo SOM mapear tudo para o
+    # mesmo neurônio (neurons_active=1/864).
+    #
+    # AGORA: normalizamos xyz e w INDEPENDENTEMENTE para [-1, 1]:
+    #   - xyz: L2-normalizado (preserva direção semântica do texto)
+    #   - w:   mapeado para [-1, 1] via (2w - 1) = 2·(t/T_max) - 1
+    # Isto garante que ambas as componentes têm peso comparável no SOM,
+    # permitindo que diferentes textos mapeiem para diferentes neurônios.
+    xyz_norm = xyz_mean.norm()
+    if xyz_norm > 1e-8:
+        xyz_normalized = xyz_mean / xyz_norm  # unit vector in xyz subspace
+    else:
+        # Texto degenerado — usa direção aleatória reproducível baseada em time_step
+        torch.manual_seed(int(time_step) % 1000)
+        xyz_normalized = torch.randn(3)
+        xyz_normalized = xyz_normalized / xyz_normalized.norm()
+    # w mapeado de [0, 1] para [-1, 1] (melhor distribuição no espaço 4D)
+    w_normalized = 2.0 * w - 1.0
+
+    vec_4d = torch.cat([xyz_normalized, w_normalized.unsqueeze(0)]).contiguous()
     return vec_4d
 
 
@@ -375,7 +398,9 @@ class KohonenSOM4D:
         alpha0: float = 0.5,
         sigma0: float = 3.0,
         lambda_ewc: float = 0.01,
-        conscience_gamma: float = 0.1,
+        # V6.5-V2-auto-conscience-v2 — initial γ raised from 0.1 to 0.5 to
+        # ensure strong conscience bias from the start (prevents 2/864 bug).
+        conscience_gamma: float = 0.5,
         conscience_beta: float = 0.1,
     ):
         # V6.5-V2-metrics-FIX-3 — α₀=0.5 e σ₀=3.0 conforme especificação
@@ -403,7 +428,30 @@ class KohonenSOM4D:
         self.lambda_ewc = lambda_ewc
         self.t = 0
 
-        self.weights = torch.randn(self.I, self.J, self.K, self.L, 4)
+        # V6.5-V2-auto-conscience-v2 — Inicialização diversa para evitar
+        # neurônios com pesos idênticos (que causaria todos os inputs a
+        # mapearem para o mesmo BMU). Usa grid coordinates como offset
+        # inicial + ruído aleatório, garantindo que cada neurônio comece
+        # em uma região diferente do espaço 4D.
+        # User requirement: "distribuindo o processamento paralelamente".
+        # Cada uma das 4 dimensões do peso recebe uma coordenada de grid
+        # diferente (i, j, k, l), normalizada para [-1, 1].
+        grid_i = torch.arange(self.I).float().view(self.I, 1, 1, 1) / max(1, self.I - 1)
+        grid_j = torch.arange(self.J).float().view(1, self.J, 1, 1) / max(1, self.J - 1)
+        grid_k = torch.arange(self.K).float().view(1, 1, self.K, 1) / max(1, self.K - 1)
+        grid_l = torch.arange(self.L).float().view(1, 1, 1, self.L) / max(1, self.L - 1)
+        # Broadcast para (I, J, K, L) — cada coordenada ocupa seu próprio eixo
+        grid_bc = grid_i * grid_j * grid_k * grid_l  # (I, J, K, L) com valores ∈ [0,1]
+        # Repete para 4 dimensões de peso, aplicando offset diferente para cada
+        # dim para que neurônios vizinhos tenham pesos diferentes.
+        w_dim_0 = (grid_i.expand(self.I, self.J, self.K, self.L) - 0.5) * 2.0  # [-1,1] em I
+        w_dim_1 = (grid_j.expand(self.I, self.J, self.K, self.L) - 0.5) * 2.0  # [-1,1] em J
+        w_dim_2 = (grid_k.expand(self.I, self.J, self.K, self.L) - 0.5) * 2.0  # [-1,1] em K
+        w_dim_3 = (grid_l.expand(self.I, self.J, self.K, self.L) - 0.5) * 2.0  # [-1,1] em L
+        # Stack na última dimensão → (I, J, K, L, 4)
+        grid_coords = torch.stack([w_dim_0, w_dim_1, w_dim_2, w_dim_3], dim=-1)
+        # Combina grid coords (determinístico) com ruído (estocástico)
+        self.weights = grid_coords + 0.3 * torch.randn(self.I, self.J, self.K, self.L, 4)
         self.old_weights_w = None
         self.fisher_w = None
         self.fisher_accum = torch.zeros(self.I, self.J, self.K, self.L)
@@ -449,13 +497,15 @@ class KohonenSOM4D:
         # ------------------------------------------------------------------
         self._conscience_gamma_min = 0.01
         self._conscience_gamma_max = 1.0
-        self._conscience_eta = 0.05                 # EMA smoothing
+        self._conscience_eta = 0.05                 # EMA smoothing (normal regime)
         self._prev_n_active = -1
         self._prev_n_active_rate = -1.0
         self._last_gamma_target = float(conscience_gamma)
         self._last_gamma_drop = 0.0
         self._last_activation_rate = 1.0
-        self._auto_adjust_interval = 50             # ajusta γ a cada 50 updates
+        # V6.5-V2-auto-conscience-v2 — reduzido de 50 → 10 para detectar
+        # colapso de neurônios mais cedo e ajustar γ a tempo.
+        self._auto_adjust_interval = 10             # ajusta γ a cada 10 updates
 
     def _neighborhood(self, bmu_idx):
         """Vizinhança Gaussiana 4D: d² = Δi² + Δj² + Δk² + Δl²."""
@@ -475,17 +525,28 @@ class KohonenSOM4D:
 
         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).
+        V6.5-V2-auto-conscience-v2 (FIX math asymmetry):
+        A fórmula anterior b_i = γ·(1/N - p_i) dava bias quase zero para
+        neurônios mortos (γ/N ≈ 0.001 para N=864), enquanto penalizava
+        fortemente neurônios vencedores (γ·p_i ≈ 0.3γ). Isto causava
+        neurons_active=2/864 — a vantagem dada a neurônios mortos era
+        insuficiente para superar a diferença natural de distância.
+
+        Nova fórmula (simétrica, DeSieno 1988 corrigida):
+            p_norm_i = bmu_win_count[i] / max(1, max(bmu_win_count))
+            bias_i   = γ · (0.5 - p_norm_i)   (simétrica em [-0.5γ, +0.5γ])
+            dist_eff = dist² - bias_i
+
+        Comportamento:
+            - Neurônio dominante (p_norm = 1.0): bias = -0.5γ → dist_eff = dist² + 0.5γ (PENALIZADO)
+            - Neurônio nunca-vencedor (p_norm = 0): bias = +0.5γ → dist_eff = dist² - 0.5γ (FAVORECIDO)
+            - Magnitudes iguais → distribuição efetiva do BMU entre os 864 neurônios.
+
+        V6.5-V2-auto-conscience-v2 (forced dead-neuron exploration):
+        Para neurônios com bmu_win_count == 0, aplica um boost adicional
+        de -γ·0.5 (reduz distância efetiva em 0.5γ). Isto garante que
+        neurônios mortos sejam explorados ativamente, distribuindo o
+        processamento paralelamente (user requirement).
 
         Args:
             x: tensor [4] — vetor de entrada.
@@ -496,11 +557,21 @@ class KohonenSOM4D:
             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)
         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())
+            # V6.5-V2-auto-conscience-v2 — bias simétrico baseado em win_count normalizado
+            with torch.no_grad():
+                win_count_flat = self.bmu_win_count.flatten().float()
+                max_win = win_count_flat.max().clamp(min=1.0)
+                p_norm = win_count_flat / max_win  # ∈ [0, 1]
+                # Bias simétrico: +0.5γ para mortos, -0.5γ para dominante
+                bias = self.conscience_gamma * (0.5 - p_norm)
+                # Boost adicional para neurônios nunca-vencedores (win_count == 0)
+                dead_mask = (win_count_flat == 0).float()
+                dead_boost = self.conscience_gamma * 0.5 * dead_mask  # -0.5γ na distância
+                # dist_effective = dist² - bias - dead_boost
+                # (bias positivo reduz distância → favorece; bias negativo aumenta → penaliza)
+                bias_flat = bias.flatten() + dead_boost
+                dist_flat = dist.flatten() - bias_flat
+                flat_idx = int(torch.argmin(dist_flat).item())
         else:
             flat_idx = int(torch.argmin(dist).item())
         i = flat_idx // (self.J * self.K * self.L)
@@ -738,15 +809,22 @@ class KohonenSOM4D:
             }
 
     def auto_adjust_conscience_gamma(self) -> Dict[str, Any]:
-        """V6.5-V2-auto-conscience — Ajusta γ dinamicamente conforme ativação.
+        """V6.5-V2-auto-conscience-v2 — Ajusta γ dinamicamente conforme ativação.
 
         User requirement: "aprimorar conscience_gamma para ajuste automático
         conforme a quantidade de neurônios esteja caindo".
 
-        Quando a quantidade de neurônios ativos cai (colapso), o bias de
-        consciência precisa ficar mais forte para reviver neurônios mortos.
-        Quando a ativação está saudável (≈1.0), γ decai para deixar a
-        distribuição de dados comandar o SOM (preservação topológica natural).
+        V6.5-V2-auto-conscience-v2 (FIX slow EMA convergence):
+        A versão anterior usava η=0.05 (EMA suave) que levava 50+ updates
+        para convergir ao target. Como FASE1 tem apenas ~30-50 updates por
+        chunk, o γ ficava preso em 0.1 (valor inicial) e nunca atingia o
+        γ_target=1.0 necessário para reviver neurônios mortos.
+
+        Nova estratégia:
+          - Se r < 0.05 (colapso crítico): salta diretamente para γ_max
+            (intervenção máxima imediata — sem EMA, bypass)
+          - Se r < 0.20 (degradação severa): η_eff = 0.5 (convergência rápida)
+          - Caso contrário: η_eff = η_default = 0.05 (suavização normal)
 
         Math (DeSieno 1988 + adaptação adaptativa):
             r        = n_active / n_total                   (∈ [0,1])
@@ -758,15 +836,13 @@ class KohonenSOM4D:
             γ_boost  = 0.3 · drop                            (reforço
                                                              antecipado)
             γ_target = clip(γ_base + γ_boost, γ_min, γ_max)
-            γ_new    = (1 - η) · γ_old + η · γ_target       (EMA suave)
+            γ_new    = (1 - η_eff) · γ_old + η_eff · γ_target  (EMA adaptativo)
 
-        Comportamento esperado em diferentes cenários:
+        Comportamento esperado:
             r = 1.0 (saudável)        → γ_base = 0.00 (data distribution domina)
             r = 0.5 (degradação)      → γ_base = 0.25 (intervenção moderada)
-            r = 0.1 (colapso severo)  → γ_base = 0.81 (intervenção forte)
-            r = 0.0 (paralisia)       → γ_base = 1.00 (intervenção máxima)
-            r caindo 1.0→0.5          → +0.15 boost (antecipa colapso)
-            r subindo 0.5→1.0         → drop=0, sem boost extra
+            r = 0.1 (colapso severo)  → γ_base = 0.81 (intervenção forte, η=0.5)
+            r < 0.05 (crítico)        → γ = γ_max = 1.0 (salto direto, sem EMA)
 
         Returns:
             Dict com: n_active, n_total, activation_rate, prev_activation_rate,
@@ -796,10 +872,23 @@ class KohonenSOM4D:
                 ),
             )
 
-            # EMA suave para evitar oscilações bruscas
-            eta = self._conscience_eta
+            # V6.5-V2-auto-conscience-v2 — adaptive EMA rate
+            # Critical collapse: jump directly to γ_max (bypass EMA)
+            # Severe degradation: fast EMA (η=0.5)
+            # Normal: slow EMA (η=0.05, default)
             gamma_old = float(self.conscience_gamma)
-            gamma_new = (1.0 - eta) * gamma_old + eta * float(gamma_target)
+            if r < 0.05:
+                # CRITICAL: bypass EMA, jump directly to target
+                eta_eff = 1.0
+                gamma_new = float(gamma_target)
+            elif r < 0.20:
+                # SEVERE: fast EMA convergence
+                eta_eff = 0.5
+                gamma_new = (1.0 - eta_eff) * gamma_old + eta_eff * float(gamma_target)
+            else:
+                # NORMAL: slow EMA
+                eta_eff = self._conscience_eta
+                gamma_new = (1.0 - eta_eff) * gamma_old + eta_eff * float(gamma_target)
             gamma_new = float(max(
                 self._conscience_gamma_min,
                 min(self._conscience_gamma_max, gamma_new),
@@ -824,7 +913,8 @@ class KohonenSOM4D:
                 "gamma_new": gamma_new,
                 "gamma_min": float(self._conscience_gamma_min),
                 "gamma_max": float(self._conscience_gamma_max),
-                "eta": float(eta),
+                "eta": float(eta_eff),
+                "bypass_ema": bool(r < 0.05),
             }
 
     def update_weights(self, x: torch.Tensor, bmu_idx, accumulate_fisher=False):