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

scripts/train_v6_5_v2.py

@@ -580,7 +580,12 @@ def save_model_states_for_evaluation(
                 "step": int(step),
                 "total_samples": int(total_samples),
                 "timestamp": datetime.now().isoformat(),
-                "version": "V6.5-V2-metrics-FIX-2",
+                "version": "V6.5-V2-unified-state",
+                # V6.5-V2-unified — fase que gerou este estado. Permite que
+                # um processo separado (ex: retomar treino) saiba se o estado
+                # é pós-FASE1 (pronto para FASE2) ou pós-FASE2 (treino completo).
+                "phase": str(reason),  # "end_of_fase_conhecimento" | "end_of_training_v2"
+                "kmeans_pp_applied": bool(getattr(kls.som, "_kmeans_pp_initialized", False)),
                 "som_grid": list(kls.som_grid),
                 "n_neurons": int(kls.som_neuron_count),
                 "hidden_dim": int(kls.hidden_dim),
@@ -1199,6 +1204,24 @@ def run_fase_conhecimento(
                             traceback.print_exc()
                             continue
 
+                        # V6.5-V2-kmeans-pp - Apos 1o chunk, inicializa pesos
+                        # do SOM via k-means++ (deferred init).
+                        # User requirement: "inicializacao com k-means++ sobre
+                        # embeddings em vez de grid coords+ruido para ambas as
+                        # FASE1 e FASE2".
+                        try:
+                            _km = kls.init_weights_kmeans_pp_if_ready()
+                            if isinstance(_km, dict) and _km.get("initialized"):
+                                logger.info(
+                                    f"[V6.5-V2-kmeans-pp] SOM weights initialized via k-means++ "
+                                    f"(samples={_km.get('n_samples_used')}, "
+                                    f"inertia={_km.get('inertia'):.4f})"
+                                )
+                        except Exception as _km_err:
+                            logger.warning(
+                                f"[V6.5-V2-kmeans-pp] init failed (non-fatal): {_km_err}"
+                            )
+
                         # Métricas
                         acc = kls.evaluate_classification()
                         accuracies_log.append({
@@ -2751,13 +2774,18 @@ def main() -> int:
         f"atingida: {conhecimento_result['meta_atingida']})"
     )
 
-    # Salva estados do modelo após CONHECIMENTO
+    # V6.5-V2-unified — Salva estado após CONHECIMENTO no MESMO arquivo
+    # unificado (v6_5_v2_model_states.pt). User requirement: "unir os
+    # estados do modelo de ambas as FASE1 e FASE2 para um estado contínuo
+    # em um único arquivo de treinamento".
+    # O campo _meta.phase = "end_of_fase_conhecimento" permite identificar
+    # que este estado é pós-FASE1 (pronto para iniciar FASE2).
     save_model_states_for_evaluation(
         kls=kls,
         reason="end_of_fase_conhecimento",
         step=conhecimento_result["n_steps"],
         total_samples=conhecimento_result["total_samples"],
-        output_path=BIGRU_ROOT / "v6_5_v2_model_states_after_conhecimento.pt",
+        output_path=MODEL_STATES_PATH,  # ARQUIVO UNIFICADO
     )
 
     # Aggressive cleanup entre fases
@@ -2797,7 +2825,10 @@ def main() -> int:
         #   (b) permitir que um processo separado (apenas FASE2) seja iniciado
         #       do zero apontando para o estado salvo da FASE1.
         logger.info("\n[V6.5-V2-metrics] Carregando estado do modelo da FASE1 (FASE2 uses FASE1 completed state)...")
-        fase1_state_path = BIGRU_ROOT / "v6_5_v2_model_states_after_conhecimento.pt"
+        # V6.5-V2-unified — Carrega estado unificado (FASE1+FASE2 no mesmo arquivo).
+        # User requirement: "LEMBRANDO que agora FASE1 e FASE2 estão treinadas
+        # no mesmo estado do modelo".
+        fase1_state_path = MODEL_STATES_PATH
         fase1_load_result = load_fase1_state_into_kls(kls, fase1_state_path)
 
         logger.info("\n[V6.5-V2] Iniciando FASE 2 — TREINAMENTO COM PUNIÇÃO...")
@@ -2916,9 +2947,9 @@ def main() -> int:
 
     # Copia arquivos relevantes para download/
     try:
+        # V6.5-V2-unified — Apenas MODEL_STATES_PATH (arquivo unificado)
         for src in [REPORT_PATH, USER_QUESTIONS_PATH, MODEL_STATES_PATH,
-                    V2_PHASES_EVAL_PATH, PREDICT_FIX_EVAL_PATH, ATTENTION_EVAL_PATH,
-                    BIGRU_ROOT / "v6_5_v2_model_states_after_conhecimento.pt"]:
+                    V2_PHASES_EVAL_PATH, PREDICT_FIX_EVAL_PATH, ATTENTION_EVAL_PATH]:
             if src.exists():
                 dst = DOWNLOAD_DIR / src.name
                 shutil.copy2(src, dst)
@@ -2975,9 +3006,9 @@ def main() -> int:
         # Inclui: v6_5_v2_model_states.pt, v6_5_v2_model_states_after_conhecimento.pt
         # Verifica tamanho ≤ 500MB (HF LFS free tier sem autenticar LFS).
         _MAX_HF_LFS_SIZE_BYTES = 500 * 1024 * 1024  # 500MB
+        # V6.5-V2-unified — Apenas UM arquivo de estado unificado.
         for pt_candidate in [
             MODEL_STATES_PATH,
-            BIGRU_ROOT / "v6_5_v2_model_states_after_conhecimento.pt",
         ]:
             if pt_candidate.exists():
                 pt_size = pt_candidate.stat().st_size
@@ -3117,6 +3148,8 @@ Updated: {datetime.now().isoformat()}
           f"({hf_upload_result.get('n_files', 0)} files)")
     print(f"  HF_TOKEN cleaned    : True (env + scripts)")
     print(f"  .pt files removed   : {len(pt_files_removed)} (ALL local .pt cleaned)")
+    print(f"  Unified state file  : {MODEL_STATES_PATH.name} (FASE1+FASE2 continuous)")
+    print(f"  k-means++ applied   : {getattr(kls.som, '_kmeans_pp_initialized', False)}")
     print(f"  Storage cleanup     : {final_storage_cleanup['n_files_removed']} files, "
           f"{final_storage_cleanup['mb_freed']:.1f}MB freed")
     print(f"  Final n_hypotheses  : {kls.n_hypotheses} (active={kls.hypothesis_ensemble.active_count})")

src/bigru_t/model/kohonen_learning_system.py

@@ -507,6 +507,138 @@ class KohonenSOM4D:
         # colapso de neurônios mais cedo e ajustar γ a tempo.
         self._auto_adjust_interval = 10             # ajusta γ a cada 10 updates
 
+        # V6.5-V2-kmeans-pp — flag para inicialização k-means++ deferida.
+        # User requirement: "inicialização com k-means++ sobre embeddings em
+        # vez de grid coords+ruído dos embeddings que saem do tokenizador
+        # para ambas as FASE1 e FASE2". Como no momento do __init__ ainda
+        # não temos dados, a init k-means++ é DEFERIDA: ela acontece na
+        # primeira chamada de init_weights_kmeans_pp(data_buffer) feita
+        # pelo KLS quando o buffer_4d tem >= 64 amostras.
+        self._kmeans_pp_initialized = False
+        self._kmeans_pp_min_samples = 64
+
+    # ======================================================================
+    # V6.5-V2-kmeans-pp — Inicialização k-means++ sobre embeddings
+    # User requirement: "inicialização com k-means++ sobre embeddings em
+    # vez de grid coords+ruído dos embeddings que saem do tokenizador
+    # para ambas as FASE1 e FASE2".
+    # Math (Arthur & Vassilvitskii 2007):
+    #   1. c_1 = data[índice aleatório]
+    #   2. Para c_2..c_N: escolhe c_i = data[j] com prob ∝ D(j)^2
+    #      onde D(j) = min_k ||x_j - c_k||^2
+    #   3. Após seeding, roda n_iter iterações de Lloyd para refinar centros.
+    # Vantagem: distribui pesos nas regiões de ALTA densidade dos dados,
+    # reduzindo dead neuron rate inicial.
+    # ======================================================================
+    def init_weights_kmeans_pp(
+        self,
+        data_buffer,
+        n_iter: int = 5,
+        random_seed=None,
+    ):
+        """Inicializa pesos do SOM via k-means++ (Arthur & Vassilvitskii 2007).
+
+        Args:
+            data_buffer: lista de tensores [4] — amostras do buffer_4d do KLS.
+            n_iter: número de iterações de Lloyd (default 5).
+            random_seed: seed para reprodutibilidade.
+
+        Returns:
+            Dict com: initialized, n_samples_used, n_neurons_assigned,
+            inertia (soma das dist^2 ao centro mais próximo).
+        """
+        if not data_buffer or len(data_buffer) < 8:
+            return {
+                "initialized": False,
+                "reason": f"insufficient_data ({len(data_buffer) if data_buffer else 0} < 8)",
+            }
+
+        if random_seed is not None:
+            g = torch.Generator().manual_seed(int(random_seed))
+        else:
+            g = None
+
+        with torch.no_grad():
+            try:
+                data = torch.stack(
+                    [v.detach().clone().float() if isinstance(v, torch.Tensor)
+                     else torch.tensor(v, dtype=torch.float)
+                     for v in data_buffer]
+                ).float()
+            except Exception:
+                return {"initialized": False, "reason": "stack_failed"}
+
+            data = torch.nan_to_num(data, nan=0.0, posinf=1.0, neginf=-1.0)
+            N = data.shape[0]
+            P = self.n_neurons
+
+            if N < P:
+                repeats = (P // N) + 1
+                data = data.repeat(repeats, 1)[:P * 4]
+                N = data.shape[0]
+
+            # ---- k-means++ seeding ----
+            if g is not None:
+                first_idx = int(torch.randint(0, N, (1,), generator=g).item())
+            else:
+                first_idx = int(torch.randint(0, N, (1,)).item())
+            centers = [data[first_idx].clone()]
+
+            for k_idx in range(1, P):
+                C = torch.stack(centers)
+                data_sq = (data * data).sum(dim=-1, keepdim=True)
+                C_sq = (C * C).sum(dim=-1, keepdim=True).t()
+                cross = data @ C.t()
+                dist_sq = data_sq + C_sq - 2.0 * cross
+                dist_sq = torch.clamp(dist_sq, min=0.0)
+                D_sq_min = dist_sq.min(dim=-1).values
+                D_sum = D_sq_min.sum().clamp(min=1e-12)
+                probs = D_sq_min / D_sum
+                if g is not None:
+                    new_idx = int(torch.multinomial(probs, 1, generator=g).item())
+                else:
+                    new_idx = int(torch.multinomial(probs, 1).item())
+                centers.append(data[new_idx].clone())
+
+            centers_tensor = torch.stack(centers)
+            centers_tensor = centers_tensor + 0.02 * torch.randn(P, 4)
+
+            # ---- Lloyd iterations (refinamento) ----
+            for it in range(n_iter):
+                data_sq = (data * data).sum(dim=-1, keepdim=True)
+                C_sq = (centers_tensor * centers_tensor).sum(dim=-1, keepdim=True).t()
+                cross = data @ centers_tensor.t()
+                dist_sq = data_sq + C_sq - 2.0 * cross
+                dist_sq = torch.clamp(dist_sq, min=0.0)
+                nearest = dist_sq.argmin(dim=-1)
+                for p in range(P):
+                    mask = (nearest == p)
+                    if mask.any():
+                        centers_tensor[p] = data[mask].mean(dim=0)
+
+            data_sq = (data * data).sum(dim=-1, keepdim=True)
+            C_sq = (centers_tensor * centers_tensor).sum(dim=-1, keepdim=True).t()
+            cross = data @ centers_tensor.t()
+            dist_sq = data_sq + C_sq - 2.0 * cross
+            dist_sq = torch.clamp(dist_sq, min=0.0)
+            inertia = float(dist_sq.min(dim=-1).values.sum().item())
+
+            perm = torch.randperm(P, generator=g)
+            centers_shuffled = centers_tensor[perm]
+            new_weights = centers_shuffled.view(self.I, self.J, self.K, self.L, 4).clone()
+            new_weights = torch.clamp(new_weights, -10.0, 10.0)
+            self.weights = new_weights
+            self._kmeans_pp_initialized = True
+
+            return {
+                "initialized": True,
+                "n_samples_used": int(N),
+                "n_neurons_assigned": int(P),
+                "n_lloyd_iters": int(n_iter),
+                "inertia": float(inertia),
+                "method": "kmeans++ (Arthur & Vassilvitskii 2007)",
+            }
+
     def _neighborhood(self, bmu_idx):
         """Vizinhança Gaussiana 4D: d² = Δi² + Δj² + Δk² + Δl²."""
         i, j, k, l = bmu_idx
@@ -671,20 +803,55 @@ class KohonenSOM4D:
                 except Exception:
                     buffer_tensor = None
 
-            # Itera sobre neurônios mortos e reinicializa
+            # V6.5-V2-kmeans-pp-revive — Reinicializa neurônios mortos usando
+            # estratégia k-means++ (max-min selection): em vez de amostrar um
+            # ponto aleatório do buffer, escolhe o ponto do buffer que está
+            # MAIS DISTANTE de todos os neurônios ativos atuais. Isto garante
+            # que os pesos revividos cubram regiões do espaço de entrada que
+            # não estavam sendo representadas, maximizando a diversidade
+            # topológica do SOM.
+            # User requirement: "reforçar auto_revive para reinicializar pesos
+            # dos neurônios mortos (não só boostar γ)".
             dead_indices = dead_mask.nonzero(as_tuple=False)
+            # Identifica neurônios ATIVOS (win_count > 0) para cálculo de distância
+            active_mask = self.bmu_win_count > 0
+            active_indices = active_mask.nonzero(as_tuple=False)
+            # Stack pesos ativos (centros atuais do SOM)
+            if active_indices.shape[0] > 0:
+                active_weights = self.weights[active_mask]  # (n_active, 4)
+            else:
+                active_weights = None
+
             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)
+                    if active_weights is not None and active_weights.shape[0] > 0:
+                        # k-means++ selection: ponto mais distante dos ativos
+                        # dist²[j, k] = ||buffer[j] - active[k]||²
+                        buf_sq = (buffer_tensor * buffer_tensor).sum(dim=-1, keepdim=True)  # (B, 1)
+                        act_sq = (active_weights * active_weights).sum(dim=-1, keepdim=True).t()  # (1, A)
+                        cross = buffer_tensor @ active_weights.t()  # (B, A)
+                        dist_sq = buf_sq + act_sq - 2.0 * cross
+                        dist_sq = torch.clamp(dist_sq, min=0.0)
+                        # D²(j) = min_k ||buf[j] - active[k]||²
+                        D_sq_min = dist_sq.min(dim=-1).values  # (B,)
+                        # Escolhe o ponto com maior D² (mais distante)
+                        sample_idx = int(torch.argmax(D_sq_min).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)
+                        # Adiciona o novo peso à lista de ativos para próxima iteração
+                        active_weights = torch.cat([active_weights, new_w.unsqueeze(0)], dim=0)
+                    else:
+                        # Sem ativos: amostra aleatória simples
+                        sample_idx = torch.randint(0, buffer_tensor.shape[0], (1,)).item()
+                        new_w = buffer_tensor[sample_idx].clone()
+                        new_w = new_w + 0.05 * torch.randn(4)
+                        # Inicia lista de ativos
+                        active_weights = new_w.unsqueeze(0).clone()
                 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
@@ -2931,8 +3098,30 @@ class KohonenLearningSystemV2(KohonenLearningSystem):
             return {"active": False, "reason": "empty_buffer"}
 
         import time as _time
+        import gc as _gc
         t0 = _time.time()
 
+        # V6.5-V2-oom-guard — Pré-check de memória antes de alocar tensores
+        # grandes (n_hyp * P * N * 4 bytes). Se memória livre < 2x estimado,
+        # trunca o buffer para evitar OOM-killer.
+        # User requirement: "o processo vem sendo morto OOM-kiler".
+        try:
+            import os as _os
+            # Estima uso: n_hyp * P * N * 4 bytes (float32) + overhead 50%
+            _est_bytes = int(self.n_hypotheses * self.som_neuron_count *
+                             len(buffer_4d) * 4 * 1.5)
+            _est_mb = _est_bytes / 1e6
+            # Se estimativa > 800MB, trunca buffer para últimos 64 samples
+            if _est_mb > 800 and len(buffer_4d) > 64:
+                _orig_n = len(buffer_4d)
+                buffer_4d = buffer_4d[-64:]
+                buffer_labels = buffer_labels[-64:]
+                # Log silently (não podemos usar logger aqui para evitar circular import)
+                print(f"[V6.5-V2-oom-guard] train_hypotheses: buffer truncated "
+                      f"{_orig_n}→64 (est. {_est_mb:.0f}MB > 800MB)")
+        except Exception:
+            pass  # Nunca deixa o pré-check quebrar o treino
+
         # Prepara dados
         data = torch.stack(buffer_4d).detach()  # (N, 4)
         labels = torch.tensor(buffer_labels, dtype=torch.float, device=data.device)
@@ -2948,102 +3137,117 @@ class KohonenLearningSystemV2(KohonenLearningSystem):
 
         self.hypothesis_ensemble.train()
         losses = []
+        _oom_truncated = False  # V6.5-V2-oom-guard: flag setada em caso de OOM
+        _oom_step = -1           # V6.5-V2-oom-guard: step onde OOM ocorreu
         # V6.5-V2-metrics-FIX: pré-computa data_norm_sq uma única vez (N, 1)
         # para reuso em todos os steps — evita recomputação redundante.
         data_norm_sq = (data * data).sum(dim=-1, keepdim=True).t()  # (1, N)
         labels_expanded = labels  # (N,)
 
         for step in range(self.hyp_train_steps):
-            self.hyp_optimizer.zero_grad()
-
-            # Ativação média como representação do estado do SOM
-            x_mean = som_activations.mean(dim=0, keepdim=True)  # (1, P_som)
-
-            # Gera deltas: (1, n_hypotheses, P)
-            deltas_stack = self.hypothesis_ensemble.forward_stacked(x_mean)
-            deltas_stack = self.delta_scale * deltas_stack  # escala
-
-            # V6.5-V2-metrics-FIX: Avaliação VETORIZADA de todas as hipóteses
-            # em paralelo (substitui loop que materializava 16 cópias do SOM).
-            # Memória: (n_hyp, P, N) em vez de 16 * (P + 2*P*N).
-            if self.classifier is not None and self.classifier_trained:
-                # deltas_stack: (1, n_hyp, P) → (n_hyp, P, 4) reshape
-                n_hyp = self.n_hypotheses
-                P_neurons = self.som_neuron_count
-                # som_weights_flat: (P, 4) detached
-                W_base = som_weights_flat.reshape(P_neurons, 4)  # (P, 4)
-                # delta_h: (n_hyp, P) → reshape para (n_hyp, P, 4)
-                deltas_3d = deltas_stack[0].reshape(n_hyp, P_neurons, 4)  # (n_hyp, P, 4)
-                # W_new[h, p, d] = W_base[p, d] + deltas_3d[h, p, d]
-                W_new = W_base.unsqueeze(0) + deltas_3d  # (n_hyp, P, 4) — broadcast
-                # dist²[h, p, n] = ||W_new[h, p] - data[n]||²
-                #                 = ||W_new[h, p]||² + ||data[n]||² - 2*W_new[h, p]·data[n]
-                W_new_norm_sq = (W_new * W_new).sum(dim=-1)  # (n_hyp, P)
-                # cross[h, p, n] = W_new[h, p] · data[n]
-                cross = torch.matmul(W_new, data.t())  # (n_hyp, P, N)
-                dist_sq = (
-                    W_new_norm_sq.unsqueeze(-1)  # (n_hyp, P, 1)
-                    + data_norm_sq  # (1, N) → broadcast (n_hyp, P, N)
-                    - 2.0 * cross
-                )  # (n_hyp, P, N)
-                dist_sq = torch.clamp(dist_sq, min=0.0)
-                # activations[h, n, p] = dist_sq[h, p, n]
-                activations = dist_sq.transpose(1, 2)  # (n_hyp, N, P)
-                # Classifier forward (congelado)
-                classifier_params_were_grad = [
-                    p.requires_grad for p in self.classifier.parameters()
-                ]
-                for p in self.classifier.parameters():
-                    p.requires_grad_(False)
-                try:
-                    logits = self.classifier(
-                        activations.reshape(n_hyp * len(data), P_neurons)
-                    ).reshape(n_hyp, len(data))  # (n_hyp, N)
-                    # BCE por hipótese, depois média
-                    loss_per_hyp = F.binary_cross_entropy_with_logits(
-                        logits,
-                        labels_expanded.unsqueeze(0).expand(n_hyp, -1),
-                        reduction='none',
-                    ).mean(dim=1)  # (n_hyp,)
-                    loss_total = loss_per_hyp.mean()
-                    # Regularização L2 sobre os deltas
-                    reg_loss = 0.01 * deltas_stack.norm()
-                    loss_total = loss_total + reg_loss
-                finally:
-                    for p, was_grad in zip(self.classifier.parameters(),
-                                           classifier_params_were_grad):
-                        p.requires_grad_(was_grad)
-            else:
-                # Fallback: minimizar norma do delta (regularização pura)
-                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()))
-
-            # V6.5-V2-metrics-FIX: libera tensores intermediários explicitamente
-            # para reduzir pico de memória entre steps.
-            del loss_total, deltas_stack
-            if 'W_new' in dir():
-                del W_new, cross, dist_sq, activations
-
-            # Atualiza a escala de delta (decai suavemente)
-            with torch.no_grad():
-                self.delta_scale.data = torch.clamp(
-                    self.delta_scale.data * 0.99, 0.001, 0.1
+            # V6.5-V2-oom-guard — captura OOM/RuntimeError por step.
+            # Em caso de OOM, interrompe o treino de hipóteses graciosamente.
+            try:
+                self.hyp_optimizer.zero_grad()
+
+                # Ativação média como representação do estado do SOM
+                x_mean = som_activations.mean(dim=0, keepdim=True)  # (1, P_som)
+
+                # Gera deltas: (1, n_hypotheses, P)
+                deltas_stack = self.hypothesis_ensemble.forward_stacked(x_mean)
+                deltas_stack = self.delta_scale * deltas_stack  # escala
+
+                # V6.5-V2-metrics-FIX: Avaliação VETORIZADA de todas as hipóteses
+                # em paralelo (substitui loop que materializava 16 cópias do SOM).
+                # Memória: (n_hyp, P, N) em vez de 16 * (P + 2*P*N).
+                if self.classifier is not None and self.classifier_trained:
+                    # deltas_stack: (1, n_hyp, P) → (n_hyp, P, 4) reshape
+                    n_hyp = self.n_hypotheses
+                    P_neurons = self.som_neuron_count
+                    # som_weights_flat: (P, 4) detached
+                    W_base = som_weights_flat.reshape(P_neurons, 4)  # (P, 4)
+                    # delta_h: (n_hyp, P) → reshape para (n_hyp, P, 4)
+                    deltas_3d = deltas_stack[0].reshape(n_hyp, P_neurons, 4)  # (n_hyp, P, 4)
+                    # W_new[h, p, d] = W_base[p, d] + deltas_3d[h, p, d]
+                    W_new = W_base.unsqueeze(0) + deltas_3d  # (n_hyp, P, 4) — broadcast
+                    # dist²[h, p, n] = ||W_new[h, p] - data[n]||²
+                    #                 = ||W_new[h, p]||² + ||data[n]||² - 2*W_new[h, p]·data[n]
+                    W_new_norm_sq = (W_new * W_new).sum(dim=-1)  # (n_hyp, P)
+                    # cross[h, p, n] = W_new[h, p] · data[n]
+                    cross = torch.matmul(W_new, data.t())  # (n_hyp, P, N)
+                    dist_sq = (
+                        W_new_norm_sq.unsqueeze(-1)  # (n_hyp, P, 1)
+                        + data_norm_sq  # (1, N) → broadcast (n_hyp, P, N)
+                        - 2.0 * cross
+                    )  # (n_hyp, P, N)
+                    dist_sq = torch.clamp(dist_sq, min=0.0)
+                    # activations[h, n, p] = dist_sq[h, p, n]
+                    activations = dist_sq.transpose(1, 2)  # (n_hyp, N, P)
+                    # Classifier forward (congelado)
+                    classifier_params_were_grad = [
+                        p.requires_grad for p in self.classifier.parameters()
+                    ]
+                    for p in self.classifier.parameters():
+                        p.requires_grad_(False)
+                    try:
+                        logits = self.classifier(
+                            activations.reshape(n_hyp * len(data), P_neurons)
+                        ).reshape(n_hyp, len(data))  # (n_hyp, N)
+                        # BCE por hipótese, depois média
+                        loss_per_hyp = F.binary_cross_entropy_with_logits(
+                            logits,
+                            labels_expanded.unsqueeze(0).expand(n_hyp, -1),
+                            reduction='none',
+                        ).mean(dim=1)  # (n_hyp,)
+                        loss_total = loss_per_hyp.mean()
+                        # Regularização L2 sobre os deltas
+                        reg_loss = 0.01 * deltas_stack.norm()
+                        loss_total = loss_total + reg_loss
+                    finally:
+                        for p, was_grad in zip(self.classifier.parameters(),
+                                               classifier_params_were_grad):
+                            p.requires_grad_(was_grad)
+                else:
+                    # Fallback: minimizar norma do delta (regularização pura)
+                    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()))
+
+                # V6.5-V2-metrics-FIX: libera tensores intermediários explicitamente
+                # para reduzir pico de memória entre steps.
+                del loss_total, deltas_stack
+                if 'W_new' in dir():
+                    del W_new, cross, dist_sq, activations
+
+                # Atualiza a escala de delta (decai suavemente)
+                with torch.no_grad():
+                    self.delta_scale.data = torch.clamp(
+                        self.delta_scale.data * 0.99, 0.001, 0.1
+                    )
+            except (RuntimeError, MemoryError) as _oom_err:
+                # V6.5-V2-oom-guard — OOM detectado durante o step.
+                # Interrompe o treino de hipóteses e retorna partial results.
+                _oom_truncated = True
+                _oom_step = step
+                try:
+                    _gc.collect()
+                except Exception:
+                    pass
+                break
 
         self.hypothesis_ensemble.eval()
         # V6.5-V2-metrics-FIX: libera som_activations e som_weights_flat
@@ -3063,6 +3267,9 @@ class KohonenLearningSystemV2(KohonenLearningSystem):
         result = {
             "active": True,
             "n_steps": self.hyp_train_steps,
+            "n_steps_executed": len(losses),
+            "oom_truncated": bool(_oom_truncated),
+            "oom_step": int(_oom_step),
             "n_hypotheses": self.n_hypotheses,
             "loss_initial": float(losses[0]) if losses else 0.0,
             "loss_final": loss_final_val,
@@ -3827,6 +4034,40 @@ class KohonenLearningSystemV2(KohonenLearningSystem):
     #   ou para N(0, 0.1) se buffer vazio. Isto acelera a diversificação
     #   quando o conscience mechanism sozinho não basta.
     # ------------------------------------------------------------------
+    def init_weights_kmeans_pp_if_ready(self):
+        """V6.5-V2-kmeans-pp - Chama init_weights_kmeans_pp no SOM se buffer >= 64.
+
+        Tenta uma unica vez durante o treino (idempotente via flag
+        _kmeans_pp_init_attempted). Se falhar (buffer pequeno, erro), retorna
+        silently e o SOM mantem a inicializacao grid coords+ruido original.
+
+        Returns:
+            Dict com status da inicializacao.
+        """
+        if getattr(self, "_kmeans_pp_init_attempted", False):
+            return {"initialized": False, "reason": "already_attempted"}
+        self._kmeans_pp_init_attempted = True
+
+        if len(self.buffer_4d) < self.som._kmeans_pp_min_samples:
+            return {
+                "initialized": False,
+                "reason": f"buffer_too_small ({len(self.buffer_4d)} < {self.som._kmeans_pp_min_samples})",
+            }
+        try:
+            result = self.som.init_weights_kmeans_pp(
+                data_buffer=self.buffer_4d,
+                n_iter=5,
+                random_seed=42,
+            )
+            if result.get("initialized"):
+                self.som.bmu_win_count.zero_()
+                target_p = 1.0 / self.som.n_neurons
+                self.som.win_frequency.fill_(target_p)
+                self.som._recent_bmu_flat.clear()
+            return result
+        except Exception as e:
+            return {"initialized": False, "reason": f"error: {e}"}
+
     def revive_dead_neurons(
         self,
         dead_threshold: int = 0,

v6_5_v2_attention_eval.json

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

v6_5_v2_model_states.pt

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

v6_5_v2_predict_fix_eval.json

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

v6_5_v2_report.json

@@ -0,0 +1,309 @@
+{
+  "version": "V6.5-V2",
+  "timestamp": "2026-08-09T14:25:12.703041",
+  "config": {
+    "som_grid": [
+      6,
+      6,
+      6,
+      4
+    ],
+    "n_neurons": 864,
+    "hidden_dim": 1024,
+    "vocab_size": 16384,
+    "n_hypotheses": 16,
+    "n_trials": 3,
+    "hyp_train_steps": 30,
+    "stream_batch_size": 100,
+    "meta_conhecimento": 8000,
+    "meta_punicão": 2000,
+    "conhecimento_datasets": [
+      "dominguesm/restore-punctuation-ptbr-dataset",
+      "carolina-c4ai/corpus-carolina",
+      "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1",
+      "dominguesm/Canarim-Instruct-PTBR-Dataset",
+      "adalbertojunior/punctuation-ptbr",
+      "iara-project/news-articles-ptbr-dataset",
+      "manoela/noticias_ptbr",
+      "BrunoN-Dev/corpus-ptbr-v1"
+    ],
+    "punicão_dataset": "BrunoN-Dev/corpus-ptbr-v1"
+  },
+  "xeon_status": {
+    "version": "V6",
+    "physical_cores": 2,
+    "env": {
+      "MKL_ENABLE_INSTRUCTIONS": "AVX512",
+      "MKL_NUM_THREADS": "2",
+      "OMP_NUM_THREADS": "2",
+      "MKL_DYNAMIC": "FALSE",
+      "DNNL_PRIMITIVE_CACHE_CAPACITY": "1024",
+      "ONEDNN_MAX_CPU_ISA": "AMX_INT8",
+      "KMP_AFFINITY": "granularity=fine,compact,1,0",
+      "KMP_BLOCKTIME": "1"
+    },
+    "avx512": {
+      "supported": true,
+      "desc": "AVX512_VNNI (full INT8 acceleration)"
+    },
+    "amx": {
+      "supported": true,
+      "desc": "AMX (tile + int8 + bf16) — full AMX acceleration"
+    },
+    "ipex_available": false,
+    "init_done": true
+  },
+  "fp16_benchmark": {
+    "best_time_ms": 92.64165200011121,
+    "avg_time_ms": 92.91077149998728,
+    "best_tflops": 1.3816679348490715,
+    "avg_tflops": 1.3776658823677677,
+    "matrix_size": 4000.0
+  },
+  "v2_verification": {
+    "checks": {
+      "v2_instantiation": {
+        "status": "PASS",
+        "details": "n_hyp=4/8 (active=4), n_trials=2, delta_scale=0.0100"
+      },
+      "predict_dynamic_labels": {
+        "status": "PASS",
+        "details": "predict returned: negative_class (dynamic, not hardcoded)"
+      },
+      "process_batch_v2_conhecimento": {
+        "status": "PASS",
+        "details": "phase=CONHECIMENTO, action=none"
+      },
+      "v2_methods_exist": {
+        "status": "PASS",
+        "details": "train_hypotheses, select_best_delta, apply_best_delta_and_consolidate, process_batch_v2, get_v2_metrics"
+      }
+    },
+    "n_pass": 4,
+    "n_fail": 0,
+    "all_pass": true
+  },
+  "fase_1_conhecimento_summary": {
+    "total_samples": 8000,
+    "meta_atingida": true,
+    "elapsed_s": 529.4711573123932,
+    "storage_critical_stopped": false
+  },
+  "fase_2_punicão_summary": {
+    "total_samples": 2000,
+    "meta_atingida": true,
+    "elapsed_s": 571.2624096870422,
+    "punishment_events": 76,
+    "hypotheses_trainings": 38,
+    "delta_applications": 38,
+    "skipped": false
+  },
+  "attention_eval_summary": {
+    "active": true,
+    "logic_functional": true,
+    "n_calls": 10000,
+    "assessment": "PASS"
+  },
+  "predict_fix_summary": {
+    "n_returns_gato": 0,
+    "n_returns_cachorro": 0,
+    "n_returns_registry_label": 6,
+    "n_returns_default_label": 0,
+    "hardcoded_bug_present": false,
+    "predict_fix_verified": true
+  },
+  "user_questions_summary": {
+    "n_with_answer": 3,
+    "n_with_think": 0,
+    "answer_rate": 1.0,
+    "think_rate": 0.0,
+    "avg_latency_ms": 4.942417144775391,
+    "avg_reasoning_length": 69.0
+  },
+  "model_states_saved_to": "/home/z/my-project/BiGRU_T_version/v6_5_v2_model_states.pt",
+  "save_info": {
+    "saved": true,
+    "path": "/home/z/my-project/BiGRU_T_version/v6_5_v2_model_states.pt",
+    "size_mb": 220.157236,
+    "size_gb": 0.2050374038517475,
+    "size_status": "OK",
+    "size_within_1gb_limit": true,
+    "reason": "end_of_training_v2",
+    "step": 700,
+    "total_samples": 10000,
+    "n_tensors": 7,
+    "n_buffer_tail": 64
+  },
+  "final_v2_metrics": {
+    "version": "V2-dynamic",
+    "n_hypotheses": 4,
+    "n_hypotheses_active": 4,
+    "max_n_hypotheses": 32,
+    "n_trials": 6,
+    "hyp_train_steps": 80,
+    "hyp_lr": 0.0001,
+    "delta_scale": 0.0010000000474974513,
+    "n_generators": 32,
+    "punishment_count": 0,
+    "success_count": 0,
+    "training_ready": false,
+    "classifier_trained": true,
+    "ewc_reference_set": true,
+    "buffer_size": 128,
+    "total_hyp_steps_executed": 2670,
+    "n_train_hyp_calls": 38,
+    "dynamic_adaptation": {
+      "loss_history_len": 8,
+      "loss_stats": {
+        "slope": 0.020730994996570405,
+        "volatility": 0.09847807385506234,
+        "mean": 0.6678446382284164,
+        "std": 0.06576805360716538,
+        "n": 8
+      },
+      "punishment_rate": 1.0,
+      "punishment_window_size": 12,
+      "n_adaptations": 20,
+      "limits": {
+        "min_n_hypotheses": 4,
+        "max_n_hypotheses": 32,
+        "min_n_trials": 1,
+        "max_n_trials": 6,
+        "min_hyp_train_steps": 10,
+        "max_hyp_train_steps": 80
+      },
+      "last_5_adaptations": [
+        {
+          "trigger": "punishment",
+          "step": 71,
+          "before": {
+            "n_hypotheses": 4,
+            "n_trials": 6,
+            "hyp_train_steps": 55
+          },
+          "after": {
+            "n_hypotheses": 4,
+            "n_trials": 6,
+            "hyp_train_steps": 60
+          },
+          "adapted": true,
+          "rules_fired": [
+            "steps+5 (slope=0.01182 → 60)"
+          ],
+          "loss_stats": {
+            "slope": 0.011820448296410697,
+            "volatility": 0.10509967848483093,
+            "mean": 0.6714299917221069,
+            "std": 0.07056707625506613,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        },
+        {
+          "trigger": "auto",
+          "step": 72,
+          "before": {
+            "n_hypotheses": 4,
+            "n_trials": 6,
+            "hyp_train_steps": 60
+          },
+          "after": {
+            "n_hypotheses": 4,
+            "n_trials": 6,
+            "hyp_train_steps": 65
+          },
+          "adapted": true,
+          "rules_fired": [
+            "steps+5 (slope=0.01214 → 65)"
+          ],
+          "loss_stats": {
+            "slope": 0.01214205367224557,
+            "volatility": 0.10464130233226861,
+            "mean": 0.6752422899007797,
+            "std": 0.07065823260504085,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        },
+        {
+          "trigger": "punishment",
+          "step": 73,
+          "before": {
+            "n_hypotheses": 4,
+            "n_trials": 6,
+            "hyp_train_steps": 65
+          },
+          "after": {
+            "n_hypotheses": 4,
+            "n_trials": 6,
+            "hyp_train_steps": 70
+          },
+          "adapted": true,
+          "rules_fired": [
+            "steps+5 (slope=0.01214 → 70)"
+          ],
+          "loss_stats": {
+            "slope": 0.01214205367224557,
+            "volatility": 0.10464130233226861,
+            "mean": 0.6752422899007797,
+            "std": 0.07065823260504085,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        },
+        {
+          "trigger": "auto",
+          "step": 74,
+          "before": {
+            "n_hypotheses": 4,
+            "n_trials": 6,
+            "hyp_train_steps": 70
+          },
+          "after": {
+            "n_hypotheses": 4,
+            "n_trials": 6,
+            "hyp_train_steps": 75
+          },
+          "adapted": true,
+          "rules_fired": [
+            "steps+5 (slope=0.02073 → 75)"
+          ],
+          "loss_stats": {
+            "slope": 0.020730994996570405,
+            "volatility": 0.09847807385506234,
+            "mean": 0.6678446382284164,
+            "std": 0.06576805360716538,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        },
+        {
+          "trigger": "punishment",
+          "step": 75,
+          "before": {
+            "n_hypotheses": 4,
+            "n_trials": 6,
+            "hyp_train_steps": 75
+          },
+          "after": {
+            "n_hypotheses": 4,
+            "n_trials": 6,
+            "hyp_train_steps": 80
+          },
+          "adapted": true,
+          "rules_fired": [
+            "steps+5 (slope=0.02073 → 80)"
+          ],
+          "loss_stats": {
+            "slope": 0.020730994996570405,
+            "volatility": 0.09847807385506234,
+            "mean": 0.6678446382284164,
+            "std": 0.06576805360716538,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        }
+      ]
+    }
+  }
+}

v6_5_v2_user_questions.json

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