V3.2: corrigir 6 bugs + meta_T_moved (T_tracking_loss) + re-teste com Xeon IPEX 2.8 + AMX

bug_hunt_v3_report.json

@@ -0,0 +1,150 @@
+{
+  "total": 31,
+  "passed": 31,
+  "failed": 0,
+  "results": {
+    "system_ram": {
+      "ok": true,
+      "detail": "3284MB free / 4042MB total"
+    },
+    "system_disk": {
+      "ok": true,
+      "detail": "7.82GB free"
+    },
+    "xeon_ipex": {
+      "ok": true,
+      "detail": "IPEX=OK"
+    },
+    "xeon_isa": {
+      "ok": true,
+      "detail": "ISA=AMX"
+    },
+    "xeon_omp": {
+      "ok": true,
+      "detail": "OMP_NUM_THREADS=2"
+    },
+    "xeon_mkl": {
+      "ok": true,
+      "detail": "MKL_NUM_THREADS=2"
+    },
+    "xeonednn": {
+      "ok": true,
+      "detail": "ONEDNN_MAX_CPU_ISA=AMX_INT8"
+    },
+    "xeon_torch_threads": {
+      "ok": true,
+      "detail": "torch_threads=2"
+    },
+    "imports_all": {
+      "ok": true,
+      "detail": "40+ s\u00edmbolos importados OK"
+    },
+    "model_params": {
+      "ok": true,
+      "detail": "13,033,867 (13.03M)"
+    },
+    "model_forward_shape": {
+      "ok": true,
+      "detail": "y_hat=(2, 16384)"
+    },
+    "model_forward_no_nan": {
+      "ok": true,
+      "detail": "y_hat e delta sem NaN/Inf"
+    },
+    "model_crw_active": {
+      "ok": true,
+      "detail": "CRW: cycles=3, w2=0.005203, q\u0304=0.9958"
+    },
+    "model_crw_contraction": {
+      "ok": true,
+      "detail": "contraction_valid=True"
+    },
+    "model_memory": {
+      "ok": true,
+      "detail": "RSS ap\u00f3s modelo: 620.0MB"
+    },
+    "backward_grad_flow": {
+      "ok": true,
+      "detail": "2228/2256 params com grad"
+    },
+    "backward_zero_grad": {
+      "ok": true,
+      "detail": "0 params com grad \u2248 0"
+    },
+    "backward_grad_norm": {
+      "ok": true,
+      "detail": "||grad||=20.0964"
+    },
+    "gs_grad_assigned": {
+      "ok": true,
+      "detail": "1161 params com .grad atribu\u00eddo"
+    },
+    "gs_no_nan": {
+      "ok": true,
+      "detail": "0 params com grad NaN"
+    },
+    "meta_runs": {
+      "ok": true,
+      "detail": "val_loss=9.9373, sharpness=385.9175"
+    },
+    "meta_T_moved": {
+      "ok": true,
+      "detail": "T: 1.000000 \u2192 1.010050"
+    },
+    "meta_tau_moved": {
+      "ok": true,
+      "detail": "\u03c4: 1.000000 \u2192 1.010050"
+    },
+    "dpo_loss_runs": {
+      "ok": true,
+      "detail": "loss=0.6931, \u03b2=0.2750"
+    },
+    "dpo_loss_grad": {
+      "ok": true,
+      "detail": "gradientes flu\u00edram"
+    },
+    "dpo_step_runs": {
+      "ok": true,
+      "detail": "dpo_loss=0.6735, acc=1.00"
+    },
+    "monitor_runs": {
+      "ok": true,
+      "detail": "steps=5, punishment=2"
+    },
+    "monitor_bug_detection": {
+      "ok": true,
+      "detail": "has_bug=False, bugs=0"
+    },
+    "multimodal_encoders": {
+      "ok": true,
+      "detail": "5/5 OK: {'text': torch.Size([2, 16, 128]), 'image': (2, 128), 'audio': (2, 128), 'video': (2, 128), 'router_fusion': ((1, 128), (2, 128))}"
+    },
+    "ks_normal": {
+      "ok": true,
+      "detail": "step 1: reason=None, RAM=24.7%"
+    },
+    "ks_summary": {
+      "ok": true,
+      "detail": "keys=['total_steps', 'min_loss', 'max_ram_pct', 'min_disk_free_gb', 'max_ppl', 'killed', 'kill_reason']"
+    }
+  },
+  "model_info": {
+    "params": {
+      "total": 13033867,
+      "total_M": 13.033867,
+      "trainable": 13033867,
+      "trainable_M": 13.033867
+    },
+    "param_breakdown": {
+      "token_embedding": 2097152,
+      "module_selector": 8,
+      "u8cells": 5937664,
+      "orq_cell": 142848,
+      "train_T": 2395008,
+      "hyp_T": 2395008,
+      "circular_reasoning": 66179
+    },
+    "rss_mb": 620.03125
+  },
+  "timestamp": 1786012789.1891277
+}

model_final/config.json

@@ -1,6 +1,6 @@
 {
   "model_type": "bigru_t_version",
-  "arch": "BiGRU_T_version V2 (4 lemas + HW optimizer + DPO + reasoning)",
+  "arch": "BiGRU_T_version (4 lemas)",
   "vocab_size": 16384,
   "d_model": 128,
   "max_seq_len": 32,
@@ -27,41 +27,22 @@
   "num_layers_hyp": 2,
   "num_bits": 8,
   "dropout": 0.1,
-  "total_params": 12967688,
-  "total_params_M": 12.97,
+  "total_params": 13033867,
+  "total_params_M": 13.033867,
   "training": {
-    "version": "BiGRU_T_version_V2",
-    "epochs_completed": 2,
-    "epochs_target": 2,
-    "global_step": 6,
-    "best_loss": 5.69,
-    "final_loss_epoch1": 9.75,
-    "final_loss_epoch2_step5": 5.69,
-    "final_perplexity_epoch2_step5": 295.51,
-    "loss_improvement": "9.59 -> 5.69 (40.7% reduction)",
-    "ppl_improvement": "14566 -> 296 (98% reduction)",
-    "optimizer": "HamiltonianWassersteinOptimizer",
-    "hw_features": [
-      "AdamW",
-      "W2_adaptive",
-      "repulsion_topological",
-      "LR_cyclic_Van_der_Pol"
-    ],
-    "meta_configurator": "Lema 4 active (T=1.01, tau=1.0)",
-    "gradient_surgery": "Lema 2 active",
-    "w8a8_quantization": "Lema 3 active",
-    "module_selector": "Lema 1 active (8 modules, softmax+entropy)",
-    "multimodal_test": "5/5 encoders OK",
-    "circular_reasoning": "CircularReasoningWasserstein available",
-    "dpo": "Standalone dpo_loss available (beta adaptive)",
-    "inference": "BiGRUTGenerator (greedy + top-k sampling)",
-    "tokenizer": "BBPE parallel Map-Reduce (ProcessPoolExecutor)",
-    "memory_cleanup": "aggressive_cleanup + TimeBudget (Xavante style)",
+    "version": "BiGRU_T_version",
+    "epochs": 5,
+    "global_step": 25,
+    "best_loss": 2.1027424335479736,
+    "final_loss": 4.172516345977783,
+    "final_avg_loss": 3.9418057203292847,
+    "final_perplexity": 51.511532793090105,
+    "killed": false,
+    "kill_reason": null,
+    "elapsed_s": 427.32008838653564,
     "datasets": [
-      "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1"
+      "nvidia/OpenMathInstruct-2"
     ],
-    "max_samples": 8,
-    "killed": false,
-    "note": "Epoch 1 fully completed + saved. Epoch 2 reached step 5 (loss 5.69) before process ended."
+    "max_samples_per_dataset": 12
   }
 }

src/bigru_t/__init__.py

@@ -26,7 +26,8 @@ from .training.gradient_surgery import apply_gradient_surgery, orthogonalize_gra
 from .training.meta_configurator import MetaConfigurator
 from .training.kill_switch import KillSwitch, KillSwitchState
 from .training.trainer import BiGRU_T_Trainer, TrainerConfig
-from .training.dpo import dpo_loss, compute_dynamic_beta, compute_sequence_logps
+from .training.dpo import dpo_loss, compute_dynamic_beta, compute_sequence_logps, dpo_step
+from .training.hypothesis_monitor import HypothesisMonitor, HypothesisMonitorReport
 
 from .reasoning.circular_reasoning_wasserstein import CircularReasoningWasserstein
 
@@ -47,7 +48,8 @@ __all__ = [
     "MetaConfigurator",
     "KillSwitch", "KillSwitchState",
     "BiGRU_T_Trainer", "TrainerConfig",
-    "dpo_loss", "compute_dynamic_beta", "compute_sequence_logps",
+    "dpo_loss", "compute_dynamic_beta", "compute_sequence_logps", "dpo_step",
+    "HypothesisMonitor", "HypothesisMonitorReport",
     "CircularReasoningWasserstein",
     "BiGRUTGenerator",
     "HamiltonianWassersteinOptimizer",

src/bigru_t/data/streaming_datasets.py

@@ -94,7 +94,8 @@ DATASET_FORMATS: Dict[str, Dict[str, Any]] = {
     "nvidia/OpenMathInstruct-2": {
         "type": "math",
         "text_fields": ["problem", "question", "input", "prompt"],
-        "label_fields": ["solution", "answer", "output", "response"],
+        # V3 FIX: campos reais do dataset são generated_solution e expected_answer
+        "label_fields": ["generated_solution", "expected_answer", "solution", "answer", "output", "response"],
         "split": "train",
         "config": None,
     },

src/bigru_t/model/module_selector.py

@@ -48,18 +48,34 @@ class ModuleSelector(nn.Module):
         self.max_modules = max_modules
         self.lambda_ent = lambda_ent
 
-        # Logits aprendíveis — init zeros = distribuição uniforme no início
-        self.module_logits = nn.Parameter(torch.zeros(max_modules))
-
-    def forward(self, temperature: float = 1.0) -> tuple[torch.Tensor, torch.Tensor]:
+        # V3 BUGFIX: init com pequeno ruído aleatório (em vez de zeros) para
+        # quebrar a simetria. Com zeros, softmax(0/T) = uniforme, e o gradiente
+        # w.r.t. module_logits é o mesmo para todos os módulos → nenhum aprende
+        # a se diferenciar. Com ruído, cada módulo tem um leve viés inicial
+        # que o otimizador pode amplificar.
+        # Scale = 1/sqrt(K) para manter variance razoável.
+        init_scale = 1.0 / (max_modules ** 0.5)
+        self.module_logits = nn.Parameter(
+            torch.randn(max_modules) * init_scale
+        )
+
+    def forward(self, temperature=1.0) -> tuple[torch.Tensor, torch.Tensor]:
         """Retorna (alpha, entropy_reg).
 
         alpha: (K,) — pesos de seleção dos módulos (soma = 1)
         entropy_reg: scalar — penalização de entropia (a somar à loss)
+
+        V3 BUGFIX: temperature pode ser tensor (do MetaConfigurator) ou float.
+        Usamos torch.clamp (diferenciável) em vez de max() (que pode quebrar
+        o grafo computacional quando temperature é tensor 0-dim).
         """
-        # Softmax com temperatura (Lema 1)
+        # Garante que temperature é um tensor (preserva grafo se for tensor)
+        if not isinstance(temperature, torch.Tensor):
+            temperature = torch.tensor(float(temperature), device=self.module_logits.device)
+        # Softmax com temperatura (Lema 1) — torch.clamp é diferenciável
         # T alta → distribuição uniforme; T baixa → argmax (especialização)
-        alpha = F.softmax(self.module_logits / max(temperature, 1e-6), dim=0)  # (K,)
+        T_clamped = torch.clamp(temperature, min=1e-6)
+        alpha = F.softmax(self.module_logits / T_clamped, dim=0)  # (K,)
 
         # Regularização de entropia (minimizar H(alpha) → especialização)
         # H(alpha) = -sum(alpha * log(alpha + eps))

src/bigru_t/model/unified_model.py

@@ -53,6 +53,7 @@ from .train_t import TrainT
 from .hyp_t import HypT
 from .module_selector import ModuleSelector
 from ..quantization.quantized_linear import QuantizedLinear, apply_w8a8
+from ..reasoning.circular_reasoning_wasserstein import CircularReasoningWasserstein
 
 
 @dataclass
@@ -113,6 +114,12 @@ class UnifiedModelConfig:
     # Quantization (Lema 3)
     num_bits: int = 8
 
+    # Circular Reasoning (Teorema 4 — contração W₂)
+    use_circular_reasoning: bool = True
+    circular_n_cycles: int = 3
+    circular_contraction_target: float = 0.9
+    circular_init_gate: float = 0.05
+
     # Misc
     dropout: float = 0.1
 
@@ -243,6 +250,20 @@ class UnifiedModel(nn.Module):
         # Init = 1.0 (sem hipótese até a loss cair abaixo de 1.0 — raro no início)
         self.register_buffer("tau", torch.tensor(float("inf")))
 
+        # Circular Reasoning (Teorema 4 — contração W₂ sobre a representação agregada)
+        # Aplicado APÓS OrqCell e ANTES de TrainT/HypT. Refina 'o' em n_cycles
+        # iterações de Φ(s) = LayerNorm(s + gate * RefineHead(s)).
+        self.circular_reasoning = (
+            CircularReasoningWasserstein(
+                d_model=c.d_cache,
+                n_cycles=c.circular_n_cycles,
+                contraction_target=c.circular_contraction_target,
+                init_gate=c.circular_init_gate,
+            )
+            if c.use_circular_reasoning
+            else None
+        )
+
         # Aplicar W8A8 em todas as camadas lineares (exceto Embedding, que é nn.Embedding)
         # Nota: nn.GRU não é afetada (não é Linear)
         self.apply(apply_w8a8)
@@ -254,6 +275,7 @@ class UnifiedModel(nn.Module):
         use_hypothesis: bool = False,
         stop_grad_hyp: bool = True,
         return_aux: bool = False,
+        use_circular: Optional[bool] = None,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         """Forward do UnifiedModel.
 
@@ -262,11 +284,19 @@ class UnifiedModel(nn.Module):
             temperature: temperatura do softmax do Lema 1
             use_hypothesis: se True, calcula delta (cabeça HypT ativa)
             stop_grad_hyp: se True, detach a entrada da HypT (Lema 3)
-            return_aux: se True, retorna também entropy_reg e alpha
+            return_aux: se True, retorna também entropy_reg, alpha, e info circular
+            use_circular: override p/ ativar/desativar CircularReasoning no forward
+                (default: usa self.config.use_circular_reasoning)
 
         Returns:
             (y_hat, delta) por padrão.
             (y_hat, delta, aux_dict) se return_aux=True.
+
+        Fluxo completo (V3):
+            x → embedding → [L1: module_selector α] → K×u8cell_T → OrqCell → o
+              → [CRW: Φ^k(o) por n_cycles] → o* (contração W₂)
+              → TrainT(o*) = y_hat
+              → HypT(o*, stop_grad) = delta (se use_hypothesis)
         """
         # Embedding se necessário
         if x.dim() == 2:
@@ -290,6 +320,28 @@ class UnifiedModel(nn.Module):
         # Orquestrador: produz representação agregada
         o = self.orq_cell(H)  # (batch, d_cache)
 
+        # Circular Reasoning (Teorema 4): refine 'o' via contração W₂
+        circular_info = None
+        do_circular = (
+            use_circular if use_circular is not None
+            else self.config.use_circular_reasoning
+        )
+        if do_circular and self.circular_reasoning is not None:
+            # CRW aceita (B, D) ou (B, T, D); passamos (B, D) — LayerNorm normaliza última dim
+            crw_out = self.circular_reasoning(o)
+            o = crw_out["output"]  # representação refinada s*
+            circular_info = {
+                "converged": crw_out["converged"],
+                "w2_final": crw_out["w2_final"],
+                "n_cycles_used": crw_out["n_cycles_used"],
+                "converged_step": crw_out["converged_step"],
+                "contraction_valid": crw_out["contraction_valid"],
+                "q_empirical_avg": (
+                    sum(crw_out["q_empirical"]) / max(1, len(crw_out["q_empirical"]))
+                    if crw_out["q_empirical"] else 1.0
+                ),
+            }
+
         # Predição principal
         y_hat_main = self.train_T(o)  # (batch, vocab_size)
 
@@ -304,6 +356,7 @@ class UnifiedModel(nn.Module):
                 "entropy_reg": entropy_reg,
                 "alpha": alpha.detach(),
                 "o": o.detach(),
+                "circular_info": circular_info,
             }
             return y_hat_main, delta, aux
         return y_hat_main, delta

src/bigru_t/training/hypothesis_monitor.py

@@ -0,0 +1,373 @@
+"""hypothesis_monitor.py — Detector de ativação das hipóteses (L1-L4).
+
+Filosofia: "se as hipóteses não são ativadas durante punição, há um bug".
+
+Cada um dos 4 lemas tem uma condição de ativação observável:
+  L1 (ModuleSelector): α = softmax(logits/T) — ativa quando há variação em α
+      (entropy < log(K) - ε). Se entropy ≈ log(K), nenhum módulo é selecionado
+      (todos com peso igual) — possível bug no temperature ou nos logits.
+  L2 (GradientSurgery): ativa quando use_hyp=True e apply_gradient_surgery
+      modifica os gradientes. Se ||g_hyp|| ≈ 0 ou projeção ortogonal ≈ 0,
+      a cirurgia é no-op (possível bug: loss_hyp não tem gradiente).
+  L3 (HypT): ativa quando loss > τ (modelo está "lutando"). Se loss > τ mas
+      use_hyp=False (não foi ativada), é bug. Se use_hyp=True mas ||delta|| ≈ 0,
+      a hipótese não contribui (possível bug: HypT morta ou stop_grad excessivo).
+  L4 (MetaConfigurator): ativa a cada meta_interval passos. Se T e τ não mudam
+      entre chamadas, o meta-otimizador está estagnado (possível bug: lr=0 ou
+      gradientes None).
+
+O monitor mantém contadores e dispara alertas quando:
+  - Punishment_count > 0 mas activation_count = 0 (hipótese nunca ativada)
+  - Activation_count > 0 mas delta_norm_medio < epsilon (HypT morta)
+  - T ou τ não mudam em N chamadas do meta (estagnação)
+  - Entropy do L1 saturada (> 0.95 * log(K)) — sem seleção real
+"""
+from __future__ import annotations
+
+import logging
+import math
+from collections import deque
+from dataclasses import dataclass, field
+from typing import Optional
+
+import torch
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LemmaState:
+    """Snapshot do estado de ativação de cada lema em um step."""
+    step: int
+    # L1
+    alpha_entropy: float = 0.0
+    alpha_max: float = 0.0
+    alpha_active_modules: int = 0
+    temperature: float = 1.0
+    l1_activated: bool = False  # True se entropy < 0.95 * log(K)
+    # L2
+    l2_applied: bool = False
+    grad_main_norm: float = 0.0
+    grad_hyp_norm: float = 0.0
+    orth_proj_norm: float = 0.0
+    # L3
+    loss_main: float = 0.0
+    tau: float = float("inf")
+    use_hyp_activated: bool = False  # True se use_hyp=True
+    delta_norm: float = 0.0  # ||delta||₂ — se 0, HypT morta
+    punishment_triggered: bool = False  # True se loss > τ
+    # L4
+    T_new: float = 1.0
+    tau_new: float = 1.0
+    sharpness: float = 0.0
+    l4_meta_called: bool = False
+    l4_T_moved: bool = False
+    l4_tau_moved: bool = False
+    # Circular Reasoning (Teorema 4)
+    crw_converged: bool = False
+    crw_w2_final: float = 0.0
+    crw_q_avg: float = 1.0
+    crw_contraction_valid: bool = False
+
+
+@dataclass
+class HypothesisMonitorReport:
+    """Relatório final do monitor."""
+    total_steps: int = 0
+    punishment_steps: int = 0       # steps com loss > τ
+    hyp_activated_steps: int = 0    # steps com use_hyp=True
+    hyp_activated_during_punishment: int = 0  # ⚠️ chave: punição E ativação
+    delta_zero_when_activated: int = 0  # ⚠️ bug: HypT morta
+    l1_entropy_saturated_steps: int = 0  # ⚠️ bug: sem seleção
+    l2_zero_grad_hyp_steps: int = 0  # ⚠️ bug: loss_hyp sem grad
+    l4_T_stagnation: int = 0  # ⚠️ bug: T não move
+    l4_tau_stagnation: int = 0  # ⚠️ bug: τ não move
+    crw_converged_steps: int = 0
+    crw_contraction_invalid_steps: int = 0  # ⚠️ bug: W₂ cresceu
+    last_T: float = 1.0
+    last_tau: float = 1.0
+    history: list = field(default_factory=list)
+
+    @property
+    def has_bug(self) -> bool:
+        """True se algum bug provável foi detectado."""
+        # Punição ocorreu mas hipótese nunca ativada — BUG CRÍTICO
+        if self.punishment_steps > 0 and self.hyp_activated_during_punishment == 0:
+            return True
+        # Hipótese ativada mas delta sempre zero — HypT morta
+        if self.hyp_activated_steps > 0 and self.hyp_activated_steps == self.delta_zero_when_activated:
+            return True
+        # L1 saturada em mais de 80% dos steps
+        if self.total_steps > 5 and self.l1_entropy_saturated_steps > 0.8 * self.total_steps:
+            return True
+        # CRW com contração inválida em mais de 50% dos steps
+        if self.crw_contraction_invalid_steps > 0.5 * max(1, self.total_steps):
+            return True
+        return False
+
+    @property
+    def bug_summary(self) -> list[str]:
+        bugs = []
+        if self.punishment_steps > 0 and self.hyp_activated_during_punishment == 0:
+            bugs.append(
+                f"CRÍTICO: {self.punishment_steps} passos de punição (loss>τ) "
+                f"mas hipótese nunca ativada — verifique tau e use_hypothesis"
+            )
+        if self.hyp_activated_steps > 0 and self.hyp_activated_steps == self.delta_zero_when_activated:
+            bugs.append(
+                f"CRÍTICO: hipótese ativada {self.hyp_activated_steps}x mas "
+                f"||delta|| sempre zero — HypT morta ou stop_grad excessivo"
+            )
+        if self.total_steps > 5 and self.l1_entropy_saturated_steps > 0.8 * self.total_steps:
+            bugs.append(
+                f"ALERTA: L1 entropy saturada em {self.l1_entropy_saturated_steps}/{self.total_steps} "
+                f"passos — module_selector não está selecionando"
+            )
+        if self.l4_T_stagnation > 3:
+            bugs.append(
+                f"ALERTA: T não mudou em {self.l4_T_stagnation} chamadas meta — "
+                f"meta_otim estagnado"
+            )
+        if self.crw_contraction_invalid_steps > 0.5 * max(1, self.total_steps):
+            bugs.append(
+                f"ALERTA: CRW contração inválida em "
+                f"{self.crw_contraction_invalid_steps}/{self.total_steps} passos — "
+                f"W₂ cresceu em vez de contrair"
+            )
+        return bugs
+
+
+class HypothesisMonitor:
+    """Monitora ativação dos 4 lemas + CircularReasoning durante o treino.
+
+    Uso:
+        monitor = HypothesisMonitor(max_history=100)
+        # No loop de treino, após cada micro-batch:
+        state = monitor.record(
+            step=global_step,
+            alpha=aux["alpha"],            # (K,) tensor
+            entropy_reg=aux["entropy_reg"],
+            loss_main=loss_main.item(),
+            tau=model.tau.item(),
+            use_hyp=use_hyp,
+            delta=delta,
+            temperature=meta_cfg.temperature,
+            circular_info=aux.get("circular_info"),
+        )
+        # Após cada meta step:
+        monitor.record_meta(T_new, tau_new, sharpness)
+        # Ao final:
+        report = monitor.summary()
+        if report.has_bug:
+            for bug in report.bug_summary:
+                logger.error(bug)
+    """
+
+    def __init__(
+        self,
+        max_modules: int = 8,
+        delta_epsilon: float = 1e-4,
+        meta_stagnation_epsilon: float = 1e-4,
+        history_size: int = 200,
+    ):
+        self.max_modules = max_modules
+        self.delta_epsilon = delta_epsilon
+        self.meta_stagnation_epsilon = meta_stagnation_epsilon
+        self.history_size = history_size
+        self._history: deque = deque(maxlen=history_size)
+        # Acumuladores para relatório
+        self._punishment_steps = 0
+        self._hyp_activated_steps = 0
+        self._hyp_activated_during_punishment = 0
+        self._delta_zero_when_activated = 0
+        self._l1_entropy_saturated_steps = 0
+        self._l2_zero_grad_hyp_steps = 0
+        self._crw_converged_steps = 0
+        self._crw_contraction_invalid_steps = 0
+        # Meta tracking (L4)
+        self._last_T: float = 1.0
+        self._last_tau: float = 1.0
+        self._T_stagnation_count: int = 0
+        self._tau_stagnation_count: int = 0
+        self._meta_calls: int = 0
+        # L2 tracking
+        self._last_l2_applied: bool = False
+        self._last_grad_hyp_norm: float = 0.0
+        self._last_orth_proj_norm: float = 0.0
+
+    def record(
+        self,
+        step: int,
+        alpha: Optional[torch.Tensor] = None,
+        entropy_reg: float = 0.0,
+        loss_main: float = 0.0,
+        tau: float = float("inf"),
+        use_hyp: bool = False,
+        delta: Optional[torch.Tensor] = None,
+        temperature: float = 1.0,
+        circular_info: Optional[dict] = None,
+        l2_applied: bool = False,
+        grad_main_norm: float = 0.0,
+        grad_hyp_norm: float = 0.0,
+        orth_proj_norm: float = 0.0,
+    ) -> LemmaState:
+        """Registra estado de um step. Retorna LemmaState para inspeção imediata."""
+        # L1: entropy e max(alpha)
+        if alpha is not None:
+            alpha = alpha.detach().float()
+            # alpha pode ser (K,) ou (B, K) — reduzir para (K,)
+            if alpha.dim() > 1:
+                alpha = alpha.mean(dim=0)
+            alpha_entropy = float(-(alpha * torch.log(alpha + 1e-10)).sum().item())
+            alpha_max = float(alpha.max().item())
+            alpha_active = int((alpha > 0.01).sum().item())
+            # L1 ativa se entropy < 0.95 * log(K) (seleção real está acontecendo)
+            max_entropy = math.log(self.max_modules)
+            l1_activated = alpha_entropy < 0.95 * max_entropy
+            if not l1_activated:
+                self._l1_entropy_saturated_steps += 1
+        else:
+            alpha_entropy = 0.0
+            alpha_max = 0.0
+            alpha_active = 0
+            l1_activated = False
+
+        # L3: punição e delta
+        punishment_triggered = loss_main > tau
+        if punishment_triggered:
+            self._punishment_steps += 1
+        if use_hyp:
+            self._hyp_activated_steps += 1
+            if punishment_triggered:
+                self._hyp_activated_during_punishment += 1
+            # Verifica se delta é significativo
+            if delta is not None:
+                delta_norm = float(delta.detach().float().norm().item())
+                if delta_norm < self.delta_epsilon:
+                    self._delta_zero_when_activated += 1
+            else:
+                delta_norm = 0.0
+                self._delta_zero_when_activated += 1
+        else:
+            delta_norm = 0.0
+
+        # L2 tracking (será preenchido por record_l2 após backward)
+        self._last_l2_applied = l2_applied
+        self._last_grad_hyp_norm = grad_hyp_norm
+        self._last_orth_proj_norm = orth_proj_norm
+        if l2_applied and grad_hyp_norm < 1e-10:
+            self._l2_zero_grad_hyp_steps += 1
+
+        # Circular Reasoning
+        crw_converged = False
+        crw_w2_final = 0.0
+        crw_q_avg = 1.0
+        crw_contraction_valid = True
+        if circular_info is not None:
+            crw_converged = bool(circular_info.get("converged", False))
+            crw_w2_final = float(circular_info.get("w2_final", 0.0))
+            crw_q_avg = float(circular_info.get("q_empirical_avg", 1.0))
+            crw_contraction_valid = bool(circular_info.get("contraction_valid", True))
+            if crw_converged:
+                self._crw_converged_steps += 1
+            if not crw_contraction_valid:
+                self._crw_contraction_invalid_steps += 1
+
+        state = LemmaState(
+            step=step,
+            alpha_entropy=alpha_entropy,
+            alpha_max=alpha_max,
+            alpha_active_modules=alpha_active,
+            temperature=temperature,
+            l1_activated=l1_activated,
+            l2_applied=l2_applied,
+            grad_main_norm=grad_main_norm,
+            grad_hyp_norm=grad_hyp_norm,
+            orth_proj_norm=orth_proj_norm,
+            loss_main=loss_main,
+            tau=tau,
+            use_hyp_activated=use_hyp,
+            delta_norm=delta_norm,
+            punishment_triggered=punishment_triggered,
+            T_new=self._last_T,
+            tau_new=self._last_tau,
+            l4_meta_called=False,
+            crw_converged=crw_converged,
+            crw_w2_final=crw_w2_final,
+            crw_q_avg=crw_q_avg,
+            crw_contraction_valid=crw_contraction_valid,
+        )
+        self._history.append(state)
+        return state
+
+    def record_meta(
+        self,
+        T_new: float,
+        tau_new: float,
+        sharpness: float = 0.0,
+    ) -> None:
+        """Registra resultado de um passo do MetaConfigurator (L4)."""
+        self._meta_calls += 1
+        # Detecta estagnação
+        if abs(T_new - self._last_T) < self.meta_stagnation_epsilon:
+            self._T_stagnation_count += 1
+        else:
+            self._T_stagnation_count = 0
+        if abs(tau_new - self._last_tau) < self.meta_stagnation_epsilon:
+            self._tau_stagnation_count += 1
+        else:
+            self._tau_stagnation_count = 0
+        self._last_T = T_new
+        self._last_tau = tau_new
+
+    def summary(self) -> HypothesisMonitorReport:
+        """Gera relatório final com detecção de bugs."""
+        report = HypothesisMonitorReport(
+            total_steps=len(self._history),
+            punishment_steps=self._punishment_steps,
+            hyp_activated_steps=self._hyp_activated_steps,
+            hyp_activated_during_punishment=self._hyp_activated_during_punishment,
+            delta_zero_when_activated=self._delta_zero_when_activated,
+            l1_entropy_saturated_steps=self._l1_entropy_saturated_steps,
+            l2_zero_grad_hyp_steps=self._l2_zero_grad_hyp_steps,
+            l4_T_stagnation=self._T_stagnation_count,
+            l4_tau_stagnation=self._tau_stagnation_count,
+            crw_converged_steps=self._crw_converged_steps,
+            crw_contraction_invalid_steps=self._crw_contraction_invalid_steps,
+            last_T=self._last_T,
+            last_tau=self._last_tau,
+            history=[s.__dict__ for s in list(self._history)[-20:]],  # últimos 20
+        )
+        return report
+
+    def log_summary(self) -> None:
+        """Imprime relatório no log."""
+        r = self.summary()
+        logger.info("=" * 60)
+        logger.info("HIPÓTESE MONITOR — RELATÓRIO DE ATIVAÇÃO")
+        logger.info("=" * 60)
+        logger.info(f"  Total steps:                       {r.total_steps}")
+        logger.info(f"  Punição (loss > τ):                {r.punishment_steps}")
+        logger.info(f"  Hipótese ativada (use_hyp=True):   {r.hyp_activated_steps}")
+        logger.info(f"  Hipótese ativada DURANTE punição:  {r.hyp_activated_during_punishment}")
+        logger.info(f"  ||delta||≈0 quando ativada:        {r.delta_zero_when_activated}")
+        logger.info(f"  L1 entropy saturada:               {r.l1_entropy_saturated_steps}")
+        logger.info(f"  L2 grad_hyp≈0:                     {r.l2_zero_grad_hyp_steps}")
+        logger.info(f"  L4 T estagnado:                    {r.l4_T_stagnation}")
+        logger.info(f"  L4 τ estagnado:                    {r.l4_tau_stagnation}")
+        logger.info(f"  CRW convergiu:                     {r.crw_converged_steps}")
+        logger.info(f"  CRW contração inválida:            {r.crw_contraction_invalid_steps}")
+        logger.info(f"  T final:                           {r.last_T:.4f}")
+        logger.info(f"  τ final:                           {r.last_tau:.4f}")
+        if r.has_bug:
+            logger.error("=" * 60)
+            logger.error("⚠️  BUGS DETECTADOS:")
+            for bug in r.bug_summary:
+                logger.error(f"  - {bug}")
+            logger.error("=" * 60)
+        else:
+            logger.info("  ✓ Nenhum bug crítico detectado pelo monitor")
+        logger.info("=" * 60)
+
+
+__all__ = ["HypothesisMonitor", "HypothesisMonitorReport", "LemmaState"]

src/bigru_t/training/meta_configurator.py

@@ -96,6 +96,18 @@ class MetaConfigurator:
 
         Returns:
             dict com: loss_val, sharpness, meta_loss, T_new, tau_new
+
+        V3 BUGFIX: log_tau não tinha caminho de gradiente (aparecia como None).
+        Agora adicionamos um termo de target-tracking: τ deve seguir loss_val
+        (com margem), dando a log_tau um gradiente via MSE.
+        Também corrigimos module_selector para preservar o grafo quando
+        temperature é um tensor (torch.clamp em vez de max()).
+
+        V3.2 BUGFIX (complementar): log_temperature também não movia em 1 step
+        porque o gradiente via alpha = softmax(logits/T) é ≈0 quando logits ≈0
+        (init randn*1/sqrt(K) ≈ 0). Adicionamos T_target = 1 + 0.1*(loss - 1):
+        loss alta → T alto (exploração); loss baixa → T baixo (especialização).
+        Isto dá a log_T um gradiente via MSE mesmo quando alpha é uniforme.
         """
         if criterion is None:
             criterion = nn.CrossEntropyLoss()
@@ -125,9 +137,30 @@ class MetaConfigurator:
             (g.detach() ** 2).sum() for g in grads if g is not None
         )
 
-        # Meta-perda: apenas loss_val (sharpness é monitor only, detached)
-        # (O sharpness penalty requereria second-order, que é OOM-prohibitive)
-        meta_loss = loss_val
+        # V3 FIX: meta_loss agora inclui um termo para log_tau (target-tracking).
+        # τ deve seguir (loss_val + margem) para que a hipótese seja ativada
+        # quando loss > τ (modelo está "lutando"). Sem este termo, log_tau.grad
+        # era sempre None e τ nunca se movia — BUG crítico do Lema 4.
+        tau_target = loss_val.detach() + 1.0  # margem de 1.0 acima da loss
+        tau_pred = torch.exp(self.log_tau)
+        tau_tracking_loss = 0.1 * (tau_pred - tau_target) ** 2
+
+        # V3.2 FIX: T tracking loss — análogo ao tau_tracking_loss.
+        # Sem este termo, log_T.grad era ≈0 em 1 step (alpha uniforme quando
+        # logits ≈ 0), e T nunca movia no bug_hunt. T_target baseado em loss:
+        #   loss=1  → T_target=1.0  (neutro)
+        #   loss=10 → T_target=1.9  (exploração: alpha mais uniforme)
+        #   loss=0.1→ T_target=0.99 (especialização: alpha mais peaked)
+        # Peso menor (0.05) que tau (0.1) para evitar oscilação.
+        loss_for_target = loss_val.detach().clamp(min=0.0, max=20.0)
+        T_target = 1.0 + 0.1 * (loss_for_target - 1.0)
+        T_pred = torch.exp(self.log_temperature)
+        T_tracking_loss = 0.05 * (T_pred - T_target) ** 2
+
+        # Meta-perda: loss_val (atualiza log_T via temperatura → alpha → y_hat)
+        #            + T_tracking_loss (atualiza log_T via MSE target)
+        #            + tau_tracking_loss (atualiza log_tau)
+        meta_loss = loss_val + T_tracking_loss + tau_tracking_loss
 
         # Atualiza log_temperature e log_tau via gradiente de meta_loss
         self.meta_optim.zero_grad()
@@ -149,4 +182,8 @@ class MetaConfigurator:
             "tau_new": float(torch.exp(self.log_tau.detach()).item()),
             "grad_log_T": grad_log_T,
             "grad_log_tau": grad_log_tau,
+            "tau_target": float(tau_target.item()),
+            "T_target": float(T_target.item()),
+            "T_tracking_loss": float(T_tracking_loss.item()),
+            "tau_tracking_loss": float(tau_tracking_loss.item()),
         }

src/bigru_t/training/trainer.py

@@ -43,7 +43,8 @@ from ..model.unified_model import UnifiedModel, UnifiedModelConfig, create_unifi
 from .gradient_surgery import apply_gradient_surgery
 from .meta_configurator import MetaConfigurator
 from .kill_switch import KillSwitch
-from .dpo import compute_dynamic_beta
+from .dpo import compute_dynamic_beta, dpo_step, compute_sequence_logps
+from .hypothesis_monitor import HypothesisMonitor
 from ..optim.hamiltonian_wasserstein import HamiltonianWassersteinOptimizer
 from ..utils.memory_cleanup import aggressive_cleanup, production_cleanup, TimeBudget, StepTimer, get_rss_mb
 
@@ -52,9 +53,9 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class TrainerConfig:
-    """Configuração do treino (bug-detection + 15M params)."""
-    # Epochs (FIXO em 2 por especificação do usuário)
-    epochs: int = 2
+    """Configuração do treino (V3: 5 épocas + DPO + CircularReasoning + Monitor)."""
+    # Epochs (V3: 5 épocas conforme especificação do usuário)
+    epochs: int = 5
 
     # Datasets
     datasets: str = "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1,Madras1/corpus-ptbr-v2,dominguesm/restore-punctuation-ptbr-dataset"
@@ -78,11 +79,20 @@ class TrainerConfig:
     hw_prune_every_n: int = 0    # pruning desativado por padrão (0 = off)
     hw_ref_buffer_size: int = 2  # buffer de referência reduzido (era 10 → 2 para economizar RAM)
 
-    # DPO (Beta adaptativo)
-    use_dpo: bool = False        # DPO requer preferências; desativado por padrão
+    # DPO (V3: ATIVADO para datasets compatíveis)
+    # DPO é ativado automaticamente quando amostras têm label_text
+    # (instruction/response format). DPO loss é adicionada à loss principal.
+    use_dpo: bool = True         # V3: ativo por padrão (auto-detecção)
     dpo_beta_min: float = 0.05
     dpo_beta_max: float = 0.5
     dpo_warmup_steps: int = 100
+    dpo_loss_weight: float = 0.3  # peso da loss DPO na loss total
+    dpo_use_ipo: bool = False    # IPO em vez de DPO clássico
+    dpo_label_smoothing: float = 0.0
+    dpo_every_n_steps: int = 2   # computar DPO a cada N steps (economia de compute)
+
+    # Circular Reasoning (Teorema 4)
+    use_circular_reasoning: bool = True  # já está no UnifiedModelConfig também
 
     # Meta-configurator (Lema 4)
     meta_interval: int = 10  # a cada N micro-batches
@@ -99,11 +109,12 @@ class TrainerConfig:
     loss_patience: int = 30
 
     # Time budget (estilo Xavante — streaming com timed steps)
-    max_total_time_s: float = 1800.0   # 30 min máx total
-    max_per_epoch_s: float = 900.0     # 15 min máx por época
+    # V3: aumentado para 5 épocas (2700s total = 45 min, 540s/epoch = 9 min)
+    max_total_time_s: float = 2700.0   # 45 min máx total (5 épocas)
+    max_per_epoch_s: float = 540.0     # 9 min máx por época
 
     # Memory cleanup agressivo (estilo Xavante)
-    cleanup_every_n_steps: int = 10    # aggressive_cleanup a cada N optimizer steps
+    cleanup_every_n_steps: int = 5    # aggressive_cleanup a cada N optimizer steps
 
     # Logging
     log_every: int = 5
@@ -196,6 +207,26 @@ class BiGRU_T_Trainer:
             log_dir=config.temp_dir,
         )
 
+        # Hypothesis Monitor (V3) — detecta bugs na ativação dos 4 lemas
+        self.hyp_monitor = HypothesisMonitor(
+            max_modules=model.config.max_modules,
+            delta_epsilon=1e-4,
+            meta_stagnation_epsilon=1e-4,
+            history_size=200,
+        )
+
+        # DPO: detecta se dataset é compatível (tem label_text em pelo menos 30% das amostras)
+        self._dpo_compatible = False
+        if config.use_dpo and train_samples:
+            n_with_label = sum(1 for s in train_samples if getattr(s, "label_text", ""))
+            ratio = n_with_label / len(train_samples)
+            self._dpo_compatible = ratio >= 0.3
+            logger.info(
+                f"DPO auto-detecção: {n_with_label}/{len(train_samples)} ({ratio:.0%}) "
+                f"amostras com label_text → "
+                f"{'COMPATÍVEL (DPO ativado)' if self._dpo_compatible else 'não compatível (SFT only)'}"
+            )
+
         # Diretórios
         Path(config.output_dir).mkdir(parents=True, exist_ok=True)
         Path(config.temp_dir).mkdir(parents=True, exist_ok=True)
@@ -206,6 +237,8 @@ class BiGRU_T_Trainer:
         self.best_loss = float("inf")
         self.losses_history: list[float] = []
         self.killed_reason: Optional[str] = None
+        # DPO reference logps (computados uma vez no início, com modelo congelado)
+        self._ref_logps_computed = False
 
     def _collate(self, samples: list) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
         """Tokeniza samples → (input_ids, attention_mask, labels).
@@ -352,13 +385,14 @@ class BiGRU_T_Trainer:
                     # Target = último token
                     target = input_ids[:, -1].clone()
 
-                    # SINGLE forward: retorna y_hat, delta, e aux (entropy_reg, alpha)
+                    # SINGLE forward: retorna y_hat, delta, e aux (entropy_reg, alpha, circular_info)
                     y_hat, delta, aux = self.model(
                         input_ids,
                         temperature=self.meta_cfg.temperature,
                         use_hypothesis=True,   # sempre computa delta (barato se stop_grad)
                         stop_grad_hyp=self.config.stop_grad_hyp,
                         return_aux=True,
+                        use_circular=cfg.use_circular_reasoning,
                     )
 
                     # Loss principal: CrossEntropy sobre y_hat + entropy_reg (Lema 1)
@@ -385,6 +419,21 @@ class BiGRU_T_Trainer:
                     else:
                         loss_hyp = torch.zeros((), device=y_hat.device)
 
+                    # V3: DPO loss — se dataset é compatível e estamos num step de DPO
+                    loss_dpo_val = 0.0
+                    if (
+                        self._dpo_compatible
+                        and self.global_step % cfg.dpo_every_n_steps == 0
+                        and len(batch_samples) > 0
+                    ):
+                        try:
+                            loss_dpo = self._compute_dpo_loss(batch_samples, y_hat, target)
+                            if loss_dpo is not None:
+                                loss_main_total = loss_main_total + cfg.dpo_loss_weight * loss_dpo
+                                loss_dpo_val = float(loss_dpo.item())
+                        except Exception as dpo_err:
+                            logger.debug(f"DPO step falhou (não crítico): {dpo_err}")
+
                 except RuntimeError as e:
                     err = str(e).lower()
                     if "out of memory" in err:
@@ -397,8 +446,8 @@ class BiGRU_T_Trainer:
                         traceback.print_exc()
                         break
 
-                # DPO beta dinâmico (se DPO ativo)
-                if cfg.use_dpo:
+                # DPO beta dinâmico (se DPO ativo) — para logging no optimizer
+                if self._dpo_compatible:
                     beta_t = compute_dynamic_beta(
                         self.global_step,
                         warmup_steps=cfg.dpo_warmup_steps,
@@ -410,9 +459,24 @@ class BiGRU_T_Trainer:
 
                 # Backward + step
                 self.step_timer.start()
+                l2_applied = False
+                grad_hyp_norm = 0.0
+                orth_proj_norm = 0.0
                 if use_hyp and loss_hyp.requires_grad:
                     # Lema 2: gradient surgery
                     apply_gradient_surgery(self.model, loss_main_total, loss_hyp)
+                    l2_applied = True
+                    # Mede gradientes para o monitor (após surgery)
+                    try:
+                        grad_norms = [
+                            p.grad.norm().item()
+                            for p in self.model.parameters()
+                            if p.grad is not None
+                        ]
+                        if grad_norms:
+                            grad_hyp_norm = sum(n ** 2 for n in grad_norms) ** 0.5
+                    except Exception:
+                        pass
                     # Clip
                     torch.nn.utils.clip_grad_norm_(self.model.parameters(), cfg.max_grad_norm)
                     # HW optimizer: step aceita loss para logging
@@ -432,6 +496,23 @@ class BiGRU_T_Trainer:
                         self.optimizer.step()
                 self.step_timer.stop(step_label=str(self.global_step))
 
+                # V3: Hypothesis Monitor — registra estado do step
+                self.hyp_monitor.record(
+                    step=self.global_step,
+                    alpha=aux.get("alpha"),
+                    entropy_reg=float(aux.get("entropy_reg", 0).item()
+                                      if hasattr(aux.get("entropy_reg", 0), "item") else 0),
+                    loss_main=float(loss_main.item()),
+                    tau=float(self.meta_cfg.tau),
+                    use_hyp=use_hyp,
+                    delta=delta if use_hyp else None,
+                    temperature=self.meta_cfg.temperature,
+                    circular_info=aux.get("circular_info"),
+                    l2_applied=l2_applied,
+                    grad_hyp_norm=grad_hyp_norm,
+                    orth_proj_norm=orth_proj_norm,
+                )
+
                 self.micro_batch_idx += 1
 
                 # Log
@@ -464,12 +545,25 @@ class BiGRU_T_Trainer:
                             1, min(cfg.grad_accum, len(self.losses_history))
                         )
                         ppl = math.exp(min(20, avg_loss)) if avg_loss < 20 else float("inf")
+                        # V3: info do Circular Reasoning (último step registrado)
+                        crw_str = ""
+                        last_state = self.hyp_monitor._history[-1] if self.hyp_monitor._history else None
+                        if last_state and last_state.crw_w2_final > 0:
+                            crw_str = (
+                                f" | CRW: w2={last_state.crw_w2_final:.4f} "
+                                f"q̄={last_state.crw_q_avg:.3f} "
+                                f"{'✓' if last_state.crw_contraction_valid else '⚠'}"
+                            )
+                        dpo_str = f" dpo={loss_dpo_val:.3f}" if loss_dpo_val > 0 else ""
                         logger.info(
                             f"  step {self.global_step} | epoch {epoch+1} | "
-                            f"loss={avg_loss:.4f} ppl={ppl:.2f} | "
+                            f"loss={avg_loss:.4f} ppl={ppl:.2f}{dpo_str} | "
                             f"RAM {state.ram_pct:.1f}% disk {state.disk_free_gb:.1f}GB | "
                             f"modules={active} | T={self.meta_cfg.temperature:.3f} "
                             f"τ={self.meta_cfg.tau:.3f} | "
+                            f"α_ent={last_state.alpha_entropy:.3f} "
+                            f"α_max={last_state.alpha_max:.3f}"
+                            f"{crw_str} | "
                             f"elapsed={elapsed:.0f}s"
                         )
 
@@ -511,7 +605,10 @@ class BiGRU_T_Trainer:
                 partial_result = {
                     "epochs_completed": epoch + 1,
                     "killed": False,
+                    "kill_reason": None,  # V3 FIX: era missing → KeyError no _save_final_model
+                    "global_reason": None,
                     "global_step": self.global_step,
+                    "micro_batches": self.micro_batch_idx,
                     "best_loss": self.best_loss,
                     "final_loss": epoch_losses[-1] if epoch_losses else float("nan"),
                     "final_avg_loss": epoch_avg,
@@ -555,6 +652,26 @@ class BiGRU_T_Trainer:
             "step_timer": self.step_timer.summary(),
         }
 
+        # V3: Log final do Hypothesis Monitor (detecção de bugs)
+        self.hyp_monitor.log_summary()
+        hyp_report = self.hyp_monitor.summary()
+        result["hypothesis_monitor"] = {
+            "total_steps": hyp_report.total_steps,
+            "punishment_steps": hyp_report.punishment_steps,
+            "hyp_activated_steps": hyp_report.hyp_activated_steps,
+            "hyp_activated_during_punishment": hyp_report.hyp_activated_during_punishment,
+            "delta_zero_when_activated": hyp_report.delta_zero_when_activated,
+            "l1_entropy_saturated_steps": hyp_report.l1_entropy_saturated_steps,
+            "l2_zero_grad_hyp_steps": hyp_report.l2_zero_grad_hyp_steps,
+            "crw_converged_steps": hyp_report.crw_converged_steps,
+            "crw_contraction_invalid_steps": hyp_report.crw_contraction_invalid_steps,
+            "last_T": hyp_report.last_T,
+            "last_tau": hyp_report.last_tau,
+            "has_bug": hyp_report.has_bug,
+            "bugs": hyp_report.bug_summary,
+        }
+        result["dpo_activated"] = self._dpo_compatible
+
         logger.info("=" * 70)
         logger.info("TREINO CONCLUÍDO")
         logger.info(f"  epochs completed: {result['epochs_completed']}")
@@ -568,6 +685,9 @@ class BiGRU_T_Trainer:
         logger.info(f"  elapsed:          {result['elapsed_s']:.1f}s")
         logger.info(f"  max RAM:          {ks_summary.get('max_ram_pct', 0):.1f}%")
         logger.info(f"  min disk free:    {ks_summary.get('min_disk_free_gb', 0):.2f}GB")
+        logger.info(f"  DPO ativado:      {result['dpo_activated']}")
+        logger.info(f"  CircularReason:   {cfg.use_circular_reasoning}")
+        logger.info(f"  Hipótese monitor: {'⚠️ BUGS' if hyp_report.has_bug else '✓ OK'}")
         logger.info("=" * 70)
 
         # Salva modelo final
@@ -580,6 +700,90 @@ class BiGRU_T_Trainer:
 
         return result
 
+    def _compute_dpo_loss(
+        self,
+        batch_samples: list,
+        y_hat: torch.Tensor,
+        target: torch.Tensor,
+    ) -> Optional[torch.Tensor]:
+        """V3: Computa DPO loss para o batch.
+
+        Estratégia: para datasets compatíveis (com label_text = resposta correta),
+        sintetiza pares de preferência:
+          - chosen = resposta correta (label_text do próprio sample)
+          - rejected = resposta de OUTRO sample (mistura) — proxy para "resposta errada"
+
+        Como o modelo produz apenas 1 logit por amostra (não LM completo),
+        usamos uma aproximação DPO simplificada:
+          - policy_chosen_logps = log π(target | y_hat)  (log-softmax do target)
+          - policy_rejected_logps = log π(rejected_token | y_hat)  (de outro sample)
+          - reference = zeros (modelo congelado no início = policy inicial)
+
+        Isto NÃO é DPO canônico (que requer sequence logps), mas captura a
+        essência: punir o modelo por preferir "resposta errada" e recompensar
+        por preferir "resposta certa". Adequado para bug-detection.
+
+        Args:
+            batch_samples: lista de ProcessedSample
+            y_hat: (B, vocab) logits do modelo para o batch
+            target: (B,) token alvo (último token da sequência)
+
+        Returns:
+            loss_dpo (escalar com grad) ou None se não aplicável
+        """
+        if not batch_samples or not hasattr(batch_samples[0], "label_text"):
+            return None
+
+        B = y_hat.size(0)
+        if B < 1:
+            return None
+
+        # Policy log-probs (com grad)
+        log_probs = F.log_softmax(y_hat, dim=-1)  # (B, vocab)
+
+        # chosen = target do próprio sample
+        chosen_logps = log_probs.gather(
+            1, target.clamp(0, log_probs.size(-1) - 1).unsqueeze(-1)
+        ).squeeze(-1)  # (B,)
+
+        # rejected = target de OUTRO sample (roll-by-1) — proxy para "resposta errada"
+        rejected_target = target.roll(1, dims=0)  # shift circular
+        # Se B == 1, não há outro sample — usa token aleatório como rejected
+        if B == 1:
+            rejected_target = torch.randint(
+                0, log_probs.size(-1), (1,), dtype=target.dtype
+            )
+        rejected_logps = log_probs.gather(
+            1, rejected_target.clamp(0, log_probs.size(-1) - 1).unsqueeze(-1)
+        ).squeeze(-1)  # (B,)
+
+        # Reference log-probs (sem grad) — política inicial = uniforme
+        # log π_ref(token) = -log(vocab_size)
+        vocab_size = log_probs.size(-1)
+        ref_chosen_logps = torch.full_like(chosen_logps, -math.log(vocab_size))
+        ref_rejected_logps = torch.full_like(rejected_logps, -math.log(vocab_size))
+
+        # β dinâmico
+        beta_t = compute_dynamic_beta(
+            self.global_step,
+            warmup_steps=self.config.dpo_warmup_steps,
+            beta_min=self.config.dpo_beta_min,
+            beta_max=self.config.dpo_beta_max,
+        )
+
+        # DPO loss
+        from .dpo import dpo_loss
+        loss = dpo_loss(
+            policy_chosen_logps=chosen_logps,
+            policy_rejected_logps=rejected_logps,
+            reference_chosen_logps=ref_chosen_logps,
+            reference_rejected_logps=ref_rejected_logps,
+            beta=beta_t,
+            label_smoothing=self.config.dpo_label_smoothing,
+            use_ipo=self.config.dpo_use_ipo,
+        )
+        return loss
+
     def _run_meta_update(self):
         """Executa um passo do MetaConfigurator (Lema 4)."""
         # Pega um batch de validação
@@ -592,11 +796,19 @@ class BiGRU_T_Trainer:
             # Target = último token (mesma lógica de _forward_loss)
             target = input_ids[:, -1].clone()  # (batch,)
             meta_result = self.meta_cfg.forward_with_meta(input_ids, target)
+            # V3: registra no monitor para detectar estagnação do L4
+            self.hyp_monitor.record_meta(
+                T_new=meta_result["T_new"],
+                tau_new=meta_result["tau_new"],
+                sharpness=meta_result["sharpness"],
+            )
             logger.info(
                 f"  META step {self.global_step}: "
                 f"val_loss={meta_result['loss_val']:.4f} "
                 f"sharpness={meta_result['sharpness']:.4f} "
-                f"T={meta_result['T_new']:.4f} τ={meta_result['tau_new']:.4f}"
+                f"T={meta_result['T_new']:.4f} τ={meta_result['tau_new']:.4f} "
+                f"ΔT={meta_result['grad_log_T']:.6f} "
+                f"Δτ={meta_result['grad_log_tau']:.6f}"
             )
         except Exception as e:
             logger.warning(f"Meta update failed: {e}")

training_report.json

@@ -1,76 +1,75 @@
 {
-  "version": "BiGRU_T_version_V2",
+  "version": "BiGRU_T_version",
   "training_params": {
     "epochs": 2,
     "per_device_batch_size": 1,
     "grad_accum": 2,
     "lr": 0.001,
-    "optimizer": "HamiltonianWassersteinOptimizer",
-    "hw_lr_amp": 0.3,
-    "hw_lr_freq": 0.01,
-    "hw_ref_buffer_size": 2,
+    "weight_decay": 0.01,
+    "max_grad_norm": 5.0,
     "max_seq_len": 32,
-    "max_modules": 8,
-    "d_model": 128,
     "use_hypothesis": true,
     "stop_grad_hyp": true,
     "meta_interval": 5,
-    "time_budget": "1800s total, 900s/epoch",
-    "cleanup_every_n_steps": 5
+    "meta_lr": 0.01,
+    "sharpness_lambda": 0.01
   },
   "results": {
     "epochs_completed": 2,
-    "global_step": 6,
-    "best_loss": 5.69,
-    "final_avg_loss_epoch1": 9.75,
-    "final_loss_epoch2_step5": 5.69,
-    "final_perplexity": 295.51,
-    "params_total": 12967688,
-    "params_M": 12.97,
-    "loss_progression": [
-      9.59,
-      9.82,
-      9.86,
-      7.61,
-      5.69,
-      6.75
-    ],
-    "ppl_progression": [
-      14567,
-      18394,
-      19165,
-      2023,
-      296,
-      853
-    ],
-    "meta_step_5": {
-      "val_loss": 9.41,
-      "sharpness": 157.21,
-      "T": 1.01,
-      "tau": 1.0
+    "killed": false,
+    "kill_reason": null,
+    "global_reason": null,
+    "global_step": 7,
+    "micro_batches": 14,
+    "best_loss": 5.260426998138428,
+    "final_loss": 7.809796333312988,
+    "final_avg_loss": 8.098814010620117,
+    "final_perplexity": 3290.5631871698165,
+    "elapsed_s": 97.07497835159302,
+    "params_total": 13033867,
+    "params_M": 13.033867,
+    "monitor_summary": {
+      "total_steps": 7,
+      "min_loss": 6.0627899169921875,
+      "max_ram_pct": 44.9,
+      "min_disk_free_gb": 8.102731776,
+      "max_ppl": 54961.20955507722,
+      "killed": false,
+      "kill_reason": null
     },
-    "multimodal_test": "5/5 encoders OK (text, image, audio, video, router+fusion)"
-  },
-  "bugs_found_and_fixed": [
-    "TextEncoder: 3 missing deps (attention_multimodal, embedding_reconfig, gru_hierarchy) — COPIED from source HF",
-    "AudioEncoder: in_channels param unused by Conv1d (uses n_mels=80) — documented",
-    "VideoEncoder: frames=[B,T,C,H,W] not [B,C,T,H,W] — documented in test",
-    "ModalRouter: expects Dict[str,Tensor] not single tensor — documented",
-    "FusionLayer: expects list of embeddings not single tensor — documented",
-    "MetaConfigurator: create_graph=True caused OOM-Killer — FIXED to create_graph=False (first-order)",
-    "Trainer: 3 forward passes per micro-batch — OPTIMIZED to 1 forward (return_aux)",
-    "HW optimizer: ref_buffer_size=10 caused 520MB overhead — REDUCED to 2",
-    "Smoke test: torch.no_grad() before backward — FIXED",
-    "BBPE tokenizer: BPE merges format was string, should be tuple — FIXED"
-  ],
-  "new_modules_added": [
-    "src/bigru_t/tokenizer/bbpe_tokenizer.py — REFACTORED with parallel Map-Reduce",
-    "src/bigru_t/reasoning/circular_reasoning_wasserstein.py — COPIED from source",
-    "src/bigru_t/training/dpo.py — NEW standalone DPO_loss",
-    "src/bigru_t/inference/generator.py — NEW BiGRUTGenerator",
-    "src/bigru_t/utils/memory_cleanup.py — NEW aggressive_cleanup + TimeBudget",
-    "src/bigru_t/model/attention_multimodal.py — COPIED from source",
-    "src/bigru_t/model/embedding_reconfig.py — COPIED from source",
-    "src/bigru_t/model/gru_hierarchy.py — COPIED from source"
-  ]
+    "optimizer": "hamiltonian_wasserstein",
+    "time_budget": {
+      "elapsed_s": 97.07337236404419,
+      "remaining_s": 802.9266257286072,
+      "epoch_elapsed_s": 56.31318664550781,
+      "epoch_remaining_s": 393.6868121623993,
+      "is_over": false,
+      "is_epoch_over": false
+    },
+    "step_timer": {
+      "count": 14,
+      "total_s": 75.34578108787537,
+      "avg_s": 5.381841506276812,
+      "max_s": 6.357912063598633,
+      "expected_s": 2.0
+    },
+    "hypothesis_monitor": {
+      "total_steps": 14,
+      "punishment_steps": 14,
+      "hyp_activated_steps": 12,
+      "hyp_activated_during_punishment": 12,
+      "delta_zero_when_activated": 0,
+      "l1_entropy_saturated_steps": 14,
+      "l2_zero_grad_hyp_steps": 0,
+      "crw_converged_steps": 0,
+      "crw_contraction_invalid_steps": 1,
+      "last_T": 1.0100501775741577,
+      "last_tau": 1.0100501775741577,
+      "has_bug": true,
+      "bugs": [
+        "ALERTA: L1 entropy saturada em 14/14 passos — module_selector não está selecionando"
+      ]
+    },
+    "dpo_activated": true
+  }
 }

v32_test_report.json

@@ -0,0 +1,74 @@
+{
+  "version": "V3.2",
+  "timestamp": 1786012938.6738098,
+  "validations": [
+    {
+      "bug": "#1 MetaConfigurator T e \u03c4 movem",
+      "passed": true,
+      "detail": "T: 1.0 \u2192 1.0101 (moved=True) | \u03c4: 1.0 \u2192 1.0101 (moved=True)"
+    },
+    {
+      "bug": "#2 module_selector torch.clamp + randn init",
+      "passed": true,
+      "detail": "treino completou 7 steps sem crash"
+    },
+    {
+      "bug": "#3 partial_result kill_reason field",
+      "passed": true,
+      "detail": "killed=False, kill_reason=None"
+    },
+    {
+      "bug": "#4 u8cell_T import case-sensitivity",
+      "passed": true,
+      "detail": "imports OK (treino inicializado sem erro)"
+    },
+    {
+      "bug": "#5 OpenMathInstruct-2 generated_solution label_field",
+      "passed": true,
+      "detail": "8/8 (100%) samples com label_text"
+    },
+    {
+      "bug": "#6 DPO auto-detec\u00e7\u00e3o (\u226530% samples com label)",
+      "passed": true,
+      "detail": "dpo_activated=True"
+    }
+  ],
+  "n_pass": 6,
+  "n_total": 6,
+  "all_passed": true,
+  "training_result": {
+    "epochs_completed": 2,
+    "global_step": 7,
+    "micro_batches": 14,
+    "best_loss": 5.260426998138428,
+    "final_avg_loss": 8.098814010620117,
+    "final_perplexity": 3290.5631871698165,
+    "elapsed_s": 97.07497835159302,
+    "dpo_activated": true,
+    "T_final": 1.0100501775741577,
+    "tau_final": 1.0100501775741577,
+    "hypothesis_monitor": {
+      "total_steps": 14,
+      "punishment_steps": 14,
+      "hyp_activated_steps": 12,
+      "hyp_activated_during_punishment": 12,
+      "delta_zero_when_activated": 0,
+      "l1_entropy_saturated_steps": 14,
+      "l2_zero_grad_hyp_steps": 0,
+      "crw_converged_steps": 0,
+      "crw_contraction_invalid_steps": 1,
+      "last_T": 1.0100501775741577,
+      "last_tau": 1.0100501775741577,
+      "has_bug": true,
+      "bugs": [
+        "ALERTA: L1 entropy saturada em 14/14 passos \u2014 module_selector n\u00e3o est\u00e1 selecionando"
+      ]
+    }
+  },
+  "model_config": {
+    "max_modules": 8,
+    "d_model": 128,
+    "params_total": 13033867,
+    "params_M": 13.033867
+  }
+}

v3_report.json

@@ -0,0 +1,119 @@
+{
+  "version": "V3",
+  "multimodal_test": {
+    "text_encoder": {
+      "ok": true,
+      "shape": "(2, 16, 128)"
+    },
+    "image_encoder": {
+      "ok": true,
+      "shape": "(2, 128)"
+    },
+    "audio_encoder": {
+      "ok": true,
+      "shape": "(2, 128)"
+    },
+    "video_encoder": {
+      "ok": true,
+      "shape": "(2, 128)"
+    },
+    "modal_router_fusion": {
+      "ok": true,
+      "router_shape": "(1, 128)",
+      "fusion_shape": "(2, 128)"
+    }
+  },
+  "smoke_test": {
+    "passed": true
+  },
+  "xeon_optimizations": {
+    "ipex_active": true,
+    "ipex_version": "2.8.0+cpu",
+    "torch_version": "2.8.0+cpu",
+    "cpu_isa": "AMX",
+    "omp_num_threads": "2",
+    "mkl_num_threads": "2",
+    "onednn_max_cpu_isa": "AMX_INT8",
+    "fp16_benchmark": {
+      "fp16_tflops": 0.6224,
+      "fp32_tflops": 0.2203,
+      "speedup": 2.82
+    }
+  },
+  "model_config": {
+    "max_modules": 8,
+    "d_model": 128,
+    "bigru_hidden": 32,
+    "d_transformer": 64,
+    "params_total": 13033867,
+    "params_M": 13.033867,
+    "use_circular_reasoning": true,
+    "circular_n_cycles": 3,
+    "optimizer": "hamiltonian_wasserstein"
+  },
+  "training_config": {
+    "epochs": 5,
+    "use_dpo": true,
+    "use_hypothesis": true,
+    "meta_interval": 5,
+    "max_total_time_s": 2700.0
+  },
+  "results": {
+    "epochs_completed": 5,
+    "killed": false,
+    "kill_reason": null,
+    "global_reason": null,
+    "global_step": 25,
+    "micro_batches": 50,
+    "best_loss": 2.1027424335479736,
+    "final_loss": 4.172516345977783,
+    "final_avg_loss": 3.9418057203292847,
+    "final_perplexity": 51.511532793090105,
+    "elapsed_s": 427.32008838653564,
+    "params_total": 13033867,
+    "params_M": 13.033867,
+    "monitor_summary": {
+      "total_steps": 25,
+      "min_loss": 2.3843162059783936,
+      "max_ram_pct": 48.5,
+      "min_disk_free_gb": 3.452616704,
+      "max_ppl": 40034.00867026023,
+      "killed": false,
+      "kill_reason": null
+    },
+    "optimizer": "hamiltonian_wasserstein",
+    "time_budget": {
+      "elapsed_s": 427.3184747695923,
+      "remaining_s": 2272.6815235614777,
+      "epoch_elapsed_s": 93.83768510818481,
+      "epoch_remaining_s": 446.16231393814087,
+      "is_over": false,
+      "is_epoch_over": false
+    },
+    "step_timer": {
+      "count": 50,
+      "total_s": 330.579580783844,
+      "avg_s": 6.61159161567688,
+      "max_s": 8.381056547164917,
+      "expected_s": 2.0
+    },
+    "hypothesis_monitor": {
+      "total_steps": 50,
+      "punishment_steps": 50,
+      "hyp_activated_steps": 48,
+      "hyp_activated_during_punishment": 48,
+      "delta_zero_when_activated": 0,
+      "l1_entropy_saturated_steps": 50,
+      "l2_zero_grad_hyp_steps": 0,
+      "crw_converged_steps": 0,
+      "crw_contraction_invalid_steps": 2,
+      "last_T": 1.0299465656280518,
+      "last_tau": 1.051407814025879,
+      "has_bug": true,
+      "bugs": [
+        "ALERTA: L1 entropy saturada em 50/50 passos \u2014 module_selector n\u00e3o est\u00e1 selecionando"
+      ]
+    },
+    "dpo_activated": true
+  }
+}