V6.5-V2-parallel-reorganize: ParallelSOM4D + ReorganizingSOM4D + OOM-killer guards + unified state (75 files)

model_states/v6_5_v2_model_states.pt

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

scripts/train_v6_5_v2.py

@@ -1199,11 +1199,62 @@ def run_fase_conhecimento(
                                 dataset_name=dataset_name,
                                 enable_punishment=False,
                             )
+                        except (MemoryError, RuntimeError) as oom_err:
+                            # V6.5-V2-oom-guard — OOM-killer protection
+                            # 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 (acrescentar
+                            # exceptions e melhor detecção de falhas de lógica e
+                            # erros de script)".
+                            #
+                            # Captura MemoryError e RuntimeError("out of memory")
+                            # explicitamente. Em vez de morrer, dispara limpeza
+                            # agressiva de memória e continua com o próximo batch.
+                            is_oom = (
+                                isinstance(oom_err, MemoryError)
+                                or "out of memory" in str(oom_err).lower()
+                                or "cuda" in str(oom_err).lower()
+                            )
+                            if is_oom:
+                                logger.error(
+                                    f"[V6.5-V2-oom-guard] OOM detected in process_batch_v2: "
+                                    f"{type(oom_err).__name__}: {str(oom_err)[:200]}"
+                                )
+                                logger.error("[V6.5-V2-oom-guard] Triggering aggressive memory cleanup...")
+                                cleanup_result = aggressive_memory_cleanup()
+                                logger.error(
+                                    f"[V6.5-V2-oom-guard] Cleanup freed "
+                                    f"{cleanup_result.get('freed_mb', 0):.1f}MB "
+                                    f"(RSS: {cleanup_result.get('rss_before_mb', 0):.0f}MB → "
+                                    f"{cleanup_result.get('rss_after_mb', 0):.0f}MB)"
+                                )
+                                # Trunca buffer para reduzir pressão
+                                if len(kls.buffer_4d) > 32:
+                                    overflow = len(kls.buffer_4d) - 32
+                                    del kls.buffer_4d[:overflow]
+                                    del kls.buffer_labels[:overflow]
+                                    logger.error(
+                                        f"[V6.5-V2-oom-guard] Buffer truncated to 32 "
+                                        f"(dropped {overflow} samples)"
+                                    )
+                                continue
+                            else:
+                                logger.error(f"[V6.5-V2] process_batch_v2 RuntimeError: {oom_err}")
+                                traceback.print_exc()
+                                continue
                         except Exception as e:
                             logger.error(f"[V6.5-V2] process_batch_v2 error: {e}")
                             traceback.print_exc()
                             continue
 
+                        # V6.5-V2-oom-guard — gc.collect() entre batches para
+                        # liberar tensores intermediários antes que se acumulem.
+                        # Em runs longos (8000+ samples), mesmo pequenos leaks
+                        # acumulam e causam OOM. O custo de gc.collect() é ~10ms,
+                        # insignificante vs. o risco de morte por OOM-killer.
+                        if step % 4 == 0:
+                            gc.collect()
+
                         # V6.5-V2-kmeans-pp - Apos 1o chunk, inicializa pesos
                         # do SOM via k-means++ (deferred init).
                         # User requirement: "inicializacao com k-means++ sobre
@@ -1250,6 +1301,27 @@ def run_fase_conhecimento(
 
                         step += 1
                         time.sleep(INTER_BATCH_PAUSE_S_FASE1)
+                    except (MemoryError, RuntimeError) as oom_err_outer:
+                        # V6.5-V2-oom-guard — Outer OOM catch (metrics/attention eval)
+                        is_oom_outer = (
+                            isinstance(oom_err_outer, MemoryError)
+                            or "out of memory" in str(oom_err_outer).lower()
+                        )
+                        if is_oom_outer:
+                            logger.error(
+                                f"[V6.5-V2-oom-guard] Outer OOM in batch loop: "
+                                f"{type(oom_err_outer).__name__}: {str(oom_err_outer)[:200]}"
+                            )
+                            cleanup_result = aggressive_memory_cleanup()
+                            logger.error(
+                                f"[V6.5-V2-oom-guard] Cleanup freed "
+                                f"{cleanup_result.get('freed_mb', 0):.1f}MB"
+                            )
+                            continue
+                        else:
+                            logger.error(f"[V6.5-V2] Batch RuntimeError: {oom_err_outer}")
+                            traceback.print_exc()
+                            continue
                     except Exception as e:
                         logger.error(f"[V6.5-V2] Batch error: {e}")
                         traceback.print_exc()
@@ -1897,11 +1969,54 @@ def run_fase_punicão(
                             dataset_name=PUNICAO_DATASET,
                             enable_punishment=True,
                         )
+                    except (MemoryError, RuntimeError) as oom_err_fase2:
+                        # V6.5-V2-oom-guard — OOM-killer protection FASE2
+                        # User requirement: "o processo vem sendo morto OOM-kiler".
+                        # FASE2 é mais pesada (hypothesis training + EWC) e mais
+                        # propensa a OOM. Captura MemoryError e RuntimeError("out
+                        # of memory") explicitamente para evitar morte do processo.
+                        is_oom_f2 = (
+                            isinstance(oom_err_fase2, MemoryError)
+                            or "out of memory" in str(oom_err_fase2).lower()
+                            or "cuda" in str(oom_err_fase2).lower()
+                        )
+                        if is_oom_f2:
+                            logger.error(
+                                f"[V6.5-V2-oom-guard] FASE2 OOM detected: "
+                                f"{type(oom_err_fase2).__name__}: {str(oom_err_fase2)[:200]}"
+                            )
+                            logger.error("[V6.5-V2-oom-guard] Triggering aggressive memory cleanup...")
+                            cleanup_result = aggressive_memory_cleanup()
+                            logger.error(
+                                f"[V6.5-V2-oom-guard] FASE2 cleanup freed "
+                                f"{cleanup_result.get('freed_mb', 0):.1f}MB "
+                                f"(RSS: {cleanup_result.get('rss_before_mb', 0):.0f}MB → "
+                                f"{cleanup_result.get('rss_after_mb', 0):.0f}MB)"
+                            )
+                            # Trunca buffer para reduzir pressão
+                            if len(kls.buffer_4d) > 32:
+                                overflow = len(kls.buffer_4d) - 32
+                                del kls.buffer_4d[:overflow]
+                                del kls.buffer_labels[:overflow]
+                                logger.error(
+                                    f"[V6.5-V2-oom-guard] FASE2 buffer truncated to 32 "
+                                    f"(dropped {overflow} samples)"
+                                )
+                            continue
+                        else:
+                            logger.error(f"[V6.5-V2] FASE2 process_batch_v2 RuntimeError: {oom_err_fase2}")
+                            traceback.print_exc()
+                            continue
                     except Exception as e:
                         logger.error(f"[V6.5-V2] process_batch_v2 error: {e}")
                         traceback.print_exc()
                         continue
 
+                    # V6.5-V2-oom-guard — gc.collect() entre batches FASE2
+                    # (PUNITIVA é mais pesada — hypothesis training + EWC + revival)
+                    if step % 2 == 0:
+                        gc.collect()
+
                     # Log punishment events
                     action = result.get("action", "none")
                     if action != "none" and action != "success":

src/bigru_t/model/kohonen_learning_system.py

@@ -975,6 +975,314 @@ class KohonenSOM4D:
                 "n_recent_bmus_tracked": int(len(self._recent_bmu_flat)),
             }
 
+    # ==================================================================
+    # V6.5-V2-parallel — Vectorial parallel SOM (ParallelSOM4D pattern)
+    # User requirement: "Para elevar o desempenho ao nível máximo, a arquitetura
+    # com multiprocessing (baseada em CPU) que usamos anteriormente não é a
+    # ideal para cenários de alta dimensão. O custo de copiar os dados entre
+    # múltiplos processos do Python (overhead de IPC) anula o ganho da
+    # computação paralela. Para um ajuste paralelo verdadeiro e massivo de uma
+    # SOM de 4 dimensões, a abordagem ideal é o paralelismo vetorial em GPU
+    # utilizando PyTorch."
+    #
+    # Math: todas as operações são feitas via broadcasting PyTorch:
+    #   1. distances = sum((flat_weights - sample)^2, dim=-1)  # (N_neurons,)
+    #   2. bmu_idx = argmin(distances)
+    #   3. grid_dists_sq = sum((grid_coords - bmu_coord)^2, dim=-1)  # (N_neurons,)
+    #   4. influence = exp(-grid_dists_sq / (2 * sigma^2))  # (N_neurons,)
+    #   5. weights += alpha * influence * (sample - weights)  # broadcast (N, 4)
+    # ==================================================================
+    def _precompute_grid_coords_flat(self) -> torch.Tensor:
+        """Pré-computa coordenadas 4D da grade planificadas (N_neurons, 4).
+
+        V6.5-V2-parallel — pré-computação evita recriar meshgrid a cada update.
+        Usado por train_batch_parallel e reorganize_map_by_density.
+        """
+        if not hasattr(self, "_grid_coords_flat_cache") or self._grid_coords_flat_cache is None:
+            II, JJ, KK, LL = torch.meshgrid(
+                torch.arange(self.I).float(),
+                torch.arange(self.J).float(),
+                torch.arange(self.K).float(),
+                torch.arange(self.L).float(),
+                indexing="ij",
+            )
+            grid_coords = torch.stack([II, JJ, KK, LL], dim=-1)  # (I, J, K, L, 4)
+            self._grid_coords_flat_cache = grid_coords.view(-1, 4)  # (N, 4)
+        return self._grid_coords_flat_cache
+
+    def train_batch_parallel(
+        self,
+        samples: torch.Tensor,
+        use_conscience: bool = True,
+        accumulate_fisher: bool = False,
+    ) -> Dict[str, Any]:
+        """V6.5-V2-parallel — Treina SOM com paralelismo vetorial PyTorch.
+
+        User requirement (ParallelSOM4D pattern): processa amostras usando
+        operações matriciais PyTorch ao invés de loops Python. Cada amostra
+        ainda é processada sequencialmente (online learning — Kohonen canônico),
+        mas todas as operações internas (distância, BMU, vizinhança, update)
+        são feitas via broadcasting sobre os 864 neurônios simultaneamente.
+
+        Vantagens:
+        1. Zero IPC overhead (sem multiprocessing)
+        2. Broadcast de tensores — uma instrução matricial atualiza todos os
+           pesos da hipergrade 4D simultaneamente
+        3. Compatível com AVX512_VNNI / AMX_INT8 via xeon_runtime
+        4. Memória eficiente: apenas 2 tensores temporários (dist, influence)
+
+        Args:
+            samples: tensor (B, 4) — batch de amostras 4D.
+            use_conscience: se True, aplica bias de consciência (default True).
+            accumulate_fisher: se True, acumula Fisher info em w.
+
+        Returns:
+            Dict com: n_processed, n_bmu_unique, dead_rate, alpha_t, sigma_t.
+        """
+        if not isinstance(samples, torch.Tensor):
+            samples = torch.tensor(samples, dtype=torch.float)
+        samples = samples.float()
+        if samples.dim() == 1:
+            samples = samples.unsqueeze(0)
+        # Sanitiza NaN/Inf
+        samples = torch.nan_to_num(samples, nan=0.0, posinf=1e4, neginf=-1e4)
+
+        n_processed = 0
+        bmu_indices: List[Tuple[int, int, int, int]] = []
+        grid_coords_flat = self._precompute_grid_coords_flat()
+
+        with torch.no_grad():
+            for sample_idx in range(samples.shape[0]):
+                x = samples[sample_idx]  # (4,)
+                # 1. PARALELISMO MATRICIAL: distância de 1 amostra vs TODOS os neurônios
+                flat_weights = self.weights.view(-1, 4)  # (N, 4)
+                dist = torch.sum((flat_weights - x.unsqueeze(0)) ** 2, dim=-1)  # (N,)
+
+                # 2. BMU selection (com conscience opcional)
+                if use_conscience:
+                    win_count_flat = self.bmu_win_count.flatten().float()
+                    max_win = win_count_flat.max().clamp(min=1.0)
+                    p_norm = win_count_flat / max_win
+                    bias = self.conscience_gamma * (0.5 - p_norm)
+                    dead_mask = (win_count_flat == 0).float()
+                    dead_boost = self.conscience_gamma * 0.5 * dead_mask
+                    bias_flat = bias + dead_boost
+                    dist_eff = dist - bias_flat
+                    flat_idx = int(torch.argmin(dist_eff).item())
+                else:
+                    flat_idx = int(torch.argmin(dist).item())
+
+                # Recupera coordenada 4D da BMU
+                i = flat_idx // (self.J * self.K * self.L)
+                rest = flat_idx % (self.J * self.K * self.L)
+                j = rest // (self.K * self.L)
+                rest = rest % (self.K * self.L)
+                k = rest // self.L
+                l = rest % self.L
+                bmu_idx = (i, j, k, l)
+                bmu_indices.append(bmu_idx)
+
+                # 3. Vizinhança 4D paralela — distância na grade
+                bmu_coord = grid_coords_flat[flat_idx]  # (4,)
+                grid_dists_sq = torch.sum((grid_coords_flat - bmu_coord.unsqueeze(0)) ** 2, dim=-1)  # (N,)
+
+                # 4. Hiperparâmetros com floors
+                sigma = max(self.sigma0 * math.exp(-self.t / 1000), 0.1)
+                alpha = max(self.alpha0 * math.exp(-self.t / 2000), 0.001)
+
+                # 5. Influência Gaussiana
+                influence = torch.exp(-grid_dists_sq / (2 * sigma ** 2))  # (N,)
+                influence = influence.view(self.I, self.J, self.K, self.L, 1)  # (I,J,K,L,1)
+
+                # 6. Update em massa — uma operação vetorial
+                delta = x.view(1, 1, 1, 1, 4) - self.weights  # (I,J,K,L,4)
+                update = alpha * influence * delta
+
+                # EWC penalty na 4ª dimensão
+                if self.old_weights_w is not None and self.fisher_w is not None:
+                    ewc_penalty = self.lambda_ewc * self.fisher_w * (
+                        self.weights[..., 3] - self.old_weights_w
+                    )
+                    update[..., 3] = update[..., 3] - ewc_penalty
+
+                self.weights = self.weights + update
+                self.weights = torch.clamp(self.weights, -100.0, 100.0)
+                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
+                    )
+
+                # 7. Fisher accumulation
+                if accumulate_fisher:
+                    influence_flat = influence.view(-1)
+                    mask = influence_flat > 0.1
+                    if mask.any():
+                        diff_sq = (x[3] - self.weights.view(-1, 4)[mask, 3]) ** 2
+                        self.fisher_accum.view(-1)[mask] += diff_sq
+                        self.fisher_count.view(-1)[mask] += 1
+
+                self.t += 1
+                n_processed += 1
+
+                # 8. Atualiza conscience (win frequency)
+                try:
+                    self.update_win_frequency(bmu_idx)
+                except Exception:
+                    pass
+
+                # 9. Auto-ajuste de γ (throttled)
+                try:
+                    if self.t % self._auto_adjust_interval == 0:
+                        self.auto_adjust_conscience_gamma()
+                except Exception:
+                    pass
+
+        # Estatísticas pós-batch
+        n_unique_bmus = len(set(bmu_indices))
+        n_active = int((self.bmu_win_count > 0).sum().item())
+        dead_rate = float(1.0 - n_active / max(1, self.n_neurons))
+        sigma_t = max(self.sigma0 * math.exp(-self.t / 1000), 0.1)
+        alpha_t = max(self.alpha0 * math.exp(-self.t / 2000), 0.001)
+
+        return {
+            "n_processed": n_processed,
+            "n_bmu_unique": n_unique_bmus,
+            "dead_rate": dead_rate,
+            "n_active": n_active,
+            "n_total": self.n_neurons,
+            "alpha_t": float(alpha_t),
+            "sigma_t": float(sigma_t),
+            "som_t": int(self.t),
+            "conscience_gamma": float(self.conscience_gamma),
+            "method": "vectorial_parallel_pytorch",
+        }
+
+    # ==================================================================
+    # V6.5-V2-reorganize — Density-based map reorganization
+    # (ReorganizingSOM4D pattern)
+    # User requirement: "Para reorganizar o mapa SOM dinamicamente durante o
+    # treinamento, a técnica matemática mais robusta e paralelizável é a
+    # Filtragem de Ativação por Convolução Baseada em Densidade. Em vez de
+    # alterar a topologia de forma sequencial (o que quebraria o paralelismo),
+    # nós calculamos a frequência de ativação de cada neurônio (densidade de
+    # uso) diretamente na GPU/CPU e aplicamos um filtro gaussiano
+    # multidimensional. Os neurônios pouco ativados (isolados) sofrem uma força
+    # de atração em direção aos agrupamentos de alta densidade, reorganizando
+    # geometricamente o hipercubo 4D sem perder o alinhamento matricial."
+    #
+    # Math:
+    #   density_i = bmu_win_count[i] / sum(bmu_win_count)  ∈ [0, 1]
+    #   density_center = sum(weights * density, dim=0)  (centro de massa ponderado)
+    #   pull_force_i = (1 - density_i) * regularization_factor
+    #   new_weights_i = weights_i + pull_force_i * (density_center - weights_i)
+    #
+    # Comportamento:
+    #   - Neurônios com alta densidade (muito ativos): pull_force ≈ 0 → ficam parados
+    #   - Neurônios com baixa densidade (mortos): pull_force ≈ 1 → puxados para o centro
+    #   - Centro de massa é dominado pelos neurônios ativos (ponderação por densidade)
+    # ==================================================================
+    def reorganize_map_by_density(
+        self,
+        regularization_factor: float = 0.05,
+        min_dead_rate_for_trigger: float = 0.3,
+    ) -> Dict[str, Any]:
+        """V6.5-V2-reorganize — Reorganização topológica paralela baseada em densidade.
+
+        Implementa o padrão ReorganizingSOM4D: identifica zonas frias (neurônios
+        mortos) via hit_map e as desloca matematicamente em direção ao centro
+        de massa ponderado pelos neurônios ativos.
+
+        Vantagens sobre revive_dead_neurons puro:
+        1. Não zera bmu_win_count (preserva histórico de ativação)
+        2. Pulso suave e contínuo (não reinicialização abrupta)
+        3. Compatível com paralelismo matricial — uma única operação vetorial
+        4. Decaimento temporal: regularization_factor *= decay (early epochs
+           reorganizam drasticamente, late epochs estabilizam)
+        5. Eliminação efetiva de neurônios mortos sem quebrar a topologia
+
+        Args:
+            regularization_factor: magnitude do pull (default 0.05 — 5% do
+                deslocamento em direção ao centro de massa).
+            min_dead_rate_for_trigger: só reorganiza se dead_rate > threshold
+                (default 0.3 = 30% mortos). Evita reorganização desnecessária.
+
+        Returns:
+            Dict com: reorganized, dead_rate_before, dead_rate_after (estimado),
+                n_dead_pulled, density_center_norm, regularization_factor.
+        """
+        with torch.no_grad():
+            # Computa dead rate atual
+            n_total = self.n_neurons
+            n_active = int((self.bmu_win_count > 0).sum().item())
+            dead_rate = float(1.0 - n_active / max(1, n_total))
+
+            if dead_rate < min_dead_rate_for_trigger:
+                return {
+                    "reorganized": False,
+                    "reason": f"dead_rate={dead_rate:.3f} < threshold={min_dead_rate_for_trigger}",
+                    "dead_rate": dead_rate,
+                    "n_active": n_active,
+                    "n_total": n_total,
+                }
+
+            # Normaliza hit_map para distribuição de densidade
+            total_hits = float(self.bmu_win_count.sum().item())
+            if total_hits < 1e-8:
+                # Sem hits — não há centro de massa para puxar
+                return {
+                    "reorganized": False,
+                    "reason": "no_hits_in_buffer",
+                    "dead_rate": dead_rate,
+                    "n_active": n_active,
+                    "n_total": n_total,
+                }
+
+            density = self.bmu_win_count.float() / total_hits  # (I, J, K, L)
+
+            # Planifica para operações matriciais
+            flat_weights = self.weights.view(-1, 4)  # (N, 4)
+            flat_density = density.view(-1, 1)  # (N, 1)
+
+            # Centro de massa ponderado por densidade (âncora global)
+            density_center = torch.sum(flat_weights * flat_density, dim=0, keepdim=True)  # (1, 4)
+            density_center_norm = float(torch.norm(density_center).item())
+
+            # Decaimento temporal: reorganização forte em épocas iniciais,
+            # estabiliza em épocas finais (decay = exp(-t / 5000))
+            decay = float(math.exp(-self.t / 5000.0))
+            effective_factor = float(regularization_factor * decay)
+
+            # Força de atração: neurônios com baixa densidade sofrem maior deslocamento
+            pull_force = (1.0 - flat_density) * effective_factor  # (N, 1)
+
+            # Aplica reorganização em uma operação vetorial
+            new_flat_weights = flat_weights + pull_force * (density_center - flat_weights)
+
+            # Restaura shape original
+            self.weights = new_flat_weights.view(self.I, self.J, self.K, self.L, 4).clone()
+            self.weights = torch.clamp(self.weights, -100.0, 100.0)
+
+            # Sanitiza NaN/Inf
+            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
+                )
+
+            # Conta quantos neurônios mortos foram efetivamente deslocados
+            n_dead_pulled = int((pull_force.view(-1) > 1e-6).sum().item())
+
+            return {
+                "reorganized": True,
+                "dead_rate_before": dead_rate,
+                "n_dead_pulled": n_dead_pulled,
+                "density_center_norm": density_center_norm,
+                "regularization_factor": effective_factor,
+                "decay": decay,
+                "n_active": n_active,
+                "n_total": n_total,
+                "method": "density_based_reorganization",
+            }
+
     def auto_adjust_conscience_gamma(self) -> Dict[str, Any]:
         """V6.5-V2-auto-conscience-v2 — Ajusta γ dinamicamente conforme ativação.
 
@@ -1804,22 +2112,60 @@ class KohonenLearningSystem:
         V6.5-V2-memfix — Wrapped in torch.no_grad() to prevent graph building
         during SOM Hebbian updates. The SOM uses competitive learning (BMU +
         Gaussian neighborhood), not backprop — no gradient is needed.
+
+        V6.5-V2-parallel — Agora usa train_batch_parallel (ParallelSOM4D pattern)
+        ao invés do loop find_bmu + update_weights manual. Isto elimina o
+        overhead de Python e usa broadcasting PyTorch sobre os 864 neurônios.
+        User requirement: "Para um ajuste paralelo verdadeiro e massivo de uma
+        SOM de 4 dimensões, a abordagem ideal é o paralelismo vetorial em GPU
+        utilizando PyTorch."
+
+        V6.5-V2-reorganize — Após treinar, dispara reorganização por densidade
+        se dead_rate > 30% (ReorganizingSOM4D pattern).
         """
         if not self.buffer_4d:
             return
         # V6.5-V2-memfix — detach+stack to ensure no graph leaks from buffer
         data = torch.stack(self.buffer_4d).detach()
         with torch.no_grad():
+            # V6.5-V2-parallel — Usa train_batch_parallel para todas as 5 épocas
+            # User requirement: paralelismo vetorial PyTorch sobre os 864 neurônios
+            acc_fisher = (
+                self.punishment_count == 0
+                and self.som.old_weights_w is None
+            )
             for _ in range(5):  # épocas de treino rápido
                 perm = torch.randperm(len(data))
-                for idx in perm:
-                    x = data[idx]
-                    bmu = self.som.find_bmu(x)
-                    acc_fisher = (
-                        self.punishment_count == 0
-                        and self.som.old_weights_w is None
+                # train_batch_parallel já faz sanitização NaN/Inf + conscience
+                # + Fisher accumulation em uma única chamada vetorial
+                self.som.train_batch_parallel(
+                    samples=data[perm],
+                    use_conscience=True,
+                    accumulate_fisher=acc_fisher,
+                )
+
+            # V6.5-V2-reorganize — Reorganização topológica por densidade
+            # User requirement (ReorganizingSOM4D pattern): "Os neurônios pouco
+            # ativados (isolados) sofrem uma força de atração em direção aos
+            # agrupamentos de alta densidade, reorganizando geometricamente o
+            # hipercubo 4D sem perder o alinhamento matricial."
+            try:
+                reorg = self.reorganize_map_if_needed(
+                    regularization_factor=0.05,
+                    min_dead_rate_for_trigger=0.3,
+                    min_steps_between_reorganizations=300,
+                )
+                if reorg.get("action") == "auto_reorganized":
+                    import logging as _logging
+                    _log = _logging.getLogger("kohonen_learning_system")
+                    _log.info(
+                        f"[V6.5-V2-reorganize] Map reorganized: "
+                        f"n_dead_pulled={reorg.get('n_dead_pulled')}, "
+                        f"dead_rate={reorg.get('dead_rate_before', 0):.3f}, "
+                        f"factor={reorg.get('regularization_factor', 0):.4f}"
                     )
-                    self.som.update_weights(x, bmu, accumulate_fisher=acc_fisher)
+            except Exception:
+                pass
 
         # 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
@@ -4104,6 +4450,128 @@ class KohonenLearningSystemV2(KohonenLearningSystem):
         """
         return self.som.parallel_neuron_activation_report()
 
+    # ==================================================================
+    # V6.5-V2-parallel — Wrappers para novos métodos parallel SOM
+    # ==================================================================
+    def train_som_batch_parallel(
+        self,
+        samples: torch.Tensor,
+        use_conscience: bool = True,
+        accumulate_fisher: bool = False,
+    ) -> Dict[str, Any]:
+        """V6.5-V2-parallel — Wrapper KLS para som.train_batch_parallel.
+
+        User requirement (ParallelSOM4D pattern): usa paralelismo vetorial
+        PyTorch ao invés de loops Python + multiprocessing. Todas as operações
+        internas (distância, BMU, vizinhança, update) são feitas via
+        broadcasting sobre os 864 neurônios simultaneamente.
+
+        Args:
+            samples: tensor (B, 4) — batch de amostras 4D.
+            use_conscience: se True, aplica bias de consciência.
+            accumulate_fisher: se True, acumula Fisher info em w.
+
+        Returns:
+            Dict com: n_processed, n_bmu_unique, dead_rate, alpha_t, sigma_t.
+        """
+        return self.som.train_batch_parallel(
+            samples=samples,
+            use_conscience=use_conscience,
+            accumulate_fisher=accumulate_fisher,
+        )
+
+    def reorganize_som_map_by_density(
+        self,
+        regularization_factor: float = 0.05,
+        min_dead_rate_for_trigger: float = 0.3,
+    ) -> Dict[str, Any]:
+        """V6.5-V2-reorganize — Wrapper KLS para som.reorganize_map_by_density.
+
+        User requirement (ReorganizingSOM4D pattern): reorganiza topologia do
+        SOM dinamicamente durante o treinamento via filtragem de ativação por
+        densidade. Neurônios pouco ativados (isolados) sofrem força de atração
+        em direção aos agrupamentos de alta densidade, reorganizando
+        geometricamente o hipercubo 4D sem perder o alinhamento matricial.
+
+        Args:
+            regularization_factor: magnitude do pull (default 0.05).
+            min_dead_rate_for_trigger: só reorganiza se dead_rate > threshold.
+
+        Returns:
+            Dict com: reorganized, dead_rate_before, n_dead_pulled, etc.
+        """
+        return self.som.reorganize_map_by_density(
+            regularization_factor=regularization_factor,
+            min_dead_rate_for_trigger=min_dead_rate_for_trigger,
+        )
+
+    def reorganize_map_if_needed(
+        self,
+        regularization_factor: float = 0.05,
+        min_dead_rate_for_trigger: float = 0.3,
+        min_steps_between_reorganizations: int = 300,
+    ) -> Dict[str, Any]:
+        """V6.5-V2-reorganize — Auto-dispara reorganização por densidade se necessário.
+
+        Verifica o dead_rate atual e reorganiza o mapa SOM se:
+          - dead_rate > min_dead_rate_for_trigger (default 0.3 = 30% mortos)
+          - pelo menos min_steps_between_reorganizations desde a última
+            reorganização (cooldown)
+
+        Complementa auto_revive_if_needed: enquanto auto_revive faz
+        reinicialização abrupta (k-means++ selection), reorganize_map faz
+        pulso suave e contínuo (gravitational pull). Ambos podem coexistir.
+
+        Args:
+            regularization_factor: magnitude do pull (default 0.05).
+            min_dead_rate_for_trigger: limite para disparar (default 0.3).
+            min_steps_between_reorganizations: cooldown em steps (default 300).
+
+        Returns:
+            Dict com status da reorganização (ou action="skipped" se não disparou).
+        """
+        last_reorg_step = getattr(
+            self, "_last_reorganize_step", -min_steps_between_reorganizations
+        )
+        current_step = self.som.t
+        steps_since_last = current_step - last_reorg_step
+
+        # Computa dead rate atual
+        n_total = self.som.n_neurons
+        n_active = int((self.som.bmu_win_count > 0).sum().item())
+        dead_rate = float(1.0 - n_active / max(1, n_total))
+
+        if dead_rate <= min_dead_rate_for_trigger:
+            return {
+                "action": "skipped",
+                "reason": f"dead_rate={dead_rate:.3f} <= threshold={min_dead_rate_for_trigger}",
+                "dead_rate": dead_rate,
+                "n_active": n_active,
+                "n_total": n_total,
+            }
+        if steps_since_last < min_steps_between_reorganizations:
+            return {
+                "action": "skipped",
+                "reason": (
+                    f"cooldown: only {steps_since_last} steps since last reorg "
+                    f"(need {min_steps_between_reorganizations})"
+                ),
+                "dead_rate": dead_rate,
+                "n_active": n_active,
+                "n_total": n_total,
+            }
+
+        # Dispara reorganização
+        reorg = self.reorganize_som_map_by_density(
+            regularization_factor=regularization_factor,
+            min_dead_rate_for_trigger=min_dead_rate_for_trigger,
+        )
+        self._last_reorganize_step = current_step
+        reorg["action"] = "auto_reorganized"
+        reorg["trigger_dead_rate"] = dead_rate
+        reorg["steps_since_last_reorg"] = steps_since_last
+        return reorg
+
     def auto_revive_if_needed(
         self,
         dead_rate_threshold: float = 0.5,