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

scripts/train_v6_5_v2.py

@@ -1201,6 +1201,33 @@ def run_fase_conhecimento(
     auto_adjust_log: List[Dict[str, Any]] = []
     stop_training_reason: Optional[str] = None
 
+    # V7-tokenizer-growth — Corpus collector para crescimento do vocabulário
+    # User requirement: "verificar impacto de seq_len em vocab real=293
+    # (alvo 16384)". A análise V7 revelou que o vocab real era apenas 293
+    # porque o tokenizer era treinado com apenas 17 frases hardcoded.
+    #
+    # Prova 13 (vocab growth): O BBPE precisa de corpus ≥ 200 textos para
+    # ter merges suficientes para alcançar vocab_size=16384. Com 17 frases,
+    # o nº de pares únicos é ~50, limitando o vocab a ~300. Com 2000+
+    # frases (coletadas durante FASE1), o nº de pares cresce para 5000+,
+    # permitindo vocab alcançar 5000-10000 (próximo do alvo 16384).
+    #
+    # Estratégia: acumular textos dos chunks durante FASE1, e refitar o
+    # tokenizer a cada 1000 amostras (10 chunks). O embedding matrix é
+    # fixo (16384 rows), então qualquer crescimento de vocab é acomodado.
+    # O SOM adapta-se automaticamente às novas projeções 4D do embedding.
+    tokenizer_corpus_buffer: List[str] = []
+    TOKENIZER_REFIT_INTERVAL_SAMPLES = 1000  # refit a cada 1000 amostras
+    TOKENIZER_CORPUS_CAP = 2000              # cap para evitar OOM (memória: ~2MB)
+    last_tokenizer_refit_sample_count = 0
+    tokenizer_growth_log: List[Dict[str, Any]] = []
+    initial_vocab_size = int(getattr(kls.tokenizer, "vocab_size", 0))
+    logger.info(
+        f"[V7-tokenizer-growth] Initial vocab_size={initial_vocab_size} "
+        f"(target={VOCAB_SIZE}). Will refit every "
+        f"{TOKENIZER_REFIT_INTERVAL_SAMPLES} samples during FASE1."
+    )
+
     # V6.5-V2-metrics — reseta histórico de métricas SOM no início de CONHECIMENTO
     kls.reset_som_metric_history()
     logger.info("[V6.5-V2-metrics] Histórico de métricas SOM resetado para FASE 1.")
@@ -1468,6 +1495,54 @@ def run_fase_conhecimento(
                         f"{len(kls.buffer_4d)} samples (cap={MAX_BUFFER_SIZE})"
                     )
 
+                # V7-tokenizer-growth — Acumula corpus para refit do tokenizer
+                # User requirement: "verificar impacto de seq_len em vocab
+                # real=293 (alvo 16384)". Coleta amostras reais do streaming
+                # para treinar o BBPE com corpus maior.
+                try:
+                    # Adiciona amostras do chunk ao buffer (cap para evitar OOM)
+                    tokenizer_corpus_buffer.extend(chunk_samples[:200])
+                    if len(tokenizer_corpus_buffer) > TOKENIZER_CORPUS_CAP:
+                        # Mantém apenas as TOKENIZER_CORPUS_CAP mais recentes
+                        overflow_corpus = len(tokenizer_corpus_buffer) - TOKENIZER_CORPUS_CAP
+                        del tokenizer_corpus_buffer[:overflow_corpus]
+
+                    total_so_far_now = sum(samples_per_dataset.values())
+                    samples_since_refit = total_so_far_now - last_tokenizer_refit_sample_count
+                    if (samples_since_refit >= TOKENIZER_REFIT_INTERVAL_SAMPLES
+                            and len(tokenizer_corpus_buffer) >= 200):
+                        # Refit tokenizer com corpus acumulado
+                        vocab_before = int(getattr(kls.tokenizer, "vocab_size", 0))
+                        try:
+                            kls.tokenizer.fit(list(tokenizer_corpus_buffer))
+                            vocab_after = int(getattr(kls.tokenizer, "vocab_size", 0))
+                            growth = vocab_after - vocab_before
+                            tokenizer_growth_log.append({
+                                "step": step,
+                                "chunk_idx": chunk_idx_global,
+                                "total_samples": total_so_far_now,
+                                "corpus_size": len(tokenizer_corpus_buffer),
+                                "vocab_before": vocab_before,
+                                "vocab_after": vocab_after,
+                                "vocab_growth": growth,
+                            })
+                            logger.info(
+                                f"[V7-tokenizer-growth] Refit @ sample "
+                                f"{total_so_far_now}: vocab {vocab_before} → "
+                                f"{vocab_after} (+{growth}, corpus="
+                                f"{len(tokenizer_corpus_buffer)})"
+                            )
+                            last_tokenizer_refit_sample_count = total_so_far_now
+                        except Exception as tok_fit_err:
+                            logger.warning(
+                                f"[V7-tokenizer-growth] Refit failed (non-fatal): "
+                                f"{tok_fit_err}"
+                            )
+                except Exception as tok_col_err:
+                    logger.warning(
+                        f"[V7-tokenizer-growth] Corpus collection failed: {tok_col_err}"
+                    )
+
                 # V6.5-V2-metrics — Computa métricas SOM após cada chunk
                 # (QE, TE, Kaski-Lagus, Variância Explicada, Dead Neurons,
                 #  Colapso Topológico, Estagnação QE, Cruzamento Vizinhança).
@@ -1709,6 +1784,11 @@ def run_fase_conhecimento(
         "auto_adjust_log": auto_adjust_log[-50:],
         "auto_adjust_state": auto_adjuster.state.to_dict(),
         "stop_training_reason": stop_training_reason,
+        # V7-tokenizer-growth — diagnóstico de crescimento do vocabulário
+        "tokenizer_growth_log": tokenizer_growth_log,
+        "tokenizer_final_vocab_size": int(getattr(kls.tokenizer, "vocab_size", 0)),
+        "tokenizer_initial_vocab_size": int(initial_vocab_size),
+        "tokenizer_target_vocab_size": int(VOCAB_SIZE),
     }
 
 

src/bigru_t/model/som_auto_adjust.py

@@ -32,6 +32,8 @@ Stop-learning detection (user: "parar caso não esteja"):
   - QE estagnado em nível crítico (severity="severe") por ≥ 5 chunks consecutivos
   - Dead neuron rate > 0.8 após revival + conscience boost
   - All metrics NaN por 2 batches consecutivos
+  - V7: Neighborhood crossing severity="severe" por ≥ 4 chunks consecutivos
+    (instabilidade sináptica crônica — Prova 12)
 
 ============================================================================
 MATH (Kohonen canonical + adaptive extensions)
@@ -42,8 +44,18 @@ MATH (Kohonen canonical + adaptive extensions)
     α₀_eff ← α₀_eff · (1 + 0.3 · norm_qe)            (resposta ao QE)
     σ₀_eff ← σ₀_eff · (1 + 0.4 · te)                 (resposta ao TE)
     α₀_eff ← α₀_eff · (1 - 0.2 · crossing_severity)  (estabiliza crossing)
+- V7 — Crossing severo extra boost:
+    σ₀_eff ← σ₀_eff + 0.25  (re-organização topológica forçada)
 - Decay bound: α₀_eff ∈ [α₀, 2·α₀], σ₀_eff ∈ [σ₀, 2·σ₀]
   (nunca abaixo do canônico, no máximo 2× para evitar divergência)
+
+Prova 12 (neighborhood_crossing_severe stop):
+  Se std(TE_final) > 2·growth_threshold·std(TE_initial) ou TE cresce
+  monotonicamente no final, severity="severe". Após 4 chunks consecutivos
+  severe, o treino para — a rede entrou em regime de instabilidade
+  sináptica crônica onde correções (-α +σ) não recuperam a topologia.
+  Continuar o treino só degrada mais a topologia, desperdiçando compute.
+  Stop-learning preserva o estado atual e permite diagnóstico.
 """
 from __future__ import annotations
 
@@ -75,6 +87,11 @@ class SOMAutoAdjustState:
     consecutive_qe_stagnant_severe: int = 0
     consecutive_dead_rate_critical: int = 0
     consecutive_nan_batches: int = 0
+    # V7 — Neighborhood crossing severo consecutivo (instabilidade crônica)
+    # User requirement: "neighborhood_crossing_severe" deve ser detectado e
+    # tratado. Após N batches consecutivos com severity="severe", o treino
+    # para (a rede sofreu instabilidade sináptica crônica).
+    consecutive_crossing_severe: int = 0
     # Histórico de ações tomadas (últimas 50)
     actions_log: List[Dict[str, Any]] = field(default_factory=list)
     # Flag de parada (uma vez True, treino não deve continuar)
@@ -89,6 +106,7 @@ class SOMAutoAdjustState:
         self.consecutive_qe_stagnant_severe = 0
         self.consecutive_dead_rate_critical = 0
         self.consecutive_nan_batches = 0
+        self.consecutive_crossing_severe = 0
 
     def to_dict(self) -> Dict[str, Any]:
         return {
@@ -98,6 +116,7 @@ class SOMAutoAdjustState:
             "consecutive_qe_stagnant_severe": int(self.consecutive_qe_stagnant_severe),
             "consecutive_dead_rate_critical": int(self.consecutive_dead_rate_critical),
             "consecutive_nan_batches": int(self.consecutive_nan_batches),
+            "consecutive_crossing_severe": int(self.consecutive_crossing_severe),
             "stop_training": bool(self.stop_training),
             "stop_reason": self.stop_reason,
             "n_actions_total": int(self.n_actions_total),
@@ -131,6 +150,14 @@ class SOMAutoAdjuster:
     COLLAPSE_POINT_LIMIT = 3             # 3 collapses consecutivos = parar
     DEAD_CRITICAL_LIMIT = 5              # 5 batches críticos = parar
     NAN_BATCH_LIMIT = 2                  # 2 batches NaN = parar
+    # V7 — Neighborhood crossing severo (user requirement)
+    # 4 batches consecutivos com crossing_severity="severe" = parar treino.
+    # Justificativa matemática (Prova 12): se a oscilação crônica do TE
+    # persiste por 4+ batches apesar das correções (-α +σ), isto indica
+    # que a vizinhança topológica não consegue fixar — a rede entrou em
+    # regime de instabilidade sináptica crônica, e continuar o treino
+    # só degrada a topologia. Stop-learning evita desperdiçar compute.
+    CROSSING_SEVERE_LIMIT = 4
 
     def __init__(self, state: Optional[SOMAutoAdjustState] = None):
         self.state = state or SOMAutoAdjustState()
@@ -355,6 +382,7 @@ class SOMAutoAdjuster:
 
         # ==============================================================
         # 2.4 Neighborhood Crossing  →  -α₀ (estabiliza), +σ₀
+        # V7 — Crossing severo consecutivo → stop-learning (Prova 12)
         # ==============================================================
         if crossing_detected:
             # Desacelera aprendizado para estabilizar
@@ -367,6 +395,38 @@ class SOMAutoAdjuster:
                 f"({crossing_severity})"
             )
 
+            # V7 — Contador de crossing severo consecutivo
+            if crossing_severity == "severe":
+                self.state.consecutive_crossing_severe += 1
+                actions.append(
+                    f"crossing_severe_consecutive="
+                    f"{self.state.consecutive_crossing_severe} "
+                    f"(limit={self.CROSSING_SEVERE_LIMIT})"
+                )
+                # Intervenção extra em crossing severo: boost agressivo de σ
+                # para forçar re-organização topológica.
+                self.state.sigma0_boost = min(2.0, self.state.sigma0_boost + 0.25)
+                actions.append(
+                    "crossing_severe_extra_boost: σ+0.25 (re-organização forçada)"
+                )
+                if self.state.consecutive_crossing_severe >= self.CROSSING_SEVERE_LIMIT:
+                    self.state.stop_training = True
+                    self.state.stop_reason = (
+                        f"neighborhood_crossing_severe_consecutive="
+                        f"{self.state.consecutive_crossing_severe}"
+                    )
+                    logger.error(
+                        f"[som_auto_adjust] STOP: {self.state.stop_reason} "
+                        f"(instabilidade sináptica crônica por "
+                        f"{self.state.consecutive_crossing_severe} batches)"
+                    )
+            else:
+                # Crossing mild: reseta contador de severo (mild é recuperável)
+                self.state.consecutive_crossing_severe = 0
+        else:
+            # Sem crossing: reseta contador
+            self.state.consecutive_crossing_severe = 0
+
         # ==============================================================
         # Aplica boosts efetivos ao SOM (se alterados)
         # ==============================================================

src/bigru_t/training/ewc.py

@@ -1,6 +1,37 @@
-"""ewc.py — V6: Elastic Weight Consolidation with Kohonen 4D per-neuron support.
+"""ewc.py — V6/V7: Elastic Weight Consolidation with Kohonen 4D per-neuron support
++ Fisher accumulation (online EWC with EMA decay).
 
 ═══════════════════════════════════════════════════════════════════════════════
+V7 — FISHER ACCUMULATION (ONLINE EWC)
+═══════════════════════════════════════════════════════════════════════════════
+
+V6 mantinha `online_ewc: bool = True` e `online_decay: float = 0.99` na
+configuração, mas NUNCA os utilizava — a cada chamada de `compute_fisher()`,
+a Fisher anterior era SOBRESCRITA pela nova (perda total do conhecimento
+de tarefas anteriores). Isto explica o sintoma observado na análise V7:
+
+  Fisher_w_mean = 0.0  (EWC sem acumulação Fisher — possível bug)
+
+A correção V7 implementa a acumulação online clássica (Schwarz et al. 2018):
+
+  F_new = decay · F_old + (1 - decay) · F_computed
+
+onde:
+  - F_old     : Fisher acumulada de tarefas anteriores (persistente)
+  - F_computed: Fisher computada nesta tarefa (a partir de gradients²)
+  - decay     : fator EMA (default 0.99 — preserva 99% do passado)
+  - F_new     : Fisher acumulada após esta tarefa
+
+Analogamente, os pesos ótimos (anchors) seguem EMA:
+  W*_new = decay · W*_old + (1 - decay) · W_current
+
+Isto garante que:
+  1. Tarefas antigas continuem a ser "ancoradas" mesmo após muitas tarefas
+     novas (evita catastrophic forgetting multi-tarefa).
+  2. A Fisher seja suave (sem saltos bruscos) — estável sob gradient noise.
+  3. A penalty V6 (clássica + Kohonen per-neuron + topológica) é aplicada
+     sobre a Fisher ACUMULADA, não sobre a Fisher da última tarefa.
+
 V6 — EWC + KOHONEN 4D PER-NEURON WEIGHTS
 ═══════════════════════════════════════════════════════════════════════════════
 
@@ -80,7 +111,7 @@ class EWCConfigV6:
     fisher_n_samples: int = 32
     fisher_batch_size: int = 4
     online_ewc: bool = True
-    online_decay: float = 0.99
+    online_decay: float = 0.99          # V7 — agora EFETIVAMENTE usado (era decorativo)
     fisher_smoothing_alpha: float = 0.1
     adaptive_lambda: bool = True
     fisher_clip_eps: float = 1e-8
@@ -92,6 +123,14 @@ class EWCConfigV6:
     skip_som_filled_neurons: bool = True  # default True (user requirement)
     # Skip_mask é lido do OrqCell.neuron_filled_mask em compute_fisher()
     # e aplicado em compute_penalty() para zerar a penalidade dos filled.
+    # ───────────────────────────────────────────────────────────────────────
+    # V7 — Fisher accumulation diagnostics (apenas leitura, não-configurável)
+    # ───────────────────────────────────────────────────────────────────────
+    # fisher_accumulation_active: se True, compute_fisher() faz EMA entre
+    #   F_old e F_computed (V7 — ativação do online_ewc).
+    # fisher_ema_initialized: True após a 1ª compute_fisher (não há F_old
+    #   na 1ª chamada — apenas inicializa).
+    fisher_accumulation_active: bool = True  # V7 — ativa por padrão
 
 
 class EWCV6:
@@ -124,6 +163,16 @@ class EWCV6:
         self._last_task_grad_norm: float = 0.0
         self._last_ewc_grad_norm: float = 0.0
         self._adaptive_lambda: float = self.cfg.lambda_ewc
+        # ───────────────────────────────────────────────────────────────────
+        # V7 — Fisher accumulation state (online EWC with EMA)
+        # ───────────────────────────────────────────────────────────────────
+        # _fisher_ema_initialized: False até a 1ª compute_fisher() concluir.
+        #   Antes disso, compute_fisher() apenas inicializa F = F_computed.
+        #   Após isso, F = decay·F_old + (1-decay)·F_computed.
+        self._fisher_ema_initialized: bool = False
+        # Diagnóstico: média da Fisher acumulada (para auditoria)
+        self._fisher_w_mean: float = 0.0   # média da Fisher clássica (scalar)
+        self._fisher_n_mean: float = 0.0   # média da Fisher per-neuron (scalar)
         # Detectar OrqCells no modelo
         self.orq_cells: Dict[str, nn.Module] = self._find_orq_cells()
 
@@ -241,8 +290,8 @@ class EWCV6:
             for orq_name in neuron_fisher_accum:
                 neuron_fisher_accum[orq_name] /= max(1, n_used // bs)
 
-        # Smooth + clip Fisher
-        self.fisher = self._smooth_and_clip(fisher_accum)
+        # Smooth + clip Fisher (compute F_computed — smoothed/clipped)
+        fisher_computed = self._smooth_and_clip(fisher_accum)
         # V6.1 — Aplicar skip mask também no Fisher CLÁSSICO para
         # orq_cell.neuron_cache (evita dupla penalização: o classic Fisher
         # e o Kohonen per-neuron Fisher apontam para o MESMO parâmetro).
@@ -253,13 +302,34 @@ class EWCV6:
                 if not hasattr(orq_cell, "neuron_filled_mask"):
                     continue
                 param_name = f"{orq_name}.neuron_cache"
-                if param_name not in self.fisher:
+                if param_name not in fisher_computed:
                     continue
                 filled = orq_cell.neuron_filled_mask.bool()
                 keep_mask = (~filled).float()  # 1 onde EWC atua, 0 onde skip
                 # Zera o Fisher das posições filled no classic Fisher
-                self.fisher[param_name] = self.fisher[param_name] * keep_mask.unsqueeze(-1)
-        self.neuron_fisher = {}
+                fisher_computed[param_name] = fisher_computed[param_name] * keep_mask.unsqueeze(-1)
+
+        # V7 ── Fisher accumulation (online EWC with EMA) ─────────────────
+        # F_new = decay · F_old + (1 - decay) · F_computed
+        # Se for a 1ª chamada (não inicializado), apenas copia F_computed.
+        # Aplicado APÓS smoothing/clip/skip_mask para herdar as propriedades
+        # de estabilidade numérica (log-clip evita explosão de Fisher EMA).
+        if self.cfg.online_ewc and self.cfg.fisher_accumulation_active \
+                and self._fisher_ema_initialized and len(self.fisher) > 0:
+            decay = float(self.cfg.online_decay)
+            for name, f_new_computed in fisher_computed.items():
+                f_old = self.fisher.get(name)
+                if f_old is not None and f_old.shape == f_new_computed.shape:
+                    fisher_computed[name] = (
+                        decay * f_old + (1.0 - decay) * f_new_computed
+                    )
+                # else: novo parâmetro — apenas usa F_computed (cold start)
+        # Aplica Fisher final (acumulada ou cold-start)
+        self.fisher = fisher_computed
+
+        # ── Per-neuron Fisher accumulation (V7) ──────────────────────────
+        # Mesma lógica EMA para neuron_fisher (orq_cell).
+        neuron_fisher_computed: Dict[str, torch.Tensor] = {}
         self.fisher_neuron_mask = {}  # V6.1
         for orq_name, f_tensor in neuron_fisher_accum.items():
             # V6.1 — Aplicar skip mask: neurônios filled no SOM NÃO recebem Fisher
@@ -280,21 +350,70 @@ class EWCV6:
                     self.fisher_neuron_mask[orq_name] = torch.ones(
                         f_tensor.size(0), dtype=torch.bool
                     )
-            self.neuron_fisher[orq_name] = self._smooth_and_clip_tensor(f_tensor)
-
-        # Salvar pesos ótimos atuais (anchors)
-        self.optimal_weights = {
+            f_smoothed = self._smooth_and_clip_tensor(f_tensor)
+            # V7 — EMA accumulation sobre neuron_fisher
+            if self.cfg.online_ewc and self.cfg.fisher_accumulation_active \
+                    and self._fisher_ema_initialized \
+                    and orq_name in self.neuron_fisher:
+                f_old = self.neuron_fisher[orq_name]
+                if f_old.shape == f_smoothed.shape:
+                    decay = float(self.cfg.online_decay)
+                    f_smoothed = decay * f_old + (1.0 - decay) * f_smoothed
+            neuron_fisher_computed[orq_name] = f_smoothed
+        self.neuron_fisher = neuron_fisher_computed
+
+        # Salvar pesos ótimos atuais (anchors) — V7 EMA accumulation
+        # W*_new = decay · W*_old + (1 - decay) · W_current
+        # Se 1ª chamada, apenas W*_new = W_current (cold start).
+        new_optimal_weights = {
             name: p.detach().clone()
             for name, p in self.model.named_parameters()
             if name in self.fisher
         }
+        if (self.cfg.online_ewc and self.cfg.fisher_accumulation_active
+                and self._fisher_ema_initialized and len(self.optimal_weights) > 0):
+            decay = float(self.cfg.online_decay)
+            for name, w_new in new_optimal_weights.items():
+                w_old = self.optimal_weights.get(name)
+                if w_old is not None and w_old.shape == w_new.shape:
+                    new_optimal_weights[name] = (
+                        decay * w_old + (1.0 - decay) * w_new
+                    )
+        self.optimal_weights = new_optimal_weights
+
+        # V7 — EMA accumulation para neuron_optimal (orq_cell anchors)
         for orq_name, orq_cell in self.orq_cells.items():
             if orq_name in self.neuron_fisher:
-                self.neuron_optimal[orq_name] = orq_cell.neuron_cache.detach().clone()
-                # Salvar topologia do grid (fixa)
+                new_w_n = orq_cell.neuron_cache.detach().clone()
+                if (self.cfg.online_ewc and self.cfg.fisher_accumulation_active
+                        and self._fisher_ema_initialized
+                        and orq_name in self.neuron_optimal):
+                    w_old = self.neuron_optimal[orq_name]
+                    if w_old.shape == new_w_n.shape:
+                        decay = float(self.cfg.online_decay)
+                        new_w_n = decay * w_old + (1.0 - decay) * new_w_n
+                self.neuron_optimal[orq_name] = new_w_n
+                # Salvar topologia do grid (fixa — NÃO sofre EMA, é constante)
                 if hasattr(orq_cell, "grid_dist"):
                     self.neuron_grid_dist[orq_name] = orq_cell.grid_dist.detach().clone()
 
+        # V7 — Diagnóstico: média das Fishers acumuladas
+        if self.fisher:
+            try:
+                all_means = [float(f.mean().item()) for f in self.fisher.values()]
+                self._fisher_w_mean = sum(all_means) / len(all_means) if all_means else 0.0
+            except (RuntimeError, ValueError):
+                self._fisher_w_mean = 0.0
+        if self.neuron_fisher:
+            try:
+                all_n_means = [float(f.mean().item()) for f in self.neuron_fisher.values()]
+                self._fisher_n_mean = sum(all_n_means) / len(all_n_means) if all_n_means else 0.0
+            except (RuntimeError, ValueError):
+                self._fisher_n_mean = 0.0
+
+        # V7 — Marca que a Fisher foi inicializada (próxima compute_fisher fará EMA)
+        self._fisher_ema_initialized = True
+
         self.n_tasks += 1
         self.model.zero_grad()
         gc.collect(0)
@@ -501,6 +620,12 @@ class EWCV6:
             "skip_som_filled_neurons": self.cfg.skip_som_filled_neurons,
             "n_active_ewc_neurons": n_active,    # EWC atua nestes
             "n_masked_som_neurons": n_masked,    # SOM já cobre estes (não duplica)
+            # V7 — Fisher accumulation diagnostics
+            "online_ewc_active": bool(self.cfg.online_ewc and self.cfg.fisher_accumulation_active),
+            "online_decay": float(self.cfg.online_decay),
+            "fisher_ema_initialized": bool(self._fisher_ema_initialized),
+            "fisher_w_mean": float(self._fisher_w_mean),  # diagnostic
+            "fisher_n_mean": float(self._fisher_n_mean),  # diagnostic
         }
 
 

v6_5_v2_attention_eval.json

@@ -0,0 +1,21 @@
+{
+  "evaluation": "attention_v65_v2",
+  "user_requirement": "verificar se o mecanismo de atenção está ativo e acessado logicamente funcional",
+  "metrics": {
+    "active": true,
+    "n_calls": 10000,
+    "n_errors": 0,
+    "last_norm_in": 111.79922485351562,
+    "last_norm_out": 114.68800354003906,
+    "last_attn_activated": true,
+    "last_attn_diff_norm": 113.93474578857422,
+    "n_heads": 8,
+    "logic_functional": true
+  },
+  "active": true,
+  "logic_functional": true,
+  "n_calls": 10000,
+  "n_errors": 0,
+  "n_heads": 8,
+  "assessment": "PASS"
+}

v6_5_v2_model_states.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7748a306b4aac259a9d877b2672fe5e7d277872b75854a4084b58996b6712cfa
+size 118971444

v6_5_v2_predict_fix_eval.json

@@ -0,0 +1,147 @@
+{
+  "evaluation": "predict_fix_v65_v2",
+  "user_requirement": "os strings 'gato' e 'cachorro' são fixos quando deveriam ser extrações variáveis e flexíveis de rótulos proveniente de dados dos datasets anteriormente treinados",
+  "n_test_queries": 6,
+  "results": [
+    {
+      "query": "o gato dorme na cama",
+      "prediction": "short_text",
+      "probability": 0.4827089011669159,
+      "is_gato_hardcoded": false,
+      "is_cachorro_hardcoded": false,
+      "is_registry_label": true,
+      "is_default_label": false
+    },
+    {
+      "query": "calcule dois mais dois",
+      "prediction": "short_text",
+      "probability": 0.35426780581474304,
+      "is_gato_hardcoded": false,
+      "is_cachorro_hardcoded": false,
+      "is_registry_label": true,
+      "is_default_label": false
+    },
+    {
+      "query": "qual é a capital do brasil",
+      "prediction": "long_text",
+      "probability": 0.5526613593101501,
+      "is_gato_hardcoded": false,
+      "is_cachorro_hardcoded": false,
+      "is_registry_label": true,
+      "is_default_label": false
+    },
+    {
+      "query": "explique o que é uma rede neural",
+      "prediction": "short_text",
+      "probability": 0.3866918683052063,
+      "is_gato_hardcoded": false,
+      "is_cachorro_hardcoded": false,
+      "is_registry_label": true,
+      "is_default_label": false
+    },
+    {
+      "query": "olá como você está",
+      "prediction": "short_text",
+      "probability": 0.4471302032470703,
+      "is_gato_hardcoded": false,
+      "is_cachorro_hardcoded": false,
+      "is_registry_label": true,
+      "is_default_label": false
+    },
+    {
+      "query": "traduza hello para portugues",
+      "prediction": "short_text",
+      "probability": 0.35634148120880127,
+      "is_gato_hardcoded": false,
+      "is_cachorro_hardcoded": false,
+      "is_registry_label": true,
+      "is_default_label": false
+    }
+  ],
+  "per_dataset_results": [
+    {
+      "dataset": "dominguesm/restore-punctuation-ptbr-dataset",
+      "expected_labels": [
+        "unpunctuated",
+        "punctuated"
+      ],
+      "prediction": "punctuated",
+      "valid_for_dataset": true
+    },
+    {
+      "dataset": "carolina-c4ai/corpus-carolina",
+      "expected_labels": [
+        "raw_corpus",
+        "normalized_text"
+      ],
+      "prediction": "normalized_text",
+      "valid_for_dataset": true
+    },
+    {
+      "dataset": "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1",
+      "expected_labels": [
+        "user_turn",
+        "assistant_turn"
+      ],
+      "prediction": "assistant_turn",
+      "valid_for_dataset": true
+    },
+    {
+      "dataset": "dominguesm/Canarim-Instruct-PTBR-Dataset",
+      "expected_labels": [
+        "instruction",
+        "response"
+      ],
+      "prediction": "response",
+      "valid_for_dataset": true
+    },
+    {
+      "dataset": "adalbertojunior/punctuation-ptbr",
+      "expected_labels": [
+        "unpunctuated",
+        "punctuated"
+      ],
+      "prediction": "punctuated",
+      "valid_for_dataset": true
+    },
+    {
+      "dataset": "iara-project/news-articles-ptbr-dataset",
+      "expected_labels": [
+        "headline",
+        "body"
+      ],
+      "prediction": "body",
+      "valid_for_dataset": true
+    },
+    {
+      "dataset": "manoela/noticias_ptbr",
+      "expected_labels": [
+        "headline",
+        "body"
+      ],
+      "prediction": "body",
+      "valid_for_dataset": true
+    },
+    {
+      "dataset": "BrunoN-Dev/corpus-ptbr-v1",
+      "expected_labels": [
+        "short_text",
+        "long_text"
+      ],
+      "prediction": "long_text",
+      "valid_for_dataset": true
+    }
+  ],
+  "summary": {
+    "n_returns_gato": 0,
+    "n_returns_cachorro": 0,
+    "n_returns_registry_label": 6,
+    "n_returns_default_label": 0,
+    "hardcoded_bug_present": false,
+    "predict_fix_verified": true
+  },
+  "quality_assessment": {
+    "fix_status": "PASS",
+    "note": "predict() não retorna mais 'gato'/'cachorro' fixos — usa label_registry dinâmico."
+  }
+}

v6_5_v2_report.json

@@ -0,0 +1,309 @@
+{
+  "version": "V6.5-V2",
+  "timestamp": "2026-08-09T21:42:58.763756",
+  "config": {
+    "som_grid": [
+      4,
+      4,
+      4,
+      4
+    ],
+    "n_neurons": 256,
+    "hidden_dim": 1024,
+    "vocab_size": 16384,
+    "n_hypotheses": 16,
+    "n_trials": 3,
+    "hyp_train_steps": 30,
+    "stream_batch_size": 100,
+    "meta_conhecimento": 8000,
+    "meta_punicão": 2000,
+    "conhecimento_datasets": [
+      "dominguesm/restore-punctuation-ptbr-dataset",
+      "carolina-c4ai/corpus-carolina",
+      "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1",
+      "dominguesm/Canarim-Instruct-PTBR-Dataset",
+      "adalbertojunior/punctuation-ptbr",
+      "iara-project/news-articles-ptbr-dataset",
+      "manoela/noticias_ptbr",
+      "BrunoN-Dev/corpus-ptbr-v1"
+    ],
+    "punicão_dataset": "BrunoN-Dev/corpus-ptbr-v1"
+  },
+  "xeon_status": {
+    "version": "V6",
+    "physical_cores": 2,
+    "env": {
+      "MKL_ENABLE_INSTRUCTIONS": "AVX512",
+      "MKL_NUM_THREADS": "2",
+      "OMP_NUM_THREADS": "2",
+      "MKL_DYNAMIC": "FALSE",
+      "DNNL_PRIMITIVE_CACHE_CAPACITY": "1024",
+      "ONEDNN_MAX_CPU_ISA": "AMX_INT8",
+      "KMP_AFFINITY": "granularity=fine,compact,1,0",
+      "KMP_BLOCKTIME": "1"
+    },
+    "avx512": {
+      "supported": true,
+      "desc": "AVX512_VNNI (full INT8 acceleration)"
+    },
+    "amx": {
+      "supported": true,
+      "desc": "AMX (tile + int8 + bf16) — full AMX acceleration"
+    },
+    "ipex_available": false,
+    "init_done": true
+  },
+  "fp16_benchmark": {
+    "best_time_ms": 95.63248199992813,
+    "avg_time_ms": 96.47887749997608,
+    "best_tflops": 1.3384573664008448,
+    "avg_tflops": 1.3267152698789613,
+    "matrix_size": 4000.0
+  },
+  "v2_verification": {
+    "checks": {
+      "v2_instantiation": {
+        "status": "PASS",
+        "details": "n_hyp=4/8 (active=4), n_trials=2, delta_scale=0.0100"
+      },
+      "predict_dynamic_labels": {
+        "status": "PASS",
+        "details": "predict returned: negative_class (dynamic, not hardcoded)"
+      },
+      "process_batch_v2_conhecimento": {
+        "status": "PASS",
+        "details": "phase=CONHECIMENTO, action=none"
+      },
+      "v2_methods_exist": {
+        "status": "PASS",
+        "details": "train_hypotheses, select_best_delta, apply_best_delta_and_consolidate, process_batch_v2, get_v2_metrics"
+      }
+    },
+    "n_pass": 4,
+    "n_fail": 0,
+    "all_pass": true
+  },
+  "fase_1_conhecimento_summary": {
+    "total_samples": 8000,
+    "meta_atingida": true,
+    "elapsed_s": 576.7120866775513,
+    "storage_critical_stopped": false
+  },
+  "fase_2_punicão_summary": {
+    "total_samples": 2000,
+    "meta_atingida": true,
+    "elapsed_s": 281.3677294254303,
+    "punishment_events": 24,
+    "hypotheses_trainings": 12,
+    "delta_applications": 12,
+    "skipped": false
+  },
+  "attention_eval_summary": {
+    "active": true,
+    "logic_functional": true,
+    "n_calls": 10000,
+    "assessment": "PASS"
+  },
+  "predict_fix_summary": {
+    "n_returns_gato": 0,
+    "n_returns_cachorro": 0,
+    "n_returns_registry_label": 6,
+    "n_returns_default_label": 0,
+    "hardcoded_bug_present": false,
+    "predict_fix_verified": true
+  },
+  "user_questions_summary": {
+    "n_with_answer": 3,
+    "n_with_think": 0,
+    "answer_rate": 1.0,
+    "think_rate": 0.0,
+    "avg_latency_ms": 13.19591204325358,
+    "avg_reasoning_length": 68.66666666666667
+  },
+  "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": 118.971444,
+    "size_gb": 0.11080079153180122,
+    "size_status": "OK",
+    "size_within_1gb_limit": true,
+    "reason": "end_of_training_v2",
+    "step": 700,
+    "total_samples": 10000,
+    "n_tensors": 7,
+    "n_buffer_tail": 64
+  },
+  "final_v2_metrics": {
+    "version": "V2-dynamic",
+    "n_hypotheses": 16,
+    "n_hypotheses_active": 16,
+    "max_n_hypotheses": 32,
+    "n_trials": 6,
+    "hyp_train_steps": 80,
+    "hyp_lr": 0.0001,
+    "delta_scale": 0.0010000000474974513,
+    "n_generators": 32,
+    "punishment_count": 0,
+    "success_count": 0,
+    "training_ready": false,
+    "classifier_trained": true,
+    "ewc_reference_set": true,
+    "buffer_size": 256,
+    "total_hyp_steps_executed": 710,
+    "n_train_hyp_calls": 12,
+    "dynamic_adaptation": {
+      "loss_history_len": 8,
+      "loss_stats": {
+        "slope": 0.0008405418623061408,
+        "volatility": 0.007682365915095164,
+        "mean": 0.6946855634450912,
+        "std": 0.005336828694319248,
+        "n": 8
+      },
+      "punishment_rate": 1.0,
+      "punishment_window_size": 12,
+      "n_adaptations": 20,
+      "limits": {
+        "min_n_hypotheses": 4,
+        "max_n_hypotheses": 32,
+        "min_n_trials": 1,
+        "max_n_trials": 6,
+        "min_hyp_train_steps": 10,
+        "max_hyp_train_steps": 80
+      },
+      "last_5_adaptations": [
+        {
+          "trigger": "punishment",
+          "step": 19,
+          "before": {
+            "n_hypotheses": 26,
+            "n_trials": 6,
+            "hyp_train_steps": 80
+          },
+          "after": {
+            "n_hypotheses": 24,
+            "n_trials": 6,
+            "hyp_train_steps": 80
+          },
+          "adapted": true,
+          "rules_fired": [
+            "n_hyp-2 (vol=0.016 → 24)"
+          ],
+          "loss_stats": {
+            "slope": -0.0026504212901705786,
+            "volatility": 0.015901827414676772,
+            "mean": 0.6972703039646149,
+            "std": 0.01108787203502452,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        },
+        {
+          "trigger": "auto",
+          "step": 20,
+          "before": {
+            "n_hypotheses": 24,
+            "n_trials": 6,
+            "hyp_train_steps": 80
+          },
+          "after": {
+            "n_hypotheses": 22,
+            "n_trials": 6,
+            "hyp_train_steps": 80
+          },
+          "adapted": true,
+          "rules_fired": [
+            "n_hyp-2 (vol=0.007 → 22)"
+          ],
+          "loss_stats": {
+            "slope": 0.0013643034866877965,
+            "volatility": 0.007450016062041352,
+            "mean": 0.6949898302555084,
+            "std": 0.0051776853983589305,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        },
+        {
+          "trigger": "punishment",
+          "step": 21,
+          "before": {
+            "n_hypotheses": 22,
+            "n_trials": 6,
+            "hyp_train_steps": 80
+          },
+          "after": {
+            "n_hypotheses": 20,
+            "n_trials": 6,
+            "hyp_train_steps": 80
+          },
+          "adapted": true,
+          "rules_fired": [
+            "n_hyp-2 (vol=0.007 → 20)"
+          ],
+          "loss_stats": {
+            "slope": 0.0013643034866877965,
+            "volatility": 0.007450016062041352,
+            "mean": 0.6949898302555084,
+            "std": 0.0051776853983589305,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        },
+        {
+          "trigger": "auto",
+          "step": 22,
+          "before": {
+            "n_hypotheses": 20,
+            "n_trials": 6,
+            "hyp_train_steps": 80
+          },
+          "after": {
+            "n_hypotheses": 18,
+            "n_trials": 6,
+            "hyp_train_steps": 80
+          },
+          "adapted": true,
+          "rules_fired": [
+            "n_hyp-2 (vol=0.008 → 18)"
+          ],
+          "loss_stats": {
+            "slope": 0.0008405418623061408,
+            "volatility": 0.007682365915095164,
+            "mean": 0.6946855634450912,
+            "std": 0.005336828694319248,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        },
+        {
+          "trigger": "punishment",
+          "step": 23,
+          "before": {
+            "n_hypotheses": 18,
+            "n_trials": 6,
+            "hyp_train_steps": 80
+          },
+          "after": {
+            "n_hypotheses": 16,
+            "n_trials": 6,
+            "hyp_train_steps": 80
+          },
+          "adapted": true,
+          "rules_fired": [
+            "n_hyp-2 (vol=0.008 → 16)"
+          ],
+          "loss_stats": {
+            "slope": 0.0008405418623061408,
+            "volatility": 0.007682365915095164,
+            "mean": 0.6946855634450912,
+            "std": 0.005336828694319248,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        }
+      ]
+    }
+  }
+}

v6_5_v2_user_questions.json

@@ -0,0 +1,82 @@
+{
+  "evaluation": "user_questions_without_help_v65_v2",
+  "user_requirement": "não ajudar o modelo em respostas e lançar perguntas",
+  "questions_sent_verbatim": true,
+  "no_context_added": true,
+  "no_system_prompt": true,
+  "no_few_shot": true,
+  "n_questions": 3,
+  "questions": [
+    "Luva de Pedreiro Távila",
+    "Lula reserva valor",
+    "Amazonas força-tarefa vítimas"
+  ],
+  "results": [
+    {
+      "query": "Luva de Pedreiro Távila",
+      "query_was_modified": false,
+      "context_provided": false,
+      "system_prompt_used": false,
+      "few_shot_examples": false,
+      "som_prediction": "long_text",
+      "reasoning_length": 68,
+      "has_think": false,
+      "has_plan": false,
+      "has_answer": true,
+      "has_decompose": false,
+      "think_preview": "",
+      "answer_preview": "ReasoningEngine disabled. SOM prediction: long_text",
+      "raw_response_preview": "<answer>ReasoningEngine disabled. SOM prediction: long_text</answer>",
+      "n_tags": 1,
+      "latency_ms": 28.188228607177734
+    },
+    {
+      "query": "Lula reserva valor",
+      "query_was_modified": false,
+      "context_provided": false,
+      "system_prompt_used": false,
+      "few_shot_examples": false,
+      "som_prediction": "short_text",
+      "reasoning_length": 69,
+      "has_think": false,
+      "has_plan": false,
+      "has_answer": true,
+      "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": 5.802154541015625
+    },
+    {
+      "query": "Amazonas força-tarefa vítimas",
+      "query_was_modified": false,
+      "context_provided": false,
+      "system_prompt_used": false,
+      "few_shot_examples": false,
+      "som_prediction": "short_text",
+      "reasoning_length": 69,
+      "has_think": false,
+      "has_plan": false,
+      "has_answer": true,
+      "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": 5.597352981567383
+    }
+  ],
+  "summary": {
+    "n_with_answer": 3,
+    "n_with_think": 0,
+    "answer_rate": 1.0,
+    "think_rate": 0.0,
+    "avg_latency_ms": 13.19591204325358,
+    "avg_reasoning_length": 68.66666666666667
+  },
+  "quality_assessment": {
+    "model_not_helped": true,
+    "note": "As 3 perguntas foram enviadas verbatim, sem system prompt, sem few-shot, sem contexto adicional."
+  }
+}