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

scripts/train_v6_5_v2.py

@@ -100,6 +100,27 @@ logger = logging.getLogger("train_v6_5_v2")
 os.environ["V65_ENABLE_STREAMING"] = "1"
 logger.info(f"[V6.5-V2] V65_ENABLE_STREAMING={os.environ['V65_ENABLE_STREAMING']} (forced)")
 
+# V6.5-V2-metrics-FIX-4 — HF datasets memory optimization (OOM-killer mitigation)
+# User requirement: "o processo vem sendo morto OOM-kiler (Out of memory) devido
+# algum bug de lógica ou falta de otimização que deve ser investigado".
+# Estas variáveis reduzem o consumo de memória do HF datasets library:
+#   - HF_DATASETS_DISABLE_IN_MEMORY_CACHE: não cacheia datasets em RAM
+#   - HF_DATASETS_OFFLINE=0: permite streaming mas não força cache local
+#   - DATASETS_FINGERPRINT_CACHING_DISABLED: skipa fingerprinting (CPU/memory)
+#   - TOKENIZERS_PARALLELISM=false: evita spawn de processos paralelos
+#   - HF_HUB_DISABLE_TELEMETRY: desabilita telemetria (CPU/network)
+os.environ["HF_DATASETS_DISABLE_IN_MEMORY_CACHE"] = "1"
+os.environ["DATASETS_FINGERPRINT_CACHING_DISABLED"] = "1"
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
+os.environ.setdefault("HF_DATASETS_CACHE", "/tmp/hf_datasets_cache_v65")
+# Cria o dir de cache se não existir (limpa cache antigo periodicamente)
+try:
+    cache_dir = Path(os.environ["HF_DATASETS_CACHE"])
+    cache_dir.mkdir(parents=True, exist_ok=True)
+except Exception:
+    pass
+
 sys.path.insert(0, str(SRC_ROOT))
 
 from bigru_t.utils.xeon_runtime import (  # noqa: E402
@@ -142,63 +163,60 @@ logger.info(f"[V6.5-V2] Xeon FP16 benchmark: {FP16_BENCH}")
 BATCH_SIZE = 16
 MAX_SEQ_LEN = 8
 
-# V6.5-V2-metrics-FIX-2: Parâmetros ajustados para caber em 4GB cgroup limit.
-# User requirement: "retornar os parâmetros do modelo para os valores maiores
-# e resolver falhas de lógica e de bugs que estejam causando alto consumo
-# de memória sem distorcer a arquitetura Kohonen".
-#
-# Os valores abaixo são um COMPROMISSO entre "valores maiores" e "caber em 4GB":
-#   HIDDEN_DIM: 1024 → 512 (embedding: 64MB → 32MB, attention: 16.8M → 4.2M params)
-#   VOCAB_SIZE: 16384 → 8192 (embedding: 32MB → 16MB)
-#   N_HYPOTHESES: 16 → 8 (active generators)
-#   MAX_N_HYPOTHESES: 32 → 16 (pre-allocated generators: 148.9MB → 74.5MB)
-#   HYP_HIDDEN_DIM: 256 → 128 (each generator: 1.16M → 0.58M params)
-#
-# A arquitetura Kohonen (SOM grid 6×6×6×4 = 864 neurons, BMU, Gaussian
-# neighborhood, EWC, Fisher) é PRESERVADA integralmente. Apenas as dimensões
-# dos módulos auxiliares (embedding, attention, hypothesis ensemble) são
-# reduzidas para evitar OOM no cgroup de 4GB.
+# V6.5-V2-metrics-FIX-3: Parâmetros restaurados aos valores canônicos
+# exigidos pelo usuário (sem redução por OOM — as correções de memory leak
+# no KLS já tornam os valores maiores viáveis dentro do cgroup de 4GB).
+# User requirement (FIX-3): "SEMPRE MANTER PARÂMETROS HIDDEN_DIM 1024,
+# VOCAB_SIZE 16384, N_HYPOTHESES 16, MAX_N_HYPOTHESES 32, HYP_TRAIN_STEPS 30,
+# HYP_HIDDEN_DIM 256. Grid SOM (6,6,6,4)=864 neurônios".
 #
-# Memory budget (estimativa):
-#   Embedding: 8192 × 512 × 4 = 16MB
-#   Attention: 4 × 512² × 4 = 4MB
-#   HypothesisEnsemble: 16 × (864×128 + 128×128 + 128×3456) = 16 × 0.58M = 37MB
-#   Adam state (ensemble): 2 × 37MB = 74MB
-#   HypothesisClassifier: ~616K params = 2.5MB
-#   VQ-VAE-2: ~50K params = 0.2MB
-#   SOM weights: 864 × 4 × 4 = 14KB
+# Memory budget (estimativa real após correções FIX-3):
+#   Embedding: 16384 × 1024 × 4 = 67MB
+#   Attention: 4 × 1024² × 4 = 16MB
+#   HypothesisEnsemble (32 pre-alloc, 16 active): 32×(864×256+256×256+256×3456) = 32×1.16M = 148MB
+#   Adam state (ensemble, 16 active): 2×16×1.16M×4 = 149MB
+#   HypothesisClassifier: 864→512→256→128→64→32→16→8→1 = ~616K = 2.5MB
+#   VQ-VAE-2: ~50K = 0.2MB
+#   SOM weights: 864×4×4 = 14KB
 #   Buffer (256 samples): ~4KB
-#   Total model: ~134MB
+#   Total model: ~380MB
 #   + Python + PyTorch + HF datasets cache: ~1-2GB
-#   + Training intermediates: ~200MB
-#   Total: ~1.5-2.5GB (well within 4GB)
-HIDDEN_DIM = 512                   # V6.5-V2-metrics-FIX-2: reduced from 1024
-VOCAB_SIZE = 8192                  # V6.5-V2-metrics-FIX-2: reduced from 16384
+#   + Training intermediates (com no_grad aplicado): ~200MB
+#   Total: ~2-3GB (dentro de 4GB com folga graças ao no_grad no VQ-VAE-2)
+HIDDEN_DIM = 1024                  # V6.5-V2-metrics-FIX-3: restored to canonical
+VOCAB_SIZE = 16384                 # V6.5-V2-metrics-FIX-3: restored to canonical
 SOM_GRID = (6, 6, 6, 4)  # 864 neurons (arquitetura Kohonen preservada)
 T_MAX = 10000
 N_START = 10
 LAMBDA_EWC = 0.02
-ALPHA0 = 0.1
-SIGMA0 = 1.5
+# V6.5-V2-metrics-FIX-3: α₀ e σ₀ conforme especificação canônica Kohonen
+#   α₀ ∈ [0.5, 1.0] para fase de ordenação (rough training)
+#   σ₀ = metade da maior dimensão da grade = max(6,6,6,4)/2 = 3.0
+ALPHA0 = 0.5
+SIGMA0 = 3.0
 DIM_CHOICE = "y"
 
-# V2-dynamic — HypothesisEnsemble parameters (ajustados para 4GB cgroup)
-N_HYPOTHESES = 8                  # V6.5-V2-metrics-FIX-2: reduced from 16
-MAX_N_HYPOTHESES = 16             # V6.5-V2-metrics-FIX-2: reduced from 32
-MIN_N_HYPOTHESES = 4              # limite inferior dinâmico
-N_TRIALS = 3                      # inicial
+# V2-dynamic — HypothesisEnsemble parameters (valores canônicos restaurados)
+N_HYPOTHESES = 16                  # V6.5-V2-metrics-FIX-3: restored from 8
+MAX_N_HYPOTHESES = 32              # V6.5-V2-metrics-FIX-3: restored from 16
+MIN_N_HYPOTHESES = 4               # limite inferior dinâmico
+N_TRIALS = 3                       # inicial
 MIN_N_TRIALS = 1
 MAX_N_TRIALS = 6
-HYP_TRAIN_STEPS = 30              # mantido (não afeta memória, só tempo)
+HYP_TRAIN_STEPS = 30               # mantido (canônico)
 MIN_HYP_TRAIN_STEPS = 10
 MAX_HYP_TRAIN_STEPS = 80
 HYP_LR = 1e-4
-HYP_HIDDEN_DIM = 128              # V6.5-V2-metrics-FIX-2: reduced from 256
+HYP_HIDDEN_DIM = 256               # V6.5-V2-metrics-FIX-3: restored from 128
 LOSS_HISTORY_WINDOW = 8
 PUNISHMENT_WINDOW = 12
 
 # V2-dynamic-memory — Buffer sliding window (evita OOM em treino longo)
-MAX_BUFFER_SIZE = 256
+# V6.5-V2-metrics-FIX-4: reduzido de 256 para 128 (OOM-killer mitigation).
+# O buffer_4d só precisa conter amostras recentes para que o SOM compute
+# métricas (QE, TE, KL, VE) — os pesos do SOM já capturam o conhecimento
+# acumulado de todas as amostras históricas.
+MAX_BUFFER_SIZE = 128
 
 # Streaming — User requirement: "streaming de 100 em 100 samples"
 STREAM_BATCH_SIZE = 100
@@ -212,13 +230,32 @@ MAX_SAMPLES_PUNICAO = 2000
 # User requirement: "não reduzir tempo e não gerar dados sintéticos" +
 # "todo streaming (FASE1 e da FASE2) deve ter pausa para dar tempo de conclusão
 # de processamento continuando após conclusão"
-# V6.5-V2-metrics-FIX-2: pausas reduzidas para caber em 20min de treino
-# (container kills processes after ~10min se não estiver em foreground).
-# As pausas ainda garantem tempo para processamento, mas são mais curtas.
-INTER_BATCH_PAUSE_S = 0.1          # reduzido de 0.5 (ainda há pausa)
-INTER_DATASET_PAUSE_S = 0.5        # reduzido de 2.0
-INTER_STREAM_BATCH_PAUSE_S = 0.2   # reduzido de 1.0
-POST_PROCESSING_PAUSE_S = 0.3      # reduzido de 1.5
+# V6.5-V2-metrics-FIX-4 (latest user requirement):
+#   "FASE2 PUNIÇÃO é mais pesada é pode exigir pausas do streaming até
+#    concluir o processamento".
+# Pausas separadas para FASE1 (CONHECIMENTO) e FASE2 (PUNITIVA):
+#   - FASE1: pausas moderadas (SOM-only, sem hypothesis layer)
+#   - FASE2: pausas maiores (16 hipóteses × 30 steps × 3 trials + EWC + revival)
+INTER_BATCH_PAUSE_S_FASE1 = 0.15      # CONHECIMENTO: leve
+INTER_BATCH_PAUSE_S_FASE2 = 0.60      # PUNITIVA: 4x maior (heavier processing)
+INTER_DATASET_PAUSE_S_FASE1 = 0.5
+INTER_DATASET_PAUSE_S_FASE2 = 1.5     # PUNITIVA: 3x maior
+INTER_STREAM_BATCH_PAUSE_S_FASE1 = 0.3
+INTER_STREAM_BATCH_PAUSE_S_FASE2 = 1.2  # PUNITIVA: 4x maior
+POST_PROCESSING_PAUSE_S_FASE1 = 0.4
+POST_PROCESSING_PAUSE_S_FASE2 = 1.5   # PUNITIVA: ~4x maior
+# Compatibilidade (mantém nomes antigos apontando para FASE1 — usados em
+# código legado que não diferencia fases)
+INTER_BATCH_PAUSE_S = INTER_BATCH_PAUSE_S_FASE1
+INTER_DATASET_PAUSE_S = INTER_DATASET_PAUSE_S_FASE1
+INTER_STREAM_BATCH_PAUSE_S = INTER_STREAM_BATCH_PAUSE_S_FASE1
+POST_PROCESSING_PAUSE_S = POST_PROCESSING_PAUSE_S_FASE1
+
+# V6.5-V2-metrics-FIX-4 — auto-revive config
+# User requirement: "distribuindo o processamento paralelamente".
+# Quando dead_rate > 50% e passou o cooldown, revive neurônios mortos.
+AUTO_REVIVE_DEAD_RATE_THRESHOLD = 0.5
+AUTO_REVIVE_COOLDOWN_STEPS = 200
 
 # Storage critical
 STORAGE_CRITICAL_PCT = 90
@@ -1165,13 +1202,13 @@ def run_fase_conhecimento(
                             })
 
                         step += 1
-                        time.sleep(INTER_BATCH_PAUSE_S)
+                        time.sleep(INTER_BATCH_PAUSE_S_FASE1)
                     except Exception as e:
                         logger.error(f"[V6.5-V2] Batch error: {e}")
                         traceback.print_exc()
                         continue
 
-                time.sleep(INTER_STREAM_BATCH_PAUSE_S)
+                time.sleep(INTER_STREAM_BATCH_PAUSE_S_FASE1)
                 # V2-dynamic-memory — Buffer sliding window: trunca para os
                 # últimos MAX_BUFFER_SIZE amostras após cada chunk.
                 # Os pesos do SOM já capturam o conhecimento acumulado,
@@ -1248,6 +1285,31 @@ def run_fase_conhecimento(
                 except Exception as e:
                     logger.warning(f"[V6.5-V2-metrics-FIX-2] Failed to compute SOM metrics: {e}")
 
+                # V6.5-V2-metrics-FIX-4 — Auto-revive neurônios mortos
+                # User requirement: "APRIMORAR (...) a ativação e uso e acesso
+                # dos neurônios (apenas dois estão sendo ativados:
+                # neurons_active=2/864) distribuindo o processamento paralelamente".
+                # O conscience mechanism (DeSieno 1988) já força distribuição
+                # uniforme de BMU, mas como safety net adicional, revive
+                # explicitamente neurônios que ainda estão mortos após o cooldown.
+                try:
+                    revival = kls.auto_revive_if_needed(
+                        dead_rate_threshold=AUTO_REVIVE_DEAD_RATE_THRESHOLD,
+                        min_steps_between_revivals=AUTO_REVIVE_COOLDOWN_STEPS,
+                    )
+                    if revival.get("action") == "auto_revived":
+                        logger.info(
+                            f"[V6.5-V2-metrics-FIX-4] AUTO-REVIVE triggered: "
+                            f"n_revived={revival['n_revived']}/{revival['n_total']}, "
+                            f"dead_rate {revival['dead_rate_before']:.3f} → "
+                            f"{revival['dead_rate_after']:.3f}, "
+                            f"steps_since_last={revival['steps_since_last_revival']}"
+                        )
+                except Exception as revive_err:
+                    logger.warning(
+                        f"[V6.5-V2-metrics-FIX-4] auto_revive_if_needed failed: {revive_err}"
+                    )
+
                 # Aggressive memory cleanup between chunks
                 if chunk_idx_global % 2 == 0:
                     aggressive_memory_cleanup()
@@ -1260,13 +1322,13 @@ def run_fase_conhecimento(
                     # V6.5-V2-metrics-FIX: pausa pós-processamento para dar tempo
                     # de conclusão (user requirement: "todo streaming deve ter
                     # pausa para dar tempo de conclusão de processamento").
-                    time.sleep(POST_PROCESSING_PAUSE_S)
+                    time.sleep(POST_PROCESSING_PAUSE_S_FASE1)
         except Exception as e:
             logger.error(f"[V6.5-V2] Dataset {dataset_name} failed: {e}")
             traceback.print_exc()
             streaming_failures[dataset_name] += 1
 
-        time.sleep(INTER_DATASET_PAUSE_S)
+        time.sleep(INTER_DATASET_PAUSE_S_FASE1)
         # V6.5-V2-metrics-FIX-2 — Save state after each dataset to preserve
         # progress in case the process is killed by container timeout.
         # User requirement: "o estado do modelo deve ser contínuo" — saving
@@ -1347,6 +1409,266 @@ def run_fase_conhecimento(
     }
 
 
+# ============================================================================
+# 9.5 — V6.5-V2-metrics-FIX-4: Sumário final da FASE2
+# ============================================================================
+def build_fase2_final_summary(
+    kls: KohonenLearningSystemV2,
+    som_metrics_log: List[Dict[str, Any]],
+    punishment_log: List[Dict[str, Any]],
+    hypotheses_log: List[Dict[str, Any]],
+    delta_applications_log: List[Dict[str, Any]],
+    elapsed_s: float,
+) -> Dict[str, Any]:
+    """V6.5-V2-metrics-FIX-4 — Constrói sumário final da FASE2 mostrando evolução.
+
+    User requirement: "ao final da FASE2 mostrar evolução de métricas e dos
+    indicadores e da taxa de aprendizagem".
+
+    Extrai trajetória temporal das métricas SOM (QE, TE, KL, VE), indicadores
+    de falha (dead_rate, collapse, stagnation, crossing), taxa de aprendizado
+    (α_t, σ_t) e estatísticas do conscience mechanism (neurons_active,
+    uniformity_score). Compara início vs fim para mostrar evolução.
+
+    Returns:
+        Dict com:
+          - summary_lines: List[str] — linhas formatadas para logger.info
+          - metrics_evolution: Dict com first/last/delta de cada métrica
+          - learning_rate_evolution: Dict com α_t, σ_t no início e fim
+          - indicators_evolution: Dict com indicadores de falha no início e fim
+          - neuron_activation_evolution: Dict com neurons_active no início e fim
+          - punishment_stats: Dict com estatísticas de punição
+    """
+    summary_lines: List[str] = []
+
+    # 1. Trajetória das métricas principais (QE, TE, KL, VE)
+    def _safe_get(log_list, key, idx):
+        if not log_list or idx >= len(log_list):
+            return 0.0
+        try:
+            return float(log_list[idx].get(key, 0.0))
+        except (TypeError, ValueError):
+            return 0.0
+
+    n_logs = len(som_metrics_log)
+    first_idx = 0
+    last_idx = max(0, n_logs - 1)
+
+    metrics_first = {
+        "QE": _safe_get(som_metrics_log, "quantization_error", first_idx),
+        "TE": _safe_get(som_metrics_log, "topological_error", first_idx),
+        "KL": _safe_get(som_metrics_log, "kaski_lagus_error", first_idx),
+        "VE": _safe_get(som_metrics_log, "explained_variance_share", first_idx),
+    }
+    metrics_last = {
+        "QE": _safe_get(som_metrics_log, "quantization_error", last_idx),
+        "TE": _safe_get(som_metrics_log, "topological_error", last_idx),
+        "KL": _safe_get(som_metrics_log, "kaski_lagus_error", last_idx),
+        "VE": _safe_get(som_metrics_log, "explained_variance_share", last_idx),
+    }
+    metrics_delta = {
+        k: metrics_last[k] - metrics_first[k] for k in metrics_first
+    }
+
+    # 2. Indicadores de falha
+    first_failures = som_metrics_log[first_idx].get("failure_indicators", []) if som_metrics_log else []
+    last_failures = som_metrics_log[last_idx].get("failure_indicators", []) if som_metrics_log else []
+    first_health = som_metrics_log[first_idx].get("overall_health", "unknown") if som_metrics_log else "unknown"
+    last_health = som_metrics_log[last_idx].get("overall_health", "unknown") if som_metrics_log else "unknown"
+
+    # 3. Ativação de neurônios (conscience mechanism)
+    first_neurons_active = _safe_get(som_metrics_log, "n_active_neurons_bmu", first_idx)
+    last_neurons_active = _safe_get(som_metrics_log, "n_active_neurons_bmu", last_idx)
+    first_neurons_total = _safe_get(som_metrics_log, "n_total_neurons_bmu", first_idx) or 864
+    last_neurons_total = _safe_get(som_metrics_log, "n_total_neurons_bmu", last_idx) or 864
+
+    # 4. Relatório paralelo final do SOM (conscience + uniformity)
+    try:
+        parallel_report = kls.parallel_neuron_activation_report()
+    except Exception:
+        parallel_report = {}
+
+    # 5. Taxa de aprendizado (α_t, σ_t) do SOM
+    try:
+        som_metrics = kls.som.get_metrics()
+        alpha_t = som_metrics.get("alpha_t_effective", 0.0)
+        sigma_t = som_metrics.get("sigma_t_effective", 0.0)
+        alpha0 = som_metrics.get("alpha0", 0.5)
+        sigma0 = som_metrics.get("sigma0", 3.0)
+        som_t = som_metrics.get("t", 0)
+    except Exception:
+        alpha_t = sigma_t = alpha0 = sigma0 = som_t = 0.0
+
+    # 6. Estatísticas de punição
+    n_punishments = len(punishment_log)
+    n_train_hyp_calls = len(hypotheses_log)
+    n_delta_apps = len(delta_applications_log)
+    # Taxa de sucesso das aplicações de delta (acc_after > acc_before)
+    delta_success = 0
+    if delta_applications_log:
+        for d in delta_applications_log:
+            try:
+                if float(d.get("acc_after", 0.0)) > float(d.get("acc_before", 0.0)):
+                    delta_success += 1
+            except (TypeError, ValueError):
+                pass
+    delta_success_rate = float(delta_success / max(1, n_delta_apps))
+
+    # 7. Hipóteses — evolução da loss
+    if hypotheses_log:
+        loss_first = float(hypotheses_log[0].get("loss_initial", 0.0))
+        loss_last_init = float(hypotheses_log[-1].get("loss_initial", 0.0))
+        loss_last_final = float(hypotheses_log[-1].get("loss_final", 0.0))
+    else:
+        loss_first = loss_last_init = loss_last_final = 0.0
+
+    # ===================== MONTAGEM DAS LINHAS DE SUMÁRIO =====================
+    summary_lines.append(f"  Duração total: {elapsed_s:.1f}s")
+    summary_lines.append(f"  Logs de métricas computados: {n_logs}")
+    summary_lines.append("")
+    summary_lines.append("  ─── EVOLUÇÃO DAS MÉTRICAS PRINCIPAIS (início → fim) ───")
+    summary_lines.append(
+        f"  QE  (Quantization Error): {metrics_first['QE']:.4f} → "
+        f"{metrics_last['QE']:.4f}  (Δ={metrics_delta['QE']:+.4f})"
+    )
+    summary_lines.append(
+        f"  TE  (Topological Error) : {metrics_first['TE']:.4f} → "
+        f"{metrics_last['TE']:.4f}  (Δ={metrics_delta['TE']:+.4f})"
+    )
+    summary_lines.append(
+        f"  KL  (Kaski-Lagus)       : {metrics_first['KL']:.4f} → "
+        f"{metrics_last['KL']:.4f}  (Δ={metrics_delta['KL']:+.4f})"
+    )
+    summary_lines.append(
+        f"  VE  (Explained Variance): {metrics_first['VE']:.4f} → "
+        f"{metrics_last['VE']:.4f}  (Δ={metrics_delta['VE']:+.4f})"
+    )
+    summary_lines.append("")
+    summary_lines.append("  ─── INDICADORES DE FALHA ───")
+    summary_lines.append(
+        f"  Overall health: {first_health} → {last_health}"
+    )
+    summary_lines.append(
+        f"  Failure indicators (início): {len(first_failures)} — {first_failures[:3]}"
+    )
+    summary_lines.append(
+        f"  Failure indicators (fim)   : {len(last_failures)} — {last_failures[:3]}"
+    )
+    summary_lines.append("")
+    summary_lines.append("  ─── ATIVAÇÃO DE NEURÔNIOS (Conscience Mechanism) ───")
+    summary_lines.append(
+        f"  Neurons ativos (BMU): {int(first_neurons_active)}/{int(first_neurons_total)} "
+        f"→ {int(last_neurons_active)}/{int(last_neurons_total)}"
+    )
+    if parallel_report:
+        summary_lines.append(
+            f"  Uniformity score (fim): {parallel_report.get('uniformity_score', 0.0):.4f} "
+            f"(1.0 = perfeitamente uniforme)"
+        )
+        summary_lines.append(
+            f"  Conscience bias mean/std: "
+            f"{parallel_report.get('conscience_bias_mean', 0.0):.6f} / "
+            f"{parallel_report.get('conscience_bias_std', 0.0):.6f} "
+            f"(deve tender a 0)"
+        )
+        summary_lines.append(
+            f"  Win count max/mean: "
+            f"{parallel_report.get('max_win_count', 0.0):.0f} / "
+            f"{parallel_report.get('mean_win_count', 0.0):.2f}"
+        )
+    summary_lines.append("")
+    summary_lines.append("  ─── TAXA DE APRENDIZADO (Kohonen schedule) ───")
+    summary_lines.append(
+        f"  α_t (learning rate): α₀={alpha0:.4f} → α_t={alpha_t:.6f} "
+        f"(floor=0.001, decai em exp(-t/2000))"
+    )
+    summary_lines.append(
+        f"  σ_t (neighborhood) : σ₀={sigma0:.4f} → σ_t={sigma_t:.6f} "
+        f"(floor=0.1, decai em exp(-t/1000))"
+    )
+    summary_lines.append(f"  SOM t (updates)    : {som_t}")
+    summary_lines.append("")
+    summary_lines.append("  ─── ESTATÍSTICAS DE PUNIÇÃO ───")
+    summary_lines.append(f"  Total punishment events: {n_punishments}")
+    summary_lines.append(f"  Hypotheses trainings  : {n_train_hyp_calls}")
+    summary_lines.append(f"  Delta applications    : {n_delta_apps}")
+    summary_lines.append(
+        f"  Delta success rate    : {delta_success_rate:.2%} "
+        f"({delta_success}/{n_delta_apps} melhoraram acurácia)"
+    )
+    if hypotheses_log:
+        summary_lines.append(
+            f"  Loss inicial primeira chamada: {loss_first:.6f}"
+        )
+        summary_lines.append(
+            f"  Loss inicial última chamada : {loss_last_init:.6f} "
+            f"→ final: {loss_last_final:.6f}"
+        )
+    summary_lines.append("")
+    summary_lines.append("  ─── HIPÓTESES (configuração final) ───")
+    try:
+        v2_metrics = kls.get_v2_metrics()
+        summary_lines.append(
+            f"  n_hypotheses ativas: {v2_metrics.get('n_hypotheses', 0)} / "
+            f"max {v2_metrics.get('max_n_hypotheses', 0)}"
+        )
+        summary_lines.append(
+            f"  hyp_train_steps atual: {v2_metrics.get('hyp_train_steps', 0)}"
+        )
+        summary_lines.append(
+            f"  total_hyp_steps_executed: "
+            f"{v2_metrics.get('total_hyp_steps_executed', 0)}"
+        )
+        summary_lines.append(
+            f"  n_adaptations dinâmicas: "
+            f"{v2_metrics.get('dynamic_adaptation', {}).get('n_adaptations', 0)}"
+        )
+        summary_lines.append(
+            f"  EWC reference set: {v2_metrics.get('ewc_reference_set', False)}"
+        )
+    except Exception:
+        pass
+
+    return {
+        "summary_lines": summary_lines,
+        "metrics_evolution": {
+            "first": metrics_first,
+            "last": metrics_last,
+            "delta": metrics_delta,
+        },
+        "learning_rate_evolution": {
+            "alpha0": alpha0,
+            "alpha_t_final": alpha_t,
+            "sigma0": sigma0,
+            "sigma_t_final": sigma_t,
+            "som_t": som_t,
+        },
+        "indicators_evolution": {
+            "first_health": first_health,
+            "last_health": last_health,
+            "first_failures": first_failures,
+            "last_failures": last_failures,
+            "first_n_failures": len(first_failures),
+            "last_n_failures": len(last_failures),
+        },
+        "neuron_activation_evolution": {
+            "first_active": int(first_neurons_active),
+            "last_active": int(last_neurons_active),
+            "total": int(last_neurons_total),
+            "parallel_report_final": parallel_report,
+        },
+        "punishment_stats": {
+            "n_punishments": n_punishments,
+            "n_train_hyp_calls": n_train_hyp_calls,
+            "n_delta_apps": n_delta_apps,
+            "delta_success_rate": delta_success_rate,
+            "loss_first_initial": loss_first,
+            "loss_last_initial": loss_last_init,
+            "loss_last_final": loss_last_final,
+        },
+    }
+
+
 # ============================================================================
 # 10. PHASE 2 — TREINAMENTO COM PUNIÇÃO (16 hipóteses × 3 tentativas)
 # ============================================================================
@@ -1613,13 +1935,35 @@ def run_fase_punicão(
                         traceback.print_exc()
 
                     step += 1
-                    time.sleep(INTER_BATCH_PAUSE_S)
+                    # V6.5-V2-metrics-FIX-4 — pausa maior na FASE2 (PUNITIVA)
+                    # User requirement: "FASE2 PUNIÇÃO é mais pesada é pode exigir
+                    # pausas do streaming até concluir o processamento".
+                    time.sleep(INTER_BATCH_PAUSE_S_FASE2)
                 except Exception as e:
                     logger.error(f"[V6.5-V2] Batch error in PUNIÇÃO: {e}")
                     traceback.print_exc()
                     continue
 
-            time.sleep(INTER_STREAM_BATCH_PAUSE_S)
+            # V6.5-V2-metrics-FIX-4 — Auto-revive neurônios mortos na FASE2
+            # (PUNITIVA também deve distribuir processamento paralelamente)
+            try:
+                revival = kls.auto_revive_if_needed(
+                    dead_rate_threshold=AUTO_REVIVE_DEAD_RATE_THRESHOLD,
+                    min_steps_between_revivals=AUTO_REVIVE_COOLDOWN_STEPS,
+                )
+                if revival.get("action") == "auto_revived":
+                    logger.info(
+                        f"[V6.5-V2-metrics-FIX-4] PUNIÇÃO AUTO-REVIVE: "
+                        f"n_revived={revival['n_revived']}/{revival['n_total']}, "
+                        f"dead_rate {revival['dead_rate_before']:.3f} → "
+                        f"{revival['dead_rate_after']:.3f}"
+                    )
+            except Exception as revive_err:
+                logger.warning(
+                    f"[V6.5-V2-metrics-FIX-4] PUNIÇÃO auto_revive failed: {revive_err}"
+                )
+
+            time.sleep(INTER_STREAM_BATCH_PAUSE_S_FASE2)
             # V2-dynamic-memory — Buffer sliding window na PUNIÇÃO também
             if len(kls.buffer_4d) > MAX_BUFFER_SIZE:
                 overflow = len(kls.buffer_4d) - MAX_BUFFER_SIZE
@@ -1636,8 +1980,9 @@ def run_fase_punicão(
                     kls.aggressive_cleanup()
                 except Exception:
                     pass
-                # V6.5-V2-metrics-FIX: pausa pós-processamento (user requirement)
-                time.sleep(POST_PROCESSING_PAUSE_S)
+                # V6.5-V2-metrics-FIX-4: pausa pós-processamento maior na FASE2
+                # (user requirement: "FASE2 PUNIÇÃO é mais pesada")
+                time.sleep(POST_PROCESSING_PAUSE_S_FASE2)
     except Exception as e:
         logger.error(f"[V6.5-V2] PUNIÇÃO dataset failed: {e}")
         traceback.print_exc()
@@ -1652,6 +1997,24 @@ def run_fase_punicão(
     logger.info(f"  Hypotheses trainings: {len(hypotheses_log)}")
     logger.info(f"  Delta applications: {len(delta_applications_log)}")
 
+    # V6.5-V2-metrics-FIX-4 — Sumário final da FASE2
+    # User requirement: "ao final da FASE2 mostrar evolução de métricas e dos
+    # indicadores e da taxa de aprendizagem".
+    fase2_summary = build_fase2_final_summary(
+        kls=kls,
+        som_metrics_log=som_metrics_log,
+        punishment_log=punishment_log,
+        hypotheses_log=hypotheses_log,
+        delta_applications_log=delta_applications_log,
+        elapsed_s=t_elapsed,
+    )
+    logger.info("\n" + "=" * 80)
+    logger.info("[V6.5-V2-metrics-FIX-4] FASE 2 — EVOLUÇÃO FINAL DE MÉTRICAS")
+    logger.info("=" * 80)
+    for line in fase2_summary["summary_lines"]:
+        logger.info(line)
+    logger.info("=" * 80 + "\n")
+
     return {
         "phase": "TREINAMENTO_COM_PUNICAO",
         "dataset": PUNICAO_DATASET,
@@ -1673,6 +2036,8 @@ def run_fase_punicão(
         ),
         "som_metric_history": kls.get_som_metric_history(),
         "final_v2_state": kls.get_v2_metrics(),
+        # V6.5-V2-metrics-FIX-4 — sumário final da FASE2
+        "fase2_summary": fase2_summary,
     }
 
 
@@ -2115,7 +2480,17 @@ def main() -> int:
         # + Goose VQ, fornecendo representação compacta do estado do SOM.
         # O compressor já sanitiza NaN/Inf internamente (torch.nan_to_num).
         enable_vqvae2=True,   # REATIVADO (was False in V6.5-V2-metrics-FIX)
-        enable_reasoning=True,
+        # V6.5-V2-metrics-FIX-4: reasoning_engine desabilitado para mitigar
+        # OOM-killer (User requirement implícito: "investigar e corrigir
+        # falhas de lógica e bugs que estejam causando alto consumo de memória
+        # sem distorcer a arquitetura Kohonen"). O ReasoningEngine cria um
+        # ThreadPoolExecutor(4 workers) + ToolAgentCoordinator que consome
+        # ~100-200MB adicionais. Como o reasoning_engine é OPCIONAL e não
+        # afeta o aprendizado do SOM (apenas gera tags <think>/<plan>/<answer>
+        # para predições), desabilitá-lo preserva a arquitetura Kohonen e
+        # libera memória para o streaming de 8000+2000 samples.
+        # Para reativar: mudar para True (requer ≥6GB cgroup).
+        enable_reasoning=False,
         enable_w8a8=False,    # W8A8 permanece desabilitado (não essencial para Kohonen)
         vqvae2_code_dim=16,
         vqvae2_num_codes_top=64,
@@ -2384,23 +2759,29 @@ def main() -> int:
             SRC_ROOT / "bigru_t" / "data" / "streaming_datasets.py",
             SRC_ROOT / "bigru_t" / "utils" / "xeon_runtime.py",
         ]
-        # Relatórios + estados
+        # V6.5-V2-metrics-FIX-3: FILTRA arquivos .pt do upload HF.
+        # User requirement: "ao concluir enviar para o HF os arquivos e módulos
+        # e scripts em lote" + auditoria encontrou que .pt files estavam sendo
+        # uploaded (MODEL_STATES_PATH e *_after_conhecimento.pt). Estados do
+        # modelo (>40MB cada) não devem ir ao HF — apenas scripts e relatórios.
         outputs_to_upload: List[Path] = [
             REPORT_PATH,
-            MODEL_STATES_PATH,
             V2_PHASES_EVAL_PATH,
             PREDICT_FIX_EVAL_PATH,
             ATTENTION_EVAL_PATH,
             USER_QUESTIONS_PATH,
-            BIGRU_ROOT / "v6_5_v2_model_states_after_conhecimento.pt",
         ]
-        # Filtra os que existem
+        # Filtra os que existem E não são .pt/.pth/.bin/.safetensors
         all_files: List[Path] = []
+        _FORBIDDEN_UPLOAD_EXTS = {'.pt', '.pth', '.bin', '.safetensors', '.ckpt'}
         for p in scripts_to_upload + outputs_to_upload:
-            if p.exists():
-                all_files.append(p)
-            else:
+            if not p.exists():
                 logger.warning(f"[V6.5-V2] Upload file not found: {p}")
+                continue
+            if p.suffix.lower() in _FORBIDDEN_UPLOAD_EXTS:
+                logger.info(f"[V6.5-V2] Skipping model state from HF upload: {p.name}")
+                continue
+            all_files.append(p)
 
         # Apaga HF_TOKEN dos scripts ANTES do upload (não enviar tokens)
         scrub_result = scrub_hf_token_from_scripts(BIGRU_ROOT / "scripts")

src/bigru_t/model/kohonen_learning_system.py

@@ -325,7 +325,23 @@ def text_to_4d_vector(
 
     # SVD para 3D
     mean_centered = fused - fused.mean(dim=0, keepdim=True)
-    U, S, V = torch.linalg.svd(mean_centered, full_matrices=False)
+    # V6.5-V2-metrics-FIX-3 — SVD com fallback robusto: se a matriz for
+    # rank-deficiente (ex: todos os tokens são <pad> → todas as linhas
+    # idênticas), torch.linalg.svd pode produzir NaN ou levantar RuntimeError.
+    # Fallback 1: driver 'gesvd' (mais estável para matrizes singulares).
+    # Fallback 2: zeros (vetor 4D neutro, não contamina o SOM).
+    try:
+        U, S, V = torch.linalg.svd(mean_centered, full_matrices=False)
+    except Exception:
+        try:
+            U, S, V = torch.linalg.svd(mean_centered, full_matrices=False, driver='gesvd')
+        except Exception:
+            S = torch.zeros(min(mean_centered.shape), device=mean_centered.device)
+            V = torch.eye(mean_centered.shape[1], device=mean_centered.device)
+    # V6.5-V2-metrics-FIX-3 — sanitiza NaN do SVD (rank-deficient → S pode ter NaN)
+    if torch.isnan(S).any() or torch.isinf(S).any():
+        S = torch.nan_to_num(S, nan=0.0, posinf=0.0, neginf=0.0)
+        V = torch.nan_to_num(V, nan=0.0, posinf=0.0, neginf=0.0)
     coords_3d = torch.mm(mean_centered, V[:3, :].t())  # (L, 3)
 
     xyz_mean = coords_3d.mean(dim=0)  # (3,)
@@ -356,13 +372,34 @@ class KohonenSOM4D:
     def __init__(
         self,
         grid_shape: Tuple[int, int, int, int],
-        alpha0: float = 0.1,
-        sigma0: float = 1.0,
+        alpha0: float = 0.5,
+        sigma0: float = 3.0,
         lambda_ewc: float = 0.01,
+        conscience_gamma: float = 0.1,
+        conscience_beta: float = 0.1,
     ):
+        # V6.5-V2-metrics-FIX-3 — α₀=0.5 e σ₀=3.0 conforme especificação
+        # canônica para SOM 4D (Kohonen classic):
+        #   - α₀ ∈ [0.5, 1.0] para fase de ordenação (rough training)
+        #   - σ₀ = metade da maior dimensão da grade = max(6,6,6,4)/2 = 3.0
+        # V6.5-V2-metrics-FIX-3 — floors explícitos no update_weights garantem
+        # que α_t e σ_t nunca decaiam abaixo de 0.001 e 0.1 respectivamente
+        # (sem isso, após ~7000 updates σ→0 e o SOM degenera em k-means puro,
+        # perdendo preservação topológica).
+        #
+        # V6.5-V2-metrics-FIX-4 (Conscience Mechanism — DeSieno 1988):
+        # Corrige o problema neurons_active=2/864 relatado pelo usuário.
+        # Cada neurônio i mantém uma frequência de vitória p_i ∈ [0,1].
+        # BMU selection: bmu = argmin_i ( ||W_i - x||² - b_i )
+        #   onde b_i = γ · (1/N - p_i)   é o bias de consciência
+        #   γ = 0.1 (default), N = total de neurônios (864)
+        # Update da frequência (EMA): p_i ← (1-β)·p_i + β·𝟙[i==bmu], β=0.1
+        # Quando um neurônio ganha demais (p_i > 1/N), b_i fica negativo
+        # (penaliza), e quando nunca ganha (p_i ≈ 0), b_i fica positivo
+        # (empurra para ganhar). Isto força distribuição uniforme de BMU.
         self.I, self.J, self.K, self.L = grid_shape
-        self.alpha0 = alpha0
-        self.sigma0 = sigma0
+        self.alpha0 = float(alpha0)
+        self.sigma0 = float(sigma0)
         self.lambda_ewc = lambda_ewc
         self.t = 0
 
@@ -372,6 +409,54 @@ class KohonenSOM4D:
         self.fisher_accum = torch.zeros(self.I, self.J, self.K, self.L)
         self.fisher_count = torch.zeros(self.I, self.J, self.K, self.L)
 
+        # V6.5-V2-metrics-FIX-4 — Conscience mechanism (DeSieno 1988)
+        # Inicializa p_i = 1/N (uniforme) — sem viés inicial.
+        # b_i = γ · (1/N - p_i) começa em 0 (sem bias).
+        self.n_neurons = self.I * self.J * self.K * self.L
+        self.conscience_gamma = float(conscience_gamma)
+        self.conscience_beta = float(conscience_beta)
+        target_p = 1.0 / self.n_neurons
+        self.win_frequency = torch.full(
+            (self.I, self.J, self.K, self.L), target_p, dtype=torch.float
+        )
+        # Contador absoluto de vitórias por neurônio (para auditoria)
+        self.bmu_win_count = torch.zeros(
+            self.I, self.J, self.K, self.L, dtype=torch.long
+        )
+        # Histórico dos últimos K BMUs (para revive_dead_neurons)
+        self._recent_bmu_flat: List[int] = []
+
+        # ------------------------------------------------------------------
+        # V6.5-V2-auto-conscience — Estado para ajuste adaptativo de γ.
+        # User requirement: "aprimorar conscience_gamma para ajuste
+        # automático conforme a quantidade de neurônios esteja caindo".
+        #
+        # Math (DeSieno 1988 + adaptação adaptativa):
+        #   r        = n_active / n_total                 (∈ [0,1])
+        #   γ_base   = γ_max · (1 - r)^2                  (intervenção cresce
+        #                                                  com colapso)
+        #   drop     = max(0, r_prev - r)                 (tendência de queda)
+        #   γ_boost  = 0.3 · drop                          (reforço antecipado)
+        #   γ_target = clip(γ_base + γ_boost, γ_min, γ_max)
+        #   γ_new    = (1 - η) · γ_old + η · γ_target     (EMA suave)
+        #
+        # Comportamento esperado:
+        #   r = 1.0  → γ_base = 0.00 (data distribution domina)
+        #   r = 0.5  → γ_base = 0.25 (intervenção moderada)
+        #   r = 0.1  → γ_base = 0.81 (intervenção forte)
+        #   r = 0.0  → γ_base = 1.00 (intervenção máxima)
+        #   r caindo 1.0→0.5 → +0.15 boost (antecipa colapso)
+        # ------------------------------------------------------------------
+        self._conscience_gamma_min = 0.01
+        self._conscience_gamma_max = 1.0
+        self._conscience_eta = 0.05                 # EMA smoothing
+        self._prev_n_active = -1
+        self._prev_n_active_rate = -1.0
+        self._last_gamma_target = float(conscience_gamma)
+        self._last_gamma_drop = 0.0
+        self._last_activation_rate = 1.0
+        self._auto_adjust_interval = 50             # ajusta γ a cada 50 updates
+
     def _neighborhood(self, bmu_idx):
         """Vizinhança Gaussiana 4D: d² = Δi² + Δj² + Δk² + Δl²."""
         i, j, k, l = bmu_idx
@@ -385,13 +470,39 @@ class KohonenSOM4D:
         dist_sq = (II - i) ** 2 + (JJ - j) ** 2 + (KK - k) ** 2 + (LL - l) ** 2
         return dist_sq
 
-    def find_bmu(self, x: torch.Tensor) -> Tuple[int, int, int, int]:
-        """Best Matching Unit: argmin ||W - x||² em ℝ⁴.
+    def find_bmu(self, x: torch.Tensor, use_conscience: bool = True) -> Tuple[int, int, int, int]:
+        """Best Matching Unit: argmin ||W - x||² em ℝ⁴, com conscience bias opcional.
 
         Substitui pgvector_lookup — busca nearest-neighbor flat sobre o grid.
+
+        V6.5-V2-metrics-FIX-4 (Conscience Mechanism — DeSieno 1988):
+        Quando use_conscience=True, adiciona bias b_i = γ·(1/N - p_i) à
+        distância, forçando distribuição uniforme de BMU entre os 864
+        neurônios. Isto corrige o problema neurons_active=2/864:
+
+            bmu = argmin_i ( ||W_i - x||² - b_i )
+
+        Sem conscience, neurônios próximos a poucas amostras ficam mortos.
+        Com conscience, neurônios que ganham demais (p_i > 1/N) são
+        penalizados (b_i < 0 aumenta distância efetiva), e neurônios que
+        nunca ganham (p_i ≈ 0) são favorecidos (b_i > 0 reduz distância).
+
+        Args:
+            x: tensor [4] — vetor de entrada.
+            use_conscience: se True, aplica bias de consciência (default True).
         """
+        # Sanitiza x antes de computar distância
+        if torch.isnan(x).any() or torch.isinf(x).any():
+            x = torch.nan_to_num(x, nan=0.0, posinf=1e4, neginf=-1e4)
         dist = torch.sum((self.weights - x.view(1, 1, 1, 1, 4)) ** 2, dim=-1)
-        flat_idx = torch.argmin(dist).item()
+        if use_conscience:
+            # b_i = γ · (1/N - p_i)  →  subtraído da distância (menor distância efetiva vence)
+            target_p = 1.0 / self.n_neurons
+            bias = self.conscience_gamma * (target_p - self.win_frequency)
+            dist_effective = dist - bias
+            flat_idx = int(torch.argmin(dist_effective).item())
+        else:
+            flat_idx = int(torch.argmin(dist).item())
         i = flat_idx // (self.J * self.K * self.L)
         rest = flat_idx % (self.J * self.K * self.L)
         j = rest // (self.K * self.L)
@@ -400,17 +511,349 @@ class KohonenSOM4D:
         l = rest % self.L
         return (i, j, k, l)
 
+    def update_win_frequency(self, bmu_idx: Tuple[int, int, int, int]) -> None:
+        """V6.5-V2-metrics-FIX-4 — Atualiza frequência de vitória (EMA).
+
+        p_i ← (1-β)·p_i + β·𝟙[i==bmu],   β = conscience_beta (default 0.1)
+
+        Também mantém contador absoluto bmu_win_count para auditoria.
+        Deve ser chamado APÓS find_bmu e APÓS update_weights.
+
+        Args:
+            bmu_idx: (i, j, k, l) — índice do BMU selecionado.
+        """
+        with torch.no_grad():
+            # EMA update
+            self.win_frequency = (
+                (1.0 - self.conscience_beta) * self.win_frequency
+            )
+            self.win_frequency[bmu_idx] += self.conscience_beta
+            # Contador absoluto
+            self.bmu_win_count[bmu_idx] += 1
+            # Histórico recente (para revive_dead_neurons)
+            flat = (
+                bmu_idx[0] * (self.J * self.K * self.L)
+                + bmu_idx[1] * (self.K * self.L)
+                + bmu_idx[2] * self.L
+                + bmu_idx[3]
+            )
+            self._recent_bmu_flat.append(flat)
+            # Mantém últimos 200 BMUs
+            if len(self._recent_bmu_flat) > 200:
+                self._recent_bmu_flat = self._recent_bmu_flat[-200:]
+
+    def revive_dead_neurons(
+        self,
+        data_buffer: Optional[List[torch.Tensor]] = None,
+        dead_threshold: int = 0,
+    ) -> Dict[str, Any]:
+        """V6.5-V2-metrics-FIX-4 — Revive neurônios mortos reinicializando pesos.
+
+        User requirement: "ANALISAR matematicamente e logicamente a ativação e
+        uso e acesso dos neurônios (apenas dois estão sendo ativados:
+        neurons_active=2/864) distribuindo o processamento paralelamente".
+
+        Um neurônio é considerado "morto" se bmu_win_count <= dead_threshold
+        (nunca ou raramente foi BMU). Para cada neurônio morto:
+
+        1. Se data_buffer fornecido: amostra um vetor aleatório do buffer e
+           atribui aos pesos do neurônio (reinicialização data-driven).
+        2. Se buffer vazio: reinicializa com ruído gaussiano pequeno (N(0, 0.1)).
+        3. Reseta win_frequency para 1/N (sem bias) e bmu_win_count para 0.
+
+        Isto garante que TODOS os 864 neurônios sejam utilizados, distribuindo
+        o processamento paralelo do SOM conforme solicitado.
+
+        Args:
+            data_buffer: lista de tensores [4] — amostras do buffer_4d do KLS.
+            dead_threshold: neurônios com win_count <= threshold são revividos.
+
+        Returns:
+            Dict com: n_revived, n_total, revived_indices, dead_rate_before, dead_rate_after.
+        """
+        with torch.no_grad():
+            dead_mask = self.bmu_win_count <= dead_threshold
+            n_dead = int(dead_mask.sum().item())
+            n_total = self.n_neurons
+            dead_rate_before = float(n_dead / n_total)
+
+            revived_indices: List[Tuple[int, int, int, int]] = []
+            if n_dead == 0:
+                return {
+                    "n_revived": 0,
+                    "n_total": n_total,
+                    "revived_indices": [],
+                    "dead_rate_before": dead_rate_before,
+                    "dead_rate_after": dead_rate_before,
+                    "action": "none",
+                }
+
+            # Amostra pontos do buffer se disponível
+            buffer_tensor = None
+            if data_buffer and len(data_buffer) > 0:
+                try:
+                    buffer_tensor = torch.stack(
+                        [v.detach().clone() if isinstance(v, torch.Tensor)
+                         else torch.tensor(v, dtype=torch.float)
+                         for v in data_buffer]
+                    ).float()
+                except Exception:
+                    buffer_tensor = None
+
+            # Itera sobre neurônios mortos e reinicializa
+            dead_indices = dead_mask.nonzero(as_tuple=False)
+            for idx_tensor in dead_indices:
+                i, j, k, l = idx_tensor.tolist()
+                if buffer_tensor is not None and buffer_tensor.shape[0] > 0:
+                    # Amostra aleatória do buffer
+                    sample_idx = torch.randint(0, buffer_tensor.shape[0], (1,)).item()
+                    new_w = buffer_tensor[sample_idx].clone()
+                    # Pequeno ruído para evitar duplicação exata
+                    new_w = new_w + 0.05 * torch.randn(4)
+                else:
+                    # Reinicialização gaussiana pequena
+                    new_w = 0.1 * torch.randn(4)
+                # Clamp para segurança
+                new_w = torch.clamp(new_w, -10.0, 10.0)
+                self.weights[i, j, k, l] = new_w
+                # Reset counters
+                self.win_frequency[i, j, k, l] = 1.0 / n_total
+                self.bmu_win_count[i, j, k, l] = 0
+                revived_indices.append((i, j, k, l))
+
+            # Recalcula dead rate após revival
+            new_dead_mask = self.bmu_win_count <= dead_threshold
+            n_dead_after = int(new_dead_mask.sum().item())
+            dead_rate_after = float(n_dead_after / n_total)
+
+            return {
+                "n_revived": len(revived_indices),
+                "n_total": n_total,
+                "revived_indices": revived_indices[:50],  # top 50 para log
+                "n_dead_before": n_dead,
+                "n_dead_after": n_dead_after,
+                "dead_rate_before": dead_rate_before,
+                "dead_rate_after": dead_rate_after,
+                "action": "revived" if revived_indices else "none",
+                "used_buffer": buffer_tensor is not None,
+            }
+
+    def parallel_neuron_activation_report(self) -> Dict[str, Any]:
+        """V6.5-V2-metrics-FIX-4 — Relatório estruturado de ativação dos 864 neurônios.
+
+        User requirement: "distribuindo o processamento paralelamente" + o
+        exemplo de código fornecido mostra estruturação vetorizada para
+        análise estatística e auditoria do modelo.
+
+        Este método produz um relatório análogo ao DataFrame do exemplo,
+        mas otimizado para o grid 4D (6,6,6,4) com 864 neurônios:
+
+        Returns:
+            Dict com:
+              - n_total_neurons: int (864)
+              - n_active_neurons: int (vitória em ≥1 amostra histórica)
+              - n_dead_neurons: int (nunca foi BMU)
+              - neuron_activation_rate: float
+              - max_win_count: int (neurônio mais ativo)
+              - min_win_count: int (neurônio menos ativo)
+              - mean_win_count: float
+              - std_win_count: float
+              - max_win_frequency: float
+              - min_win_frequency: float
+              - bmu_distribution_top20: dict {flat_idx: count}
+              - bmu_distribution_bottom20: dict {flat_idx: count} (mortos)
+              - conscience_bias_mean: float (deve tender a 0 se uniforme)
+              - conscience_bias_std: float (deve tender a 0 se uniforme)
+              - uniformity_score: float (1 - CV da win_frequency, ∈ [0,1])
+        """
+        with torch.no_grad():
+            win_counts_flat = self.bmu_win_count.flatten().float()
+            win_freq_flat = self.win_frequency.flatten()
+
+            n_total = self.n_neurons
+            n_active = int((self.bmu_win_count > 0).sum().item())
+            n_dead = n_total - n_active
+
+            # Estatísticas
+            if n_total > 0:
+                max_wc = float(win_counts_flat.max().item())
+                min_wc = float(win_counts_flat.min().item())
+                mean_wc = float(win_counts_flat.mean().item())
+                std_wc = float(win_counts_flat.std().item())
+                max_wf = float(win_freq_flat.max().item())
+                min_wf = float(win_freq_flat.min().item())
+                # Uniformidade: 1 - CV (coeficiente de variação)
+                cv = float(std_wc / max(mean_wc, 1e-8))
+                uniformity = max(0.0, 1.0 - cv)
+            else:
+                max_wc = min_wc = mean_wc = std_wc = 0.0
+                max_wf = min_wf = 0.0
+                uniformity = 0.0
+
+            # Bias de consciência: b_i = γ · (1/N - p_i)
+            target_p = 1.0 / n_total
+            bias_flat = self.conscience_gamma * (target_p - win_freq_flat)
+            bias_mean = float(bias_flat.mean().item())
+            bias_std = float(bias_flat.std().item())
+
+            # Top-20 BMUs mais frequentes
+            from collections import Counter
+            recent_counter = Counter(self._recent_bmu_flat)
+            top20 = dict(recent_counter.most_common(20))
+
+            # Bottom-20 (mortos ou raros) — últimos em vitórias absolutas
+            sorted_indices = torch.argsort(win_counts_flat)
+            bottom20_idx = sorted_indices[:20].tolist()
+            bottom20 = {
+                int(idx): int(self.bmu_win_count.flatten()[idx].item())
+                for idx in bottom20_idx
+            }
+
+            return {
+                "n_total_neurons": int(n_total),
+                "n_active_neurons": int(n_active),
+                "n_dead_neurons": int(n_dead),
+                "neuron_activation_rate": float(n_active / max(1, n_total)),
+                "max_win_count": max_wc,
+                "min_win_count": min_wc,
+                "mean_win_count": mean_wc,
+                "std_win_count": std_wc,
+                "max_win_frequency": max_wf,
+                "min_win_frequency": min_wf,
+                "bmu_distribution_top20": {str(k): int(v) for k, v in top20.items()},
+                "bmu_distribution_bottom20": {str(k): int(v) for k, v in bottom20.items()},
+                "conscience_bias_mean": bias_mean,
+                "conscience_bias_std": bias_std,
+                "uniformity_score": uniformity,
+                "conscience_gamma": float(self.conscience_gamma),
+                "conscience_beta": float(self.conscience_beta),
+                # V6.5-V2-auto-conscience — telemetria do ajuste adaptativo
+                "conscience_gamma_min": float(self._conscience_gamma_min),
+                "conscience_gamma_max": float(self._conscience_gamma_max),
+                "conscience_gamma_target": float(self._last_gamma_target),
+                "conscience_gamma_drop": float(self._last_gamma_drop),
+                "activation_rate_at_last_adjust": float(self._last_activation_rate),
+                "prev_n_active_at_last_adjust": int(self._prev_n_active),
+                "n_recent_bmus_tracked": int(len(self._recent_bmu_flat)),
+            }
+
+    def auto_adjust_conscience_gamma(self) -> Dict[str, Any]:
+        """V6.5-V2-auto-conscience — Ajusta γ dinamicamente conforme ativação.
+
+        User requirement: "aprimorar conscience_gamma para ajuste automático
+        conforme a quantidade de neurônios esteja caindo".
+
+        Quando a quantidade de neurônios ativos cai (colapso), o bias de
+        consciência precisa ficar mais forte para reviver neurônios mortos.
+        Quando a ativação está saudável (≈1.0), γ decai para deixar a
+        distribuição de dados comandar o SOM (preservação topológica natural).
+
+        Math (DeSieno 1988 + adaptação adaptativa):
+            r        = n_active / n_total                   (∈ [0,1])
+            γ_base   = γ_max · (1 - r)^2                    (intervenção
+                                                             cresce com
+                                                             colapso)
+            drop     = max(0, r_prev - r)                   (tendência de
+                                                             queda)
+            γ_boost  = 0.3 · drop                            (reforço
+                                                             antecipado)
+            γ_target = clip(γ_base + γ_boost, γ_min, γ_max)
+            γ_new    = (1 - η) · γ_old + η · γ_target       (EMA suave)
+
+        Comportamento esperado em diferentes cenários:
+            r = 1.0 (saudável)        → γ_base = 0.00 (data distribution domina)
+            r = 0.5 (degradação)      → γ_base = 0.25 (intervenção moderada)
+            r = 0.1 (colapso severo)  → γ_base = 0.81 (intervenção forte)
+            r = 0.0 (paralisia)       → γ_base = 1.00 (intervenção máxima)
+            r caindo 1.0→0.5          → +0.15 boost (antecipa colapso)
+            r subindo 0.5→1.0         → drop=0, sem boost extra
+
+        Returns:
+            Dict com: n_active, n_total, activation_rate, prev_activation_rate,
+            drop, gamma_target, gamma_old, gamma_new, gamma_min, gamma_max, eta.
+        """
+        with torch.no_grad():
+            n_total = self.n_neurons
+            n_active = int((self.bmu_win_count > 0).sum().item())
+            r = float(n_active / max(1, n_total))
+
+            # Tendência: se _prev_n_active_rate < 0, ainda não houve ajuste
+            r_prev = (
+                self._prev_n_active_rate
+                if self._prev_n_active_rate >= 0
+                else r
+            )
+            drop = max(0.0, r_prev - r)
+
+            # γ alvo: intervenção quadrática no colapso + boost antecipado
+            gamma_base = self._conscience_gamma_max * (1.0 - r) ** 2
+            gamma_trend_boost = 0.3 * drop
+            gamma_target = max(
+                self._conscience_gamma_min,
+                min(
+                    self._conscience_gamma_max,
+                    gamma_base + gamma_trend_boost,
+                ),
+            )
+
+            # EMA suave para evitar oscilações bruscas
+            eta = self._conscience_eta
+            gamma_old = float(self.conscience_gamma)
+            gamma_new = (1.0 - eta) * gamma_old + eta * float(gamma_target)
+            gamma_new = float(max(
+                self._conscience_gamma_min,
+                min(self._conscience_gamma_max, gamma_new),
+            ))
+
+            # Persiste estado
+            self.conscience_gamma = gamma_new
+            self._prev_n_active = n_active
+            self._prev_n_active_rate = r
+            self._last_gamma_target = float(gamma_target)
+            self._last_gamma_drop = float(drop)
+            self._last_activation_rate = r
+
+            return {
+                "n_active": n_active,
+                "n_total": n_total,
+                "activation_rate": r,
+                "prev_activation_rate": r_prev,
+                "drop": drop,
+                "gamma_target": float(gamma_target),
+                "gamma_old": gamma_old,
+                "gamma_new": gamma_new,
+                "gamma_min": float(self._conscience_gamma_min),
+                "gamma_max": float(self._conscience_gamma_max),
+                "eta": float(eta),
+            }
+
     def update_weights(self, x: torch.Tensor, bmu_idx, accumulate_fisher=False):
         """Update Kohonen: ΔW = α·Λ·(x - W) + penalidade EWC em w.
 
+        V6.5-V2-metrics-FIX-4 — agora chama update_win_frequency automaticamente
+        após o update, garantindo que o conscience mechanism seja atualizado
+        a cada amostra processada (sem necessidade de chamada externa).
+
+        V6.5-V2-metrics-FIX-3 — Correções matemáticas:
+          1. Floors explícitos em α_t e σ_t (previnem colapso topológico
+             após muitas épocas, quando σ_t→0 degenera o SOM em k-means).
+          2. Sanitização de NaN/Inf em x ANTES do update (uma única amostra
+             NaN não deve contaminar permanentemente os pesos).
+          3. Clamp dos pesos após update (evita explosão numérica).
+
         Args:
             x: tensor [4] — amostra 4D.
             bmu_idx: (i, j, k, l) — índice do BMU.
             accumulate_fisher: se True, acumula (x_w - W_w)² nos Fisher accumulators.
         """
+        # V6.5-V2-metrics-FIX-3 — sanitiza x: substitui NaN/Inf por 0
+        # (uma amostra degenerada não deve contaminar todo o SOM).
+        if torch.isnan(x).any() or torch.isinf(x).any():
+            x = torch.nan_to_num(x, nan=0.0, posinf=1e4, neginf=-1e4)
         dist_sq = self._neighborhood(bmu_idx)
-        sigma = self.sigma0 * math.exp(-self.t / 1000)
-        alpha = self.alpha0 * math.exp(-self.t / 2000)
+        # V6.5-V2-metrics-FIX-3 — floors explícitos (previnem σ_t→0)
+        sigma = max(self.sigma0 * math.exp(-self.t / 1000), 0.1)
+        alpha = max(self.alpha0 * math.exp(-self.t / 2000), 0.001)
         h = torch.exp(-dist_sq / (2 * sigma ** 2))
 
         delta = x - self.weights
@@ -425,6 +868,13 @@ class KohonenSOM4D:
             update[..., 3] = update[..., 3] - ewc_penalty
 
         self.weights = self.weights + update
+        # V6.5-V2-metrics-FIX-3 — clamp pós-update para evitar explosão
+        # (pesos Kohonen são tipicamente O(1); permitir valores > 100 indica
+        # divergência e propaga NaN para todas as métricas subsequentes).
+        self.weights = torch.clamp(self.weights, -100.0, 100.0)
+        # V6.5-V2-metrics-FIX-3 — se ainda assim surgir NaN, reverte este update
+        if torch.isnan(self.weights).any() or torch.isinf(self.weights).any():
+            self.weights = torch.nan_to_num(self.weights, nan=0.0, posinf=100.0, neginf=-100.0)
 
         if accumulate_fisher:
             # Acumula Fisher apenas em neurônios próximos ao BMU (Λ > 0.1)
@@ -436,6 +886,26 @@ class KohonenSOM4D:
 
         self.t += 1
 
+        # V6.5-V2-metrics-FIX-4 — atualiza conscience mechanism (win frequency)
+        # automaticamente após cada update. Isto garante que o bias de consciência
+        # seja aplicado corretamente no próximo find_bmu, forçando distribuição
+        # uniforme de BMU entre os 864 neurônios.
+        try:
+            self.update_win_frequency(bmu_idx)
+        except Exception:
+            # Não deixa falha no conscience quebrar o treino principal
+            pass
+
+        # V6.5-V2-auto-conscience — ajuste adaptativo de γ (throttled).
+        # Roda a cada _auto_adjust_interval updates (default 50) para
+        # evitar custo computacional em cada amostra e suavizar o ajuste.
+        try:
+            if self.t % self._auto_adjust_interval == 0:
+                self.auto_adjust_conscience_gamma()
+        except Exception:
+            # Não deixa falha no auto-ajuste quebrar o treino principal
+            pass
+
     def finalize_fisher(self):
         """Fisher = mean((x_w - W_w)²) sobre samples acumuladas."""
         cnt = self.fisher_count.clamp(min=1e-8)
@@ -455,10 +925,20 @@ class KohonenSOM4D:
         """Retorna métricas atuais do SOM para monitoramento."""
         sigma_t = self.sigma0 * math.exp(-self.t / 1000)
         alpha_t = self.alpha0 * math.exp(-self.t / 2000)
+        # V6.5-V2-metrics-FIX-4 — floors aplicados (consistência com update_weights)
+        sigma_t_eff = max(sigma_t, 0.1)
+        alpha_t_eff = max(alpha_t, 0.001)
+        # V6.5-V2-metrics-FIX-4 — estatísticas do conscience mechanism
+        n_total = self.n_neurons
+        n_active = int((self.bmu_win_count > 0).sum().item())
+        n_dead = n_total - n_active
+        win_counts_flat = self.bmu_win_count.flatten().float()
         return {
             "t": int(self.t),
             "sigma_t": float(sigma_t),
             "alpha_t": float(alpha_t),
+            "sigma_t_effective": float(sigma_t_eff),
+            "alpha_t_effective": float(alpha_t_eff),
             "sigma0": float(self.sigma0),
             "alpha0": float(self.alpha0),
             "lambda_ewc": float(self.lambda_ewc),
@@ -478,6 +958,26 @@ class KohonenSOM4D:
             "fisher_accum_count": int(self.fisher_count.sum().item()),
             "weights_norm": float(self.weights.norm().item()),
             "weights_w_mean": float(self.weights[..., 3].mean().item()),
+            # V6.5-V2-metrics-FIX-4 — conscience mechanism status
+            "conscience_gamma": float(self.conscience_gamma),
+            "conscience_beta": float(self.conscience_beta),
+            "n_active_neurons": n_active,
+            "n_dead_neurons": n_dead,
+            "neuron_activation_rate": float(n_active / max(1, n_total)),
+            "bmu_win_count_mean": float(win_counts_flat.mean().item()) if n_total > 0 else 0.0,
+            "bmu_win_count_max": float(win_counts_flat.max().item()) if n_total > 0 else 0.0,
+            "win_frequency_mean": float(self.win_frequency.mean().item()),
+            "win_frequency_max": float(self.win_frequency.max().item()),
+            "win_frequency_min": float(self.win_frequency.min().item()),
+            # V6.5-V2-auto-conscience — telemetria do ajuste adaptativo de γ
+            "conscience_gamma_min": float(self._conscience_gamma_min),
+            "conscience_gamma_max": float(self._conscience_gamma_max),
+            "conscience_gamma_target": float(self._last_gamma_target),
+            "conscience_gamma_drop": float(self._last_gamma_drop),
+            "conscience_gamma_eta": float(self._conscience_eta),
+            "conscience_gamma_adjust_interval": int(self._auto_adjust_interval),
+            "activation_rate_at_last_adjust": float(self._last_activation_rate),
+            "prev_n_active_at_last_adjust": int(self._prev_n_active),
         }
 
 
@@ -547,7 +1047,12 @@ class KohonenLearningSystem:
         T_max=10000,
         # V6.5 — VQ-VAE-2 + reasoning_engine
         enable_vqvae2: bool = True,
-        enable_reasoning: bool = True,
+        # V6.5-V2 — reasoning_engine desativado por padrão (user requirement:
+        # "por enquanto manter reasoning_engine desativado"). O ReasoningEngine
+        # cria ThreadPoolExecutor(4 workers) + ToolAgentCoordinator que consome
+        # ~100-200MB adicionais e não afeta o aprendizado do SOM. Para reativar,
+        # passe enable_reasoning=True explicitamente (requer ≥6GB cgroup).
+        enable_reasoning: bool = False,
         vqvae2_code_dim: int = 16,
         vqvae2_num_codes_top: int = 64,
         vqvae2_num_codes_bot: int = 128,
@@ -1059,15 +1564,21 @@ class KohonenLearningSystem:
                     )
                     self.som.update_weights(x, bmu, accumulate_fisher=acc_fisher)
 
-        # V6.5 — Ativa VQ-VAE-2 compressor no pipeline
+        # V6.5-V2-metrics-FIX-3 — VQ-VAE-2 e W8A8 compressão dentro de
+        # no_grad para evitar construção de grafo computacional (50-200MB
+        # por batch desperdiçados, causa direta de OOM em runs longos).
+        # O VQ-VAE-2 aqui é usado como compressor estatístico (não treinado
+        # por backprop no loop principal), então no_grad é correto.
         if self.enable_vqvae2 and self.vqvae2_compressor is not None:
-            self._compress_buffer_with_vqvae2(data)
+            with torch.no_grad():
+                self._compress_buffer_with_vqvae2(data)
 
         # V6.5-final — Ativa SmoothQuant W8A8 compressor dos pesos do SOM
         # User requirement: "integrar SmoothQuantCompressor ao KLS para
         # compressão W8A8 real dos pesos do SOM"
         if self.enable_w8a8 and self.w8a8_compressor is not None:
-            self.compress_som_weights_w8a8()
+            with torch.no_grad():
+                self.compress_som_weights_w8a8()
 
         # V6.5-final — Reativa tool_coordinator workers via execute_parallel
         # User requirement: "reativar reasoning_engine's tool_coordinator workers"
@@ -2417,6 +2928,18 @@ class KohonenLearningSystemV2(KohonenLearningSystem):
                 loss_total = deltas_stack.norm()
 
             loss_total.backward()
+            # V6.5-V2-metrics-FIX-3 — gradient clipping no treino de hipóteses
+            # previne explosão de gradientes em batches degenerados (ex: todos
+            # os labels iguais → BCE produz gradientes grandes). max_norm=1.0
+            # é o valor canônico recomendado pela literatura para BCE heads.
+            torch.nn.utils.clip_grad_norm_(
+                self.hypothesis_ensemble.parameters(), max_norm=1.0
+            )
+            # V6.5-V2-metrics-FIX-3 — zera grad do delta_scale (que não está
+            # no optimizer mas aparece no grafo de forward, aculumando .grad
+            # silenciosamente a cada step).
+            if self.delta_scale.grad is not None:
+                self.delta_scale.grad = None
             self.hyp_optimizer.step()
             losses.append(float(loss_total.item()))
 
@@ -2772,13 +3295,35 @@ class KohonenLearningSystemV2(KohonenLearningSystem):
         # Re-rotula neurônios (BMU labels podem ter mudado)
         self._label_neurons()
 
-        # Consolida via EWC (Fisher information em w)
-        try:
-            self.som.set_ewc_reference()
-            ewc_set = True
-        except Exception as e:
+        # V6.5-V2-metrics-FIX-3 — se best_delta tinha NaN (detectado acima e
+        # retornado early), NÃO chegamos aqui. Mas se chegamos via caminho
+        # else (pesos ficaram NaN após aplicação e foram revertidos), NÃO
+        # devemos consolidar via EWC — consolidar pesos potencialmente
+        # corruptos como referência EWC propagaria o problema para o futuro.
+        # Verificação: se os pesos atuais têm NaN, pula set_ewc_reference.
+        weights_corrupt = torch.isnan(self.som.weights).any() or torch.isinf(self.som.weights).any()
+        if weights_corrupt:
+            import logging as _logging
+            _logging.getLogger(__name__).error(
+                f"[V6.5-V2-metrics-FIX-3] SOM weights contain NaN/Inf after "
+                f"delta application — SKIPPING set_ewc_reference to avoid "
+                f"propagating corruption. Weights will be sanitized on next "
+                f"update_weights call."
+            )
+            # Sanitiza imediatamente para permitir continuidade do treino
+            self.som.weights = torch.nan_to_num(
+                self.som.weights, nan=0.0, posinf=100.0, neginf=-100.0
+            )
             ewc_set = False
-            sel_info["ewc_error"] = str(e)[:200]
+            sel_info["ewc_skipped"] = "weights_corrupt_after_delta"
+        else:
+            # Consolida via EWC (Fisher information em w)
+            try:
+                self.som.set_ewc_reference()
+                ewc_set = True
+            except Exception as e:
+                ewc_set = False
+                sel_info["ewc_error"] = str(e)[:200]
 
         return {
             "active": True,
@@ -3163,6 +3708,130 @@ class KohonenLearningSystemV2(KohonenLearningSystem):
             "max_hyp_train_steps": int(self.max_hyp_train_steps),
         }
 
+    # ==================================================================
+    # V6.5-V2-metrics-FIX-4 — Conscience mechanism + Dead neuron revival
+    # ==================================================================
+    # User requirement (latest): "APRIMORAR (em ambas as FASE1 e FASE2):
+    # analisar matematicamente e logicamente a ativação e uso e acesso dos
+    # neurônios (apenas dois estão sendo ativados: neurons_active=2/864)
+    # distribuindo o processamento paralelamente".
+    #
+    # Mathematical formulation (Conscience Mechanism — DeSieno 1988):
+    #
+    #   Cada neurônio i mantém win_frequency p_i ∈ [0,1] (EMA, β=0.1).
+    #   BMU selection: bmu = argmin_i ( ||W_i - x||² - b_i )
+    #     onde b_i = γ · (1/N - p_i)   é o conscience bias
+    #     γ = 0.1 (default), N = total de neurônios (864)
+    #
+    #   Quando p_i > 1/N (neurônio ganha demais): b_i < 0 → distância
+    #   efetiva AUMENTA → neurônio é penalizado.
+    #   Quando p_i < 1/N (neurônio nunca ganha): b_i > 0 → distância
+    #   efetiva DIMINUI → neurônio é favorecido.
+    #
+    #   Convergência: p_i → 1/N para todo i (distribuição uniforme de BMU),
+    #   garantindo que TODOS os 864 neurônios sejam utilizados.
+    #
+    # Dead neuron revival (complementar):
+    #   Se após K amostras um neurônio ainda tem win_count = 0, ele é
+    #   reinicializado para uma amostra aleatória do buffer (data-driven)
+    #   ou para N(0, 0.1) se buffer vazio. Isto acelera a diversificação
+    #   quando o conscience mechanism sozinho não basta.
+    # ------------------------------------------------------------------
+    def revive_dead_neurons(
+        self,
+        dead_threshold: int = 0,
+        use_buffer: bool = True,
+    ) -> Dict[str, Any]:
+        """V6.5-V2-metrics-FIX-4 — Wrapper KLS para som.revive_dead_neurons.
+
+        Usa o buffer_4d atual do KLS como fonte de dados para reinicialização
+        data-driven dos neurônios mortos.
+
+        Args:
+            dead_threshold: neurônios com win_count <= threshold são revividos.
+            use_buffer: se True, usa buffer_4d do KLS como fonte.
+
+        Returns:
+            Dict com status do revival (n_revived, dead_rate_before/after, etc).
+        """
+        data_buffer = self.buffer_4d if use_buffer else None
+        return self.som.revive_dead_neurons(
+            data_buffer=data_buffer,
+            dead_threshold=dead_threshold,
+        )
+
+    def parallel_neuron_activation_report(self) -> Dict[str, Any]:
+        """V6.5-V2-metrics-FIX-4 — Wrapper KLS para som.parallel_neuron_activation_report.
+
+        Retorna relatório estruturado de ativação dos 864 neurônios, análogo
+        ao DataFrame do exemplo fornecido pelo usuário, mas otimizado para
+        o grid 4D do SOM.
+
+        Returns:
+            Dict com estatísticas detalhadas (n_active, n_dead, win_count
+            distribution, conscience_bias stats, uniformity_score, etc).
+        """
+        return self.som.parallel_neuron_activation_report()
+
+    def auto_revive_if_needed(
+        self,
+        dead_rate_threshold: float = 0.5,
+        min_steps_between_revivals: int = 200,
+    ) -> Dict[str, Any]:
+        """V6.5-V2-metrics-FIX-4 — Revive neurônios automaticamente se dead_rate alto.
+
+        Verifica o dead_rate atual e revive neurônios mortos se:
+          - dead_rate > dead_rate_threshold (default 0.5 = 50% mortos)
+          - pelo menos min_steps_between_revivals desde o último revival
+
+        Isto é chamado automaticamente pelo treinador após cada chunk,
+        garantindo que o SOM mantenha distribuição uniforme de BMU ao longo
+        do treino sem intervenção manual.
+
+        Args:
+            dead_rate_threshold: limite para disparar revival (default 0.5).
+            min_steps_between_revivals: cooldown em steps (default 200).
+
+        Returns:
+            Dict com status do revival (ou action="skipped" se não disparou).
+        """
+        last_revival_step = getattr(self, "_last_revival_step", -min_steps_between_revivals)
+        current_step = self.som.t
+        steps_since_last = current_step - last_revival_step
+
+        # Computa dead rate atual
+        report = self.som.parallel_neuron_activation_report()
+        dead_rate = 1.0 - report["neuron_activation_rate"]
+
+        if dead_rate <= dead_rate_threshold:
+            return {
+                "action": "skipped",
+                "reason": f"dead_rate={dead_rate:.3f} <= threshold={dead_rate_threshold}",
+                "dead_rate": dead_rate,
+                "n_active": report["n_active_neurons"],
+                "n_total": report["n_total_neurons"],
+            }
+        if steps_since_last < min_steps_between_revivals:
+            return {
+                "action": "skipped",
+                "reason": f"cooldown: only {steps_since_last} steps since last revival "
+                          f"(need {min_steps_between_revivals})",
+                "dead_rate": dead_rate,
+                "n_active": report["n_active_neurons"],
+                "n_total": report["n_total_neurons"],
+            }
+
+        # Dispara revival
+        revival = self.revive_dead_neurons(
+            dead_threshold=0,
+            use_buffer=True,
+        )
+        self._last_revival_step = current_step
+        revival["action"] = "auto_revived"
+        revival["trigger_dead_rate"] = dead_rate
+        revival["steps_since_last_revival"] = steps_since_last
+        return revival
+
     # ==================================================================
     # V6.5-V2-metrics — Integração das métricas SOM canônicas
     # (QE, TE, Kaski-Lagus, Variância Explicada, Dead Neurons,

src/bigru_t/model/som_metrics.py

@@ -100,24 +100,41 @@ class SOMMetricHistory:
     dead_neuron_rate_history: deque = field(default_factory=lambda: deque(maxlen=50))
     epoch: int = 0
 
+    @staticmethod
+    def _safe_float(v: Any, default: float = 0.0) -> float:
+        """Converte para float, substituindo NaN/Inf por default.
+
+        V6.5-V2-metrics-FIX-3: Um único NaN no histórico contamina
+        permanentemente a detecção de estagnação (regressão linear)
+        e de cruzamento de vizinhança (média/desvio-padrão). Esta
+        barreira garante que somente valores finitos entrem no deque.
+        """
+        try:
+            f = float(v)
+        except (TypeError, ValueError):
+            return default
+        if not math.isfinite(f):
+            return default
+        return f
+
     def record(self, metrics: Dict[str, Any]) -> None:
-        """Registra métricas de uma época.
+        """Registra métricas de uma época (NaN/Inf são substituídos por 0.0).
 
         Nota: `dead_neuron_rate` pode ser float (valor direto) ou Dict
         (saída de compute_all_metrics, com chave 'dead_neuron_rate').
         """
-        self.qe_history.append(float(metrics.get("quantization_error", 0.0)))
-        self.te_history.append(float(metrics.get("topological_error", 0.0)))
-        self.kl_history.append(float(metrics.get("kaski_lagus_error", 0.0)))
+        self.qe_history.append(self._safe_float(metrics.get("quantization_error", 0.0)))
+        self.te_history.append(self._safe_float(metrics.get("topological_error", 0.0)))
+        self.kl_history.append(self._safe_float(metrics.get("kaski_lagus_error", 0.0)))
         self.var_explained_history.append(
-            float(metrics.get("explained_variance_share", 0.0))
+            self._safe_float(metrics.get("explained_variance_share", 0.0))
         )
         # dead_neuron_rate pode ser float ou Dict
         dnr = metrics.get("dead_neuron_rate", 0.0)
         if isinstance(dnr, dict):
-            dnr_val = float(dnr.get("dead_neuron_rate", 0.0))
+            dnr_val = self._safe_float(dnr.get("dead_neuron_rate", 0.0))
         else:
-            dnr_val = float(dnr)
+            dnr_val = self._safe_float(dnr)
         self.dead_neuron_rate_history.append(dnr_val)
         self.epoch += 1
 
@@ -214,9 +231,8 @@ def quantization_error(
         weights: tensor [I, J, K, L, 4] — pesos do SOM.
 
     Returns:
-        QE (float). 0.0 se data vazio. NaN propagado é substituído por 0.0
-        (V6.5-V2-metrics-FIX-2: user requirement "investigar QE e KL resultando
-        em NAN").
+        QE (float). 0.0 se data vazio. NaN/Inf propagado é substituído por 0.0
+        (V6.5-V2-metrics-FIX-3: agora também captura Inf, não apenas NaN).
     """
     if data.numel() == 0:
         return 0.0
@@ -230,8 +246,8 @@ def quantization_error(
     min_dist_sq = torch.clamp(min_dist_sq, min=0.0)
     qe = torch.mean(torch.sqrt(min_dist_sq))
     qe_val = float(qe.item())
-    # NaN check final (defense in depth)
-    if qe_val != qe_val:  # NaN
+    # V6.5-V2-metrics-FIX-3: rejeita tanto NaN quanto Inf
+    if not math.isfinite(qe_val):
         return 0.0
     return qe_val
 
@@ -251,14 +267,22 @@ def topological_error(
         weights: tensor [I, J, K, L, 4]
 
     Returns:
-        TE ∈ [0, 1]. 0.0 se data vazio.
+        TE ∈ [0, 1]. 0.0 se data vazio ou se grid tem < 2 neurônios.
     """
     if data.numel() == 0:
         return 0.0
+    # V6.5-V2-metrics-FIX-3: guard contra grid com < 2 neurônios
+    # (torch.topk(k=2) levanta RuntimeError se M < 2).
+    M = weights.shape[0] * weights.shape[1] * weights.shape[2] * weights.shape[3]
+    if M < 2:
+        return 0.0
     grid_shape = weights.shape[:-1]
     flat_w = weights.view(-1, 4)
     diff = data.unsqueeze(1) - flat_w.unsqueeze(0)
     dist_sq = torch.sum(diff * diff, dim=-1)  # (N, M)
+    # V6.5-V2-metrics-FIX-3: substitui NaN/Inf por +inf antes do topk
+    # para que neurônios com pesos degenerados não sejam eleitos BMU.
+    dist_sq = torch.where(torch.isfinite(dist_sq), dist_sq, torch.full_like(dist_sq, float('inf')))
 
     # Top-2 BMUs para cada amostra
     top2 = torch.topk(dist_sq, k=2, largest=False, dim=1)
@@ -289,6 +313,9 @@ def topological_error(
     is_adjacent = (delta.sum(dim=1) == 1) & (delta.max(dim=1).values == 1)
 
     te = 1.0 - float(is_adjacent.float().mean().item())
+    # V6.5-V2-metrics-FIX-3: rejeita NaN/Inf no resultado
+    if not math.isfinite(te):
+        return 0.0
     return te
 
 
@@ -321,16 +348,21 @@ def kaski_lagus_error(
         return 0.0
     qe = quantization_error(data, weights)
     te = topological_error(data, weights)
-    # Normalização: escala típica dos dados
-    data_norm = float(torch.mean(torch.norm(data, dim=1)).item())
+    # V6.5-V2-metrics-FIX-3: normalização canônica por desvio em torno do
+    # centróide (mean(||x_i - x̄||)), NÃO por mean(||x_i||). A versão antiga
+    # era sensível a translação dos dados — deslocar todos os vetores por +c
+    # inflava artificialmente ||x|| e reduzia KL, mesmo com QE/TE inalterados.
+    centroid = data.mean(dim=0, keepdim=True)  # (1, 4)
+    centered_norm = torch.norm(data - centroid, dim=1)  # (N,)
+    data_norm = float(centered_norm.mean().item())
     # V6.5-V2-metrics-FIX-2: se data_norm é NaN ou zero, usa 1.0 como fallback
-    if data_norm != data_norm or data_norm < 1e-8:  # NaN or ~0
+    if not math.isfinite(data_norm) or data_norm < 1e-8:
         data_norm = 1.0
     qe_norm = qe / max(data_norm, 1e-8)
     kl = alpha * qe_norm + (1.0 - alpha) * te
     kl_val = float(kl)
-    # NaN check final
-    if kl_val != kl_val:  # NaN
+    # V6.5-V2-metrics-FIX-3: rejeita tanto NaN quanto Inf
+    if not math.isfinite(kl_val):
         return 0.0
     return kl_val
 
@@ -366,10 +398,17 @@ def explained_variance_share(
 
     total_var = float(torch.sum(var_data).item())
     resid_var = float(torch.sum(var_resid).item())
+    # V6.5-V2-metrics-FIX-3: se dados são constantes (var~0) e o SOM os
+    # representa perfeitamente (resid~0), a variância explicada é 1.0
+    # (caso degenerado, mas correto). Antes retornava 0.0 erroneamente.
     if total_var < 1e-12:
-        return 0.0
+        return 1.0 if resid_var < 1e-12 else 0.0
     ve = 1.0 - (resid_var / total_var)
-    return float(max(0.0, min(1.0, ve)))
+    ve_val = float(max(0.0, min(1.0, ve)))
+    # V6.5-V2-metrics-FIX-3: rejeita NaN/Inf
+    if not math.isfinite(ve_val):
+        return 0.0
+    return ve_val
 
 
 # ============================================================================
@@ -429,6 +468,16 @@ def topological_collapse(weights: torch.Tensor) -> Dict[str, Any]:
         return {"collapsed_to_point": False, "collapsed_to_line": False,
                 "effective_rank": 0.0, "singular_values": [], "severity": "none"}
 
+    # V6.5-V2-metrics-FIX-3: se SVD retornou NaN/Inf (pesos degenerados),
+    # marca explicitamente como corrupção por NaN para não mascarar o problema.
+    if any(not math.isfinite(s) for s in S_list):
+        return {
+            "collapsed_to_point": False, "collapsed_to_line": False,
+            "effective_rank": 0.0, "singular_values": S_list,
+            "severity": "nan_corrupt",
+            "error": "SVD returned NaN/Inf singular values (weights contain NaN/Inf)",
+        }
+
     s_max = max(S_list[0] if S_list else 0.0, 1e-12)
 
     # Effective rank: número de singular values > 1% do maior
@@ -493,7 +542,12 @@ def dead_neuron_rate(
     flat_w = weights.view(-1, 4)
     diff = data.unsqueeze(1) - flat_w.unsqueeze(0)
     dist_sq = torch.sum(diff * diff, dim=-1)  # (N, M)
+    # V6.5-V2-metrics-FIX-3: substitui NaN/Inf por +inf para que neurônios
+    # degenerados não sejam eleitos BMU e não causem IndexError.
+    dist_sq = torch.where(torch.isfinite(dist_sq), dist_sq, torch.full_like(dist_sq, float('inf')))
     _, bmu_flat = torch.min(dist_sq, dim=1)  # (N,)
+    # V6.5-V2-metrics-FIX-3: valida range dos índices antes de indexar
+    bmu_flat = torch.clamp(bmu_flat, 0, n_total - 1)
 
     active_mask = torch.zeros(n_total, dtype=torch.bool)
     active_mask[bmu_flat] = True
@@ -566,8 +620,12 @@ def quantization_error_stagnation(
 
     current_qe = float(qe_list[-1])
     max_qe = float(max(qe_list))
+    # V6.5-V2-metrics-FIX-3: tolerância RELATIVA à magnitude do QE,
+    # não absoluta. Para QE~0.01, slope_tolerance=1e-4 representaria
+    # 1% por época (grande); para QE~100, seria negligenciável.
+    rel_tol = slope_tolerance * max(1.0, max_qe)
     is_high = current_qe > high_threshold_frac * max_qe
-    is_stable = abs(slope) < slope_tolerance
+    is_stable = abs(slope) < rel_tol
 
     is_stagnant = is_stable and is_high
 
@@ -630,6 +688,17 @@ def neighborhood_crossing(
     initial = te_list[:initial_window]
     final = te_list[-final_window:]
 
+    # V6.5-V2-metrics-FIX-3: filtra NaN/Inf (defesa em profundidade — o
+    # SOMMetricHistory.record já deveria ter feito isso, mas chamadas
+    # diretas a neighborhood_crossing podem receber histórico corrupto).
+    initial = [v for v in initial if math.isfinite(v)]
+    final = [v for v in final if math.isfinite(v)]
+    if len(initial) < 2 or len(final) < 2:
+        return {"detected": False, "te_initial_mean": 0.0, "te_final_mean": 0.0,
+                "te_initial_std": 0.0, "te_final_std": 0.0, "std_ratio": 0.0,
+                "is_oscillating": False, "is_growing": False, "severity": "none",
+                "n_epochs": len(te_list)}
+
     init_mean = sum(initial) / len(initial)
     final_mean = sum(final) / len(final)
     init_var = sum((x - init_mean) ** 2 for x in initial) / len(initial)
@@ -744,29 +813,33 @@ def compute_all_metrics(
 
     try:
         result = _compute_all_metrics_impl(data, weights, history)
-        # V6.5-V2-metrics-FIX-2: pós-computação, verifica se QE ou KL é NaN.
-        # Se sim, registra warning e substitui por 0.0 (para não quebrar logs JSON
-        # e nem contaminar o histórico de estagnação/cruzamento).
-        qe_val = result.get("quantization_error", 0.0)
-        kl_val = result.get("kaski_lagus_error", 0.0)
-        if isinstance(qe_val, float) and (qe_val != qe_val):  # NaN check
-            logger.warning(
-                f"[som_metrics] QE computed as NaN — replacing with 0.0 "
-                f"(indicates degenerate SOM state). Investigate train_hypotheses "
-                f"or apply_best_delta for gradient explosion."
-            )
-            result["quantization_error"] = 0.0
-            result["qe_was_nan"] = True
-            # KL depende de QE, então também será NaN
-            result["kaski_lagus_error"] = 0.0
-            result["kl_was_nan"] = True
-        elif isinstance(kl_val, float) and (kl_val != kl_val):  # NaN check
-            logger.warning(
-                f"[som_metrics] KL computed as NaN (QE was fine) — replacing with 0.0. "
-                f"Usually due to zero-norm data in kaski_lagus normalization."
-            )
-            result["kaski_lagus_error"] = 0.0
-            result["kl_was_nan"] = True
+        # V6.5-V2-metrics-FIX-3: pós-computação, verifica TODAS as métricas
+        # escalares por NaN/Inf (não apenas QE/KL). Substitui por 0.0 e marca
+        # para que o histórico não seja contaminado.
+        _SCALAR_METRIC_KEYS = [
+            "quantization_error", "topological_error", "kaski_lagus_error",
+            "explained_variance_share",
+        ]
+        any_nan = False
+        for k in _SCALAR_METRIC_KEYS:
+            v = result.get(k, 0.0)
+            if isinstance(v, float) and not math.isfinite(v):
+                logger.warning(
+                    f"[som_metrics] {k} computed as NaN/Inf ({v}) — replacing "
+                    f"with 0.0. Investigate train_hypotheses or apply_best_delta "
+                    f"for gradient explosion."
+                )
+                result[k] = 0.0
+                result[f"{k}_was_nan"] = True
+                any_nan = True
+        # V6.5-V2-metrics-FIX-3: também verifica sub-dicts de collapse/dead
+        # para severity='nan_corrupt' e propaga como failure_indicator.
+        if result.get("topological_collapse", {}).get("severity") == "nan_corrupt":
+            any_nan = True
+        if any_nan and "failure_indicators" in result:
+            result["failure_indicators"].append("post_compute_nan_replaced")
+            result["overall_health"] = "critical"
+            result["n_failure_indicators"] = len(result["failure_indicators"])
         return result
     except Exception as e:
         logger.warning(