KHTST v7 — RETREINO OBSERVADO: estados antigos apagados; treino do zero com monitor de RAM integral (Agente Engenheiro); métricas de tests/test_khtst_v6.py comparadas com o treino anterior; gráficos de desempenho publicados no card

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+graficos/graf_ram.png filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Projeto KHTST
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,104 @@
+# KHTST — modelo multimodal PT-BR (v8)
+
+KHTST é a evolução do projeto AURORA (renomeação integral AURORA → KHTST,
+pedido do projeto) — um modelo multimodal compacto para PT-BR com
+roteamento por S-SOM, punição SGDR, punição de novidade restrita a empates
+de Voronoi, controle Reward/Punishment/Penalty (RPP) e **janela de contexto
+256K tokens** (compressão indexada, doc 13).
+
+**14,89M parâmetros · vocab 16384 · 9 tarefas (lm/noticia/pontuacao/
+instrucao/tts/vqa/ocr/imagem_caption/asr) · encoders imagem/áudio/vídeo.**
+
+> ⚠️ **STATUS DO GATE DE QUALIDADE (honesto): FALHOU.**
+> Nesta corrida, o KHTST NÃO superou nem empatou o AURORA nas métricas
+> (`ppl_lm` 2542,11 vs 17,09 do baseline publicado). Conforme a regra do
+> projeto, **os estados (pesos) do modelo NÃO foram publicados** — este
+> repositório publica o CÓDIGO completo (scripts de alta qualidade,
+> provas matemáticas e evidências) e o diagnóstico que corrige a causa
+> raiz. Um retreino limpo com a política corrigida está pronto para
+> executar (est. ~3,3 h; o teto de 5 h da sessão impediu refazer).
+
+## O que há de novo no v8 (itens a–j, com provas em `docs/matematica/19`)
+
+| item | melhoria | onde | prova |
+|---|---|---|---|
+| a | micro buffers anulares em redes recorrentes (0 alocação/passo no decode) | `percepcao/microunidades.py` | Teo 19.6 |
+| b | canal adhoc I/O + **stop/continue** durante solicitações ativas | `servico/adhoc.py`, `scripts/09_teste_item_b.py` | Teos 19.14–19.16 |
+| c | quantização 8-bit seletiva matematicamente vantajosa (torchao/bnb) | `quanta/quantizacao.py` §10 | Teo 19.18 |
+| d | anti-vanishing: Leaky ReLU adaptativa + pesos de árvore bidirecionais + skip neutro + BatchNorm | `microunidades.py` | Teos 19.7–19.10 |
+| e | map-reduce `torch.vmap`/`sum`/`mean` nos experts MoE | `percepcao/moe.py` | Teo 19.11 (diff 0,0) |
+| f | atenção **árvore bidirecional fora de ordem**; raio_janela e kv_max **×4** (128/2048); `AtencaoCabecas` | `percepcao/atencao.py` | Teos 19.1–19.4 |
+| g | MoE **2 encoders + 4 decoders** fora de ordem agrupável/desagrupável | `percepcao/moe.py` | Teos 19.12–19.13 |
+| h | gestão de memória RAM/armazenamento com limiar adaptativo | `telemetria/gestor_memoria.py` | Teo 19.17 |
+| i | testes em dados reais → 6 bugs latentes do v7 corrigidos (ver abaixo) | vários | — |
+| j | parâmetros auto-ajustáveis matematicamente + provas conjuntas | `treino/treinador.py` | Teos 19.26–19.27 |
+
+**ViT (evolução de `video.py`/`blocos.py`/`microunidades.py`):** Token
+Merging (ToMe) com casamento bipartido único e auto-ajuste da fração de
+fusão; **LRA-QViT** com RB-LRA, WADS e STE — ramificações **1-bit ∥ 4-bit
+em paralelo** detectando **direção vetorial** da iluminação (unitária) e
+**intensidade**, mapas 2-D de contorno/área; critério de vantagem da
+difusão (`vantagem_difusao`). Provas: Teos 19.19–19.24, 19.28.
+
+**Cython + C/C++:** núcleos `acelerado/nucleos.pyx` (Kohonen sequencial +
+entropia/punição) com semântica sequencial exata (Teo 19.25) — **speedup
+medido 17,89×**, fallback puro-torch idêntico.
+
+## Verificações (tudo verde)
+
+- `tests/test_khtst.py` … `test_khtst_v6.py` (herdadas): 25+36+37+29+48 ✓
+- `tests/test_khtst_v7.py` (nova, Teoremas 19.x): **44 ✓ · 0 ✗**
+- **Item (b) no modelo treinado: APROVADO** — 4 requisições recebidas
+  ANTES da 1ª resposta, processamento serial, stop (cancelamento) e
+  pause→continue honrados em ≤ 1 passo (`teste_item_b_v8.json`).
+
+## Treino desta corrida (dentro do teto de 5 h)
+
+| métrica | valor |
+|---|---|
+| passos | 3192 (8 épocas + DPO 93 passos acc 1,0 + consolidação SOM) |
+| tempo acumulado | **3,98 h** (teto 5 h respeitado; sem treino em background) |
+| RAM | pico 3358 MB · média 2524 MB · mín 429 MB (5919 amostras) |
+| corpus | 3548 registros PT-BR reais (18 fontes HF; 987 multimodais) |
+| gate de não-regressão | **FALHOU** — `ppl_lm` 2542,11 vs 17,09 (regressão registrada em `comparacao_treino_v8.json`) |
+
+## Diagnóstico da regressão (item i — bugs latentes do v7 encontrados e corrigidos)
+
+1. **Reinícios SGDR espúrios**: 16 warm restarts em 2075 passos — o
+   cooldown (`janela/2`) era menor que o próprio ciclo (T₀) e a cláusula 1
+   da eq. 9.3 disparava no passo 9 (sem guarda de aquecimento). O lr passou
+   43% do tempo no piso ⇒ sub-convergência. **Correção** (`treino/punicao.py`):
+   cooldown = T₀ e guarda `passo ≤ warmup + T₀` para AMBAS as cláusulas.
+2. **Gate de não-regressão inoperante no v7**: as chaves do gate eram
+   `ppl_valid/perda_valid`, mas as métricas reais são `ppl_lm/perda_media_final`
+   — o "aprovado" do v7 nunca verificou o ppl. **Correção** (`scripts/08`):
+   chaves corretas ⇒ o gate agora reprova de verdade (como acima).
+3. Outros: einsum de decode `bhte→bhe` (quebrava TODA geração com cache no v7),
+   typo `perla→perda`, `NameError` no script 07, clamp de rótulos do S-SOM
+   (n_classes=8 × 9 tarefas), resumos v4/v6/v7 divergentes entre scripts.
+
+## Reprodução
+
+```bash
+python3 scripts/01_verificar_ambiente.py
+python3 scripts/02_coletar_corpus.py          # retomável por fonte
+python3 scripts/03_treinar_tokenizador.py
+python3 scripts/04_treinar.py --orcamento 470 --teto_horas 5.0
+python3 scripts/05_avaliar.py --sem_difusao
+python3 scripts/09_teste_item_b.py            # item (b) com o modelo real
+python3 scripts/08_graficos_card.py           # gráficos + gate
+python3 scripts/06_publicar_hf.py             # commit único (gate bloqueia estados)
+```
+
+## Estrutura
+
+`src/khtst/` — núcleo, percepção (atenção/microunidades/moe/vit_lra),
+memória (S-SOM + 8 variantes + janela 256K), treino (4 fases + RPP + SGDR),
+servico (canal adhoc), quanta (8-bit + STE), telemetria (hub + gestor de
+memória), qualidade (Agente Engenheiro), acelerado (Cython+C).
+`docs/matematica/00–19` — fundamentos, teoremas e provas.
+`graficos/` — desempenho desta corrida (apenas no card).
+
+## Licença
+
+MIT (herdada do projeto).

avaliacao_v7.json

@@ -0,0 +1,938 @@
+{
+  "estado": "fase-som",
+  "roteador_ssom": {
+    "amostras": 1536,
+    "pronto": true,
+    "lambda_rota": 0.35,
+    "gamma_empate": 0.15,
+    "drift_codebook": 0.0,
+    "conf_media": 0.4917,
+    "frac_rotas_ativas": 0.5312,
+    "k": 24,
+    "taxa_ativos": 1.0
+  },
+  "perdas_tarefa": {
+    "lm": {
+      "treinado": 2.8384029467900596,
+      "aleatorio": 9.732619444529215
+    },
+    "noticia": {
+      "treinado": 2.5535371700922647,
+      "aleatorio": 9.723073641459147
+    },
+    "instrucao": {
+      "treinado": 2.035900592803955,
+      "aleatorio": 9.758591492970785
+    },
+    "pontuacao": {
+      "treinado": 2.648297905921936,
+      "aleatorio": 9.727588017781576
+    },
+    "imagem_caption": {
+      "treinado": 2.127371827761332,
+      "aleatorio": 9.717129548390707
+    },
+    "vqa": {
+      "treinado": 2.177152613798777,
+      "aleatorio": 9.693151950836182
+    },
+    "ocr": {
+      "treinado": 1.418007344007492,
+      "aleatorio": 9.757900714874268
+    },
+    "asr": {
+      "treinado": 2.1221489111582437,
+      "aleatorio": 9.733868916829428
+    },
+    "tts": {
+      "treinado": 1.675029953320821,
+      "aleatorio": 9.691224416097006
+    }
+  },
+  "ppl_lm": 17.088452564794597,
+  "ppl_lm_aleatorio": 16858.65484439469,
+  "moe_uso_por_tarefa": {
+    "lm": [
+      {
+        "experts_top": [
+          5,
+          4
+        ],
+        "grupo_top": [
+          2,
+          2
+        ]
+      },
+      {
+        "experts_top": [
+          0,
+          1
+        ],
+        "grupo_top": [
+          0,
+          0
+        ]
+      }
+    ],
+    "vqa": [
+      {
+        "experts_top": [
+          2,
+          3
+        ],
+        "grupo_top": [
+          1,
+          1
+        ]
+      },
+      {
+        "experts_top": [
+          5,
+          4
+        ],
+        "grupo_top": [
+          2,
+          2
+        ]
+      }
+    ],
+    "ocr": [
+      {
+        "experts_top": [
+          2,
+          3
+        ],
+        "grupo_top": [
+          1,
+          1
+        ]
+      },
+      {
+        "experts_top": [
+          5,
+          4
+        ],
+        "grupo_top": [
+          2,
+          2
+        ]
+      }
+    ],
+    "asr": [
+      {
+        "experts_top": [
+          0,
+          1
+        ],
+        "grupo_top": [
+          0,
+          0
+        ]
+      },
+      {
+        "experts_top": [
+          2,
+          3
+        ],
+        "grupo_top": [
+          1,
+          1
+        ]
+      }
+    ],
+    "tts": [
+      {
+        "experts_top": [
+          5,
+          4
+        ],
+        "grupo_top": [
+          2,
+          2
+        ]
+      },
+      {
+        "experts_top": [
+          0,
+          1
+        ],
+        "grupo_top": [
+          0,
+          0
+        ]
+      }
+    ]
+  },
+  "mtp": {
+    "alphas": [
+      0.9997844099998474,
+      0.00021563710470218211
+    ],
+    "per_cabeca": [
+      2.9869613647460938,
+      10.111918449401855
+    ],
+    "entropia": 0.00203594658523798,
+    "termos_ce": 0.0
+  },
+  "w8a8_delta": 0.0011706352233886719,
+  "som_treinado": {
+    "variante_ativa": "cpn",
+    "variantes": {
+      "som": {
+        "k": 24,
+        "taxa_ativos": 1.0,
+        "resemeados": 24,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "gg": {
+        "k": 4,
+        "taxa_ativos": 1.0,
+        "resemeados": 4,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "gcs": {
+        "k": 3,
+        "arestas": 3,
+        "eq_treino": 88415.8203125,
+        "atingiu_alvo": true
+      },
+      "gsom": {
+        "k": 29,
+        "gt": 1.05,
+        "erro_medio": 0.0,
+        "atingiu_alvo": true
+      },
+      "hsom": {},
+      "tkm": {
+        "k": 32,
+        "taxa_ativos": 1.0,
+        "resemeados": 32,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "rsom": {
+        "k": 32,
+        "taxa_ativos": 1.0,
+        "resemeados": 32,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "cpn": {},
+      "ssom": {
+        "erro": "IndexError: index 8 is out of bounds for dimension 0 with size 8"
+      }
+    },
+    "roteador": {
+      "amostras": 1586,
+      "pronto": true,
+      "lambda_rota": 0.35,
+      "gamma_empate": 0.15,
+      "drift_codebook": 0.032477,
+      "conf_media": 0.0,
+      "frac_rotas_ativas": 0.0,
+      "k": 24,
+      "taxa_ativos": 1.0
+    },
+    "invariante_sem_orfaos": true,
+    "orfaos_por_variante": {
+      "som": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "gg": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "gcs": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "gsom": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "hsom": {
+        "orfaos": 0,
+        "relocados": 0
+      },
+      "tkm": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "rsom": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "cpn": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "ssom": {
+        "orfaos": 0,
+        "relocados": 23,
+        "taxa_ativos": 1.0
+      }
+    }
+  },
+  "som_eq_fresco": {
+    "som": {
+      "taxa_ativos": 1.0,
+      "eq": 75.31108856201172
+    },
+    "gg": {
+      "taxa_ativos": 1.0,
+      "eq": 144.36021423339844
+    },
+    "gcs": {
+      "taxa_ativos": 1.0,
+      "eq": 160.38645935058594
+    },
+    "gsom": {
+      "taxa_ativos": 1.0,
+      "eq": 130.51382446289062
+    },
+    "tkm": {
+      "taxa_ativos": 1.0,
+      "eq": 72.5010757446289
+    },
+    "rsom": {
+      "taxa_ativos": 1.0,
+      "eq": 75.71780395507812
+    },
+    "ssom": {
+      "taxa_ativos": 1.0,
+      "eq": 78.7991714477539
+    }
+  },
+  "geracao": {
+    "sem_punicao": "ricos a a a a Atualadawaficados novo 75 cada motivação o choque o clima inédentpresenta competimes tipo individual-sucedidos observador",
+    "com_punicao": " NaNTde a testevem trromcada 360 Bat que globais lou topo atingmadas atadado desa Emb 89 con badminton dizie sua simples doenças na"
+  },
+  "microunidades": {
+    "lm": [
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp"
+        ],
+        "alpha_medio": [
+          0.2641,
+          0.305,
+          0.4309
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          0.5519,
+          0.1535,
+          0.1445,
+          0.1501
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          0.2203,
+          0.2562,
+          0.2834,
+          0.2401
+        ],
+        "passos_rec": 2
+      }
+    ],
+    "vqa": [
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp"
+        ],
+        "alpha_medio": [
+          0.0647,
+          0.2521,
+          0.6833
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          0.2515,
+          0.2591,
+          0.2497,
+          0.2398
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          0.0645,
+          0.1988,
+          0.4256,
+          0.311
+        ],
+        "passos_rec": 2
+      }
+    ],
+    "asr": [
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp"
+        ],
+        "alpha_medio": [
+          0.2777,
+          0.3308,
+          0.3916
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          0.5948,
+          0.1387,
+          0.1316,
+          0.1348
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          0.1736,
+          0.2893,
+          0.2814,
+          0.2557
+        ],
+        "passos_rec": 2
+      }
+    ],
+    "instrucao": [
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp"
+        ],
+        "alpha_medio": [
+          0.1276,
+          0.2803,
+          0.5922
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          0.353,
+          0.2125,
+          0.2194,
+          0.2151
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          0.0723,
+          0.2226,
+          0.4016,
+          0.3036
+        ],
+        "passos_rec": 2
+      }
+    ]
+  },
+  "treino_prs_v8": {
+    "trust": 0.4091,
+    "tau": 0.55736,
+    "clip": 3.2906,
+    "boost": 1.0,
+    "streak": 0,
+    "ciclos_sgdr": 0,
+    "recompensa_acum": 17.593,
+    "beta_min_relativo": 2.0
+  },
+  "treino_confianca": {
+    "h_ema": 0.6650000214576721,
+    "ece": 0.3813131313131314,
+    "posterior_media": 0.32673267326732675,
+    "bernstein": [
+      0.176243817077732,
+      0.4772215294569215
+    ]
+  },
+  "treino_memoria": {
+    "slots": 25,
+    "capacidade": 64,
+    "escritas": 25,
+    "rejeitadas_confianca": 0,
+    "hit_rate": 1.0,
+    "comprimidos": 0,
+    "entropia_codebook": 1.4736544073912228e-07,
+    "perda_vq": null,
+    "violacoes_contrato": 0,
+    "economia_bits_por_slot": 0.9990234375
+  },
+  "treino_crescimento": [],
+  "memoria_execucao": {
+    "slots": 32,
+    "capacidade": 32,
+    "escritas": 45,
+    "rejeitadas_confianca": 0,
+    "hit_rate": 1.0,
+    "comprimidos": 32,
+    "entropia_codebook": 3.5029096603393555,
+    "perda_vq": "tensor(7.0846)",
+    "violacoes_contrato": 0,
+    "economia_bits_por_slot": 0.9990234375,
+    "escritas_aceitas": 45,
+    "consultas_com_acerto": 15,
+    "comprimidos_agora": 32
+  },
+  "curva_epocas": [
+    {
+      "epoca": 0,
+      "perda_media": 4.501659254233043,
+      "ppl_lm": 116.51917431950382
+    },
+    {
+      "epoca": 1,
+      "perda_media": 2.1522662341594696,
+      "ppl_lm": 20.32702512440419
+    },
+    {
+      "epoca": 2,
+      "perda_media": 1.628365287516499,
+      "ppl_lm": 6.841325508316532
+    },
+    {
+      "epoca": 3,
+      "perda_media": 1.5996007979906435,
+      "ppl_lm": 6.208188231846149
+    },
+    {
+      "epoca": 4,
+      "perda_media": 1.4905521827482286,
+      "ppl_lm": 5.169895857934865
+    },
+    {
+      "epoca": 5,
+      "perda_media": 0.9951962381601334,
+      "ppl_lm": 3.663949358479845
+    },
+    {
+      "epoca": 5,
+      "perda_media": 0.78661770003876,
+      "ppl_lm": 2.2905761511962
+    }
+  ],
+  "coerencia": {
+    "corpus_25pct": {
+      "n_registros": 887,
+      "repeticao_pct": 46.32,
+      "ancoragem_bigramas": 0.0,
+      "entropia_logits": 3.0155
+    },
+    "corpus_50pct": {
+      "n_registros": 1774,
+      "repeticao_pct": 63.97,
+      "ancoragem_bigramas": 0.0071,
+      "entropia_logits": 3.0155
+    },
+    "corpus_100pct": {
+      "n_registros": 3548,
+      "repeticao_pct": 52.94,
+      "ancoragem_bigramas": 0.0,
+      "entropia_logits": 3.0155
+    },
+    "amostras": [
+      " corpos a na china oran melhorar incêndiocas tenha controlaroumentos tradicional ideias tr 26un agachamentos fornecer em meadosvosvosÉ pela ",
+      " afastados dança melhorar sexove por fatoresun agachamentosense em bicicleta retorno Isso cargo de a a na Califórnia tor Os benefícios passa",
+      " eie Este comJánas tipo passa ritmo tropical02 de",
+      ""
+    ]
+  },
+  "clip_score": {
+    "clip_real": -0.1604,
+    "clip_controle": -0.1702,
+    "margem": 0.0098,
+    "n": 32
+  },
+  "itm": {
+    "acuracia": 0.5,
+    "f1": 0.0,
+    "n": 16,
+    "tp": 0,
+    "fp": 0,
+    "fn": 8
+  },
+  "ppl_visual": {
+    "ppl_visual": 1.16,
+    "n": 192,
+    "codigos_distintos": 8
+  },
+  "ppl_multimodal": {
+    "ppl_mm": 9.41,
+    "ce_mm": 2.2417,
+    "n": 2733
+  },
+  "geracao_metricas": {
+    "medias": {
+      "bleu": 0.0,
+      "rouge_l": 0.0149,
+      "meteor": 0.0,
+      "cider": 0.0001
+    },
+    "n": 12,
+    "amostras": [
+      {
+        "hipotese": " a a a sombra levando levando ao emn19 indes incêndio",
+        "ref": "Na foto podemos ver um homem centralizado na imagem, posicio",
+        "bleu": 0.0,
+        "rouge_l": 0.023288,
+        "meteor": 0.0,
+        "cider": 0.0
+      },
+      {
+        "hipotese": " a gordura levando sociedade formação ajudar tropicalgou como pode levar sozinha",
+        "ref": "Na foto podemos ver duas pessoas sobre uma prancha de stand ",
+        "bleu": 0.0,
+        "rouge_l": 0.014975,
+        "meteor": 0.0,
+        "cider": 5.8e-05
+      },
+      {
+        "hipotese": "",
+        "ref": "Na foto podemos ver cinco pessoas reunidas ao redor de uma c",
+        "bleu": 0.0,
+        "rouge_l": 0.0,
+        "meteor": 0.0,
+        "cider": 0.0
+      },
+      {
+        "hipotese": " trânsito PL rastre!1540 conelos a a competiçãodam várias United físicoifúvemerc",
+        "ref": "Na imagem podemos ver um homem usando uma jaqueta jeans de m",
+        "bleu": 0.0,
+        "rouge_l": 0.018564,
+        "meteor": 0.0,
+        "cider": 0.0
+      }
+    ]
+  },
+  "benchmarks": {
+    "mmmu": {
+      "benchmark": "MMMU-proxy-PT",
+      "n": 30,
+      "acuracia": 0.0,
+      "acertos": 0,
+      "distribuicao": {
+        "∅": 27,
+        "A": 3
+      },
+      "acaso": 0.25,
+      "rotulo": "proxy em escala reduzida"
+    },
+    "mme": {
+      "benchmark": "MME-proxy-PT",
+      "n": 15,
+      "acc": 0.0,
+      "acc_mais": 0.0,
+      "score_mme": 0.0,
+      "rotulo": "proxy em escala reduzida"
+    },
+    "mathvista": {
+      "benchmark": "MathVista-proxy-PT",
+      "n": 2,
+      "acuracia": 0.0,
+      "acertos": 0,
+      "rotulo": "proxy em escala reduzida"
+    }
+  },
+  "som_expandido": {
+    "som": {
+      "k": 24,
+      "qe": 59.763092,
+      "te": 0.980469,
+      "distorcao": 4559.125,
+      "sigma0": 3.0,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 24,
+      "entropia": 3.178054,
+      "rank_efetivo": 24.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 32.043781,
+        "u_max": 60.584747,
+        "u_std": 13.450652,
+        "fronteiras_picos": 5
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "gg": {
+      "k": 4,
+      "qe": 824.069397,
+      "te": 0.316406,
+      "distorcao": 2294.106445,
+      "sigma0": 3.0,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 4,
+      "entropia": 1.386294,
+      "rank_efetivo": 4.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 11.976965,
+        "u_max": 13.957561,
+        "u_std": 1.774012,
+        "fronteiras_picos": 1
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "gcs": {
+      "k": 3,
+      "qe": 250.228699,
+      "te": 1.0,
+      "distorcao": 1513.247803,
+      "sigma0": 0.0,
+      "sigma_f": 0.0,
+      "alpha0": 0.0,
+      "alpha_ultimo": 0.0,
+      "n_ativos": 2,
+      "entropia": 0.574847,
+      "rank_efetivo": 1.7769,
+      "frac_vivas": 0.6667,
+      "u_matrix_resumo": {
+        "u_media": 0.0,
+        "u_max": 0.0,
+        "u_std": 0.0,
+        "fronteiras_picos": 0
+      },
+      "taxa_ativos_ema": null
+    },
+    "gsom": {
+      "k": 4,
+      "qe": 220.440918,
+      "te": 0.410156,
+      "distorcao": 3028.990967,
+      "sigma0": 3.0,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 4,
+      "entropia": 1.386294,
+      "rank_efetivo": 4.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 36.250061,
+        "u_max": 60.509567,
+        "u_std": 19.814838,
+        "fronteiras_picos": 1
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "hsom": {
+      "k": 12,
+      "qe": 71.016319,
+      "te": 0.855469,
+      "distorcao": 3511.441895,
+      "sigma0": 2.5,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 12,
+      "entropia": 2.484907,
+      "rank_efetivo": 12.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 28.268629,
+        "u_max": 40.029243,
+        "u_std": 7.094913,
+        "fronteiras_picos": 3
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "tkm": {
+      "k": 32,
+      "qe": 58.265549,
+      "te": 0.851562,
+      "distorcao": 6600.30127,
+      "sigma0": 2.0,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 32,
+      "entropia": 3.465736,
+      "rank_efetivo": 32.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 33.759853,
+        "u_max": 60.711811,
+        "u_std": 13.525013,
+        "fronteiras_picos": 9
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "rsom": {
+      "k": 32,
+      "qe": 53.492386,
+      "te": 0.824219,
+      "distorcao": 5104.700684,
+      "sigma0": 2.0,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 32,
+      "entropia": 3.465736,
+      "rank_efetivo": 32.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 34.29977,
+        "u_max": 60.189041,
+        "u_std": 13.249257,
+        "fronteiras_picos": 6
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "cpn": {
+      "k": 24,
+      "qe": 38.578434,
+      "te": 0.195312,
+      "distorcao": 884.967712,
+      "sigma0": 2.5,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.462963,
+      "n_ativos": 23,
+      "entropia": 2.909895,
+      "rank_efetivo": 18.3549,
+      "frac_vivas": 0.9583,
+      "u_matrix_resumo": {
+        "u_media": 9.52423,
+        "u_max": 16.741587,
+        "u_std": 4.716956,
+        "fronteiras_picos": 3
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "ssom": {
+      "k": 24,
+      "qe": 123.85688,
+      "te": 0.90625,
+      "distorcao": 5260.532715,
+      "sigma0": 2.0,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 24,
+      "entropia": 3.178054,
+      "rank_efetivo": 24.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 33.295235,
+        "u_max": 59.584949,
+        "u_std": 15.406026,
+        "fronteiras_picos": 4
+      },
+      "taxa_ativos_ema": 1.0
+    }
+  },
+  "inferencia_agente": {
+    "latencia_s": 0.382,
+    "tokens": 24,
+    "taxa_repeticao": 0.2083,
+    "coerencia_bigramas": 0.0
+  },
+  "difusao": {
+    "modo": "real",
+    "prompt_enriquecido": "o pantanal ao entardecer, com detalhes nítidos, com composição harmônica, com iluminação suave",
+    "latencia_s": 2.42,
+    "gerou_pixels": true
+  },
+  "agente_engenheiro": {
+    "revisoes_aprovadas": 0,
+    "revisoes_bloqueadas": 0,
+    "som_invariante_sem_orfaos": true,
+    "som_ativos": {
+      "ativos/som": 1.0,
+      "k/som": 24,
+      "ativos/gg": 1.0,
+      "k/gg": 4,
+      "ativos/gcs": 1.0,
+      "k/gcs": 3,
+      "ativos/gsom": 1.0,
+      "k/gsom": 4,
+      "ativos/hsom": 1.0,
+      "k/hsom": 12,
+      "ativos/tkm": 1.0,
+      "k/tkm": 32,
+      "ativos/rsom": 1.0,
+      "k/rsom": 32,
+      "ativos/cpn": 1.0,
+      "k/cpn": 24,
+      "ativos/ssom": 1.0,
+      "k/ssom": 24,
+      "A_global": 1.0
+    }
+  }
+}

avaliacao_v8.json

@@ -0,0 +1,947 @@
+{
+  "estado": "fase-som",
+  "roteador_ssom": {
+    "amostras": 1536,
+    "pronto": true,
+    "lambda_rota": 0.35,
+    "gamma_empate": 0.15,
+    "drift_codebook": 0.0,
+    "conf_media": 0.3382,
+    "frac_rotas_ativas": 0.75,
+    "k": 24,
+    "taxa_ativos": 1.0
+  },
+  "perdas_tarefa": {
+    "lm": {
+      "treinado": 7.840750614802043,
+      "aleatorio": 9.75594711303711
+    },
+    "noticia": {
+      "treinado": 7.552767038345337,
+      "aleatorio": 9.748649597167969
+    },
+    "instrucao": {
+      "treinado": 6.964608271916707,
+      "aleatorio": 9.766283671061197
+    },
+    "pontuacao": {
+      "treinado": 7.724856456120809,
+      "aleatorio": 9.752796649932861
+    },
+    "imagem_caption": {
+      "treinado": 7.004336357116699,
+      "aleatorio": 9.723368008931478
+    },
+    "vqa": {
+      "treinado": 7.352211872736613,
+      "aleatorio": 9.732653617858887
+    },
+    "ocr": {
+      "treinado": 7.486716111501058,
+      "aleatorio": 9.772692362467447
+    },
+    "asr": {
+      "treinado": 7.620069583257039,
+      "aleatorio": 9.76025120417277
+    },
+    "tts": {
+      "treinado": 6.79421067237854,
+      "aleatorio": 9.778711160024008
+    }
+  },
+  "ppl_lm": 2542.1122649587833,
+  "ppl_lm_aleatorio": 17256.55090604361,
+  "moe_uso_por_tarefa": {
+    "lm": [
+      {
+        "experts_top": [
+          0,
+          1
+        ],
+        "grupo_top": [
+          0,
+          0
+        ]
+      },
+      {
+        "experts_top": [
+          1,
+          3
+        ],
+        "grupo_top": [
+          "dec",
+          "dec"
+        ],
+        "agrupado": false
+      }
+    ],
+    "vqa": [
+      {
+        "experts_top": [
+          0,
+          4
+        ],
+        "grupo_top": [
+          0,
+          2
+        ]
+      },
+      {
+        "experts_top": [
+          1,
+          3
+        ],
+        "grupo_top": [
+          "dec",
+          "dec"
+        ],
+        "agrupado": false
+      }
+    ],
+    "ocr": [
+      {
+        "experts_top": [
+          0,
+          4
+        ],
+        "grupo_top": [
+          0,
+          2
+        ]
+      },
+      {
+        "experts_top": [
+          1,
+          3
+        ],
+        "grupo_top": [
+          "dec",
+          "dec"
+        ],
+        "agrupado": false
+      }
+    ],
+    "asr": [
+      {
+        "experts_top": [
+          4,
+          0
+        ],
+        "grupo_top": [
+          2,
+          0
+        ]
+      },
+      {
+        "experts_top": [
+          1,
+          3
+        ],
+        "grupo_top": [
+          "dec",
+          "dec"
+        ],
+        "agrupado": false
+      }
+    ],
+    "tts": [
+      {
+        "experts_top": [
+          0,
+          4
+        ],
+        "grupo_top": [
+          0,
+          2
+        ]
+      },
+      {
+        "experts_top": [
+          1,
+          3
+        ],
+        "grupo_top": [
+          "dec",
+          "dec"
+        ],
+        "agrupado": false
+      }
+    ]
+  },
+  "mtp": {
+    "alphas": [
+      0.0005292753921821713,
+      0.9994707703590393
+    ],
+    "per_cabeca": [
+      8.05044937133789,
+      8.269538879394531
+    ],
+    "entropia": 0.004521933849900961,
+    "termos_ce": 0.0
+  },
+  "w8a8_delta": 0.0006594657897949219,
+  "som_treinado": {
+    "variante_ativa": "cpn",
+    "variantes": {
+      "som": {
+        "k": 24,
+        "taxa_ativos": 1.0,
+        "resemeados": 24,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "gg": {
+        "k": 4,
+        "taxa_ativos": 1.0,
+        "resemeados": 4,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "gcs": {
+        "k": 3,
+        "arestas": 3,
+        "eq_treino": 4104.4892578125,
+        "atingiu_alvo": true
+      },
+      "gsom": {
+        "k": 15,
+        "gt": 1.05,
+        "erro_medio": 0.18949279189109802,
+        "atingiu_alvo": true
+      },
+      "hsom": {},
+      "tkm": {
+        "k": 32,
+        "taxa_ativos": 1.0,
+        "resemeados": 32,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "rsom": {
+        "k": 32,
+        "taxa_ativos": 1.0,
+        "resemeados": 32,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "cpn": {},
+      "ssom": {
+        "erro": "IndexError: index 8 is out of bounds for dimension 0 with size 8"
+      }
+    },
+    "roteador": {
+      "amostras": 1581,
+      "pronto": true,
+      "lambda_rota": 0.35,
+      "gamma_empate": 0.15,
+      "drift_codebook": 0.009923,
+      "conf_media": 0.4107,
+      "frac_rotas_ativas": 0.7188,
+      "k": 24,
+      "taxa_ativos": 1.0
+    },
+    "invariante_sem_orfaos": true,
+    "orfaos_por_variante": {
+      "som": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "gg": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "gcs": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "gsom": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "hsom": {
+        "orfaos": 0,
+        "relocados": 0
+      },
+      "tkm": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "rsom": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "cpn": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "ssom": {
+        "orfaos": 0,
+        "relocados": 23,
+        "taxa_ativos": 1.0
+      }
+    }
+  },
+  "som_eq_fresco": {
+    "som": {
+      "taxa_ativos": 1.0,
+      "eq": 0.22861014306545258
+    },
+    "gg": {
+      "taxa_ativos": 1.0,
+      "eq": 1.0804760456085205
+    },
+    "gcs": {
+      "taxa_ativos": 1.0,
+      "eq": 0.9599178433418274
+    },
+    "gsom": {
+      "taxa_ativos": 1.0,
+      "eq": 1.2962698936462402
+    },
+    "tkm": {
+      "taxa_ativos": 1.0,
+      "eq": 0.08437514305114746
+    },
+    "rsom": {
+      "taxa_ativos": 1.0,
+      "eq": 0.07955622673034668
+    },
+    "ssom": {
+      "taxa_ativos": 1.0,
+      "eq": 0.09257030487060547
+    }
+  },
+  "geracao": {
+    "sem_punicao": " ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?",
+    "com_punicao": " ? ? ? ?\n ? ? ?feira ? ? ? ? ? ? ? ? ? ? O ? ? ? ? Uma ? corpo ? O ?"
+  },
+  "microunidades": {
+    "lm": [
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp"
+        ],
+        "alpha_medio": [
+          0.6092,
+          0.3907,
+          0.0002
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          0.1485,
+          0.4984,
+          0.0738,
+          0.2794
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          1.0,
+          0.0,
+          0.0,
+          0.0
+        ],
+        "passos_rec": 2
+      }
+    ],
+    "vqa": [
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp"
+        ],
+        "alpha_medio": [
+          1.0,
+          0.0,
+          0.0
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          0.1592,
+          0.4579,
+          0.0731,
+          0.3098
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          1.0,
+          0.0,
+          0.0,
+          0.0
+        ],
+        "passos_rec": 2
+      }
+    ],
+    "asr": [
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp"
+        ],
+        "alpha_medio": [
+          0.6136,
+          0.3863,
+          0.0001
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          0.1496,
+          0.4945,
+          0.074,
+          0.2819
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          1.0,
+          0.0,
+          0.0,
+          0.0
+        ],
+        "passos_rec": 2
+      }
+    ],
+    "instrucao": [
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp"
+        ],
+        "alpha_medio": [
+          0.839,
+          0.161,
+          0.0
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          0.1472,
+          0.5048,
+          0.0738,
+          0.2742
+        ],
+        "passos_rec": 2
+      },
+      {
+        "ramos": [
+          "conv_dil",
+          "gru",
+          "mlp",
+          "moe"
+        ],
+        "alpha_medio": [
+          1.0,
+          0.0,
+          0.0,
+          0.0
+        ],
+        "passos_rec": 2
+      }
+    ]
+  },
+  "treino_prs_v8": {
+    "trust": 0.3768,
+    "tau": 6.82558,
+    "clip": 5.0,
+    "boost": 1.0,
+    "streak": 0,
+    "ciclos_sgdr": 0,
+    "recompensa_acum": 9.712,
+    "beta_min_relativo": 2.0
+  },
+  "treino_confianca": {
+    "h_ema": 0.398207426071167,
+    "ece": 0.13666666666666666,
+    "posterior_media": 0.18478260869565216,
+    "bernstein": [
+      0.048734518728612175,
+      0.32083069866269215
+    ]
+  },
+  "treino_memoria": {
+    "slots": 13,
+    "capacidade": 64,
+    "escritas": 13,
+    "rejeitadas_confianca": 10,
+    "hit_rate": 1.0,
+    "comprimidos": 0,
+    "entropia_codebook": 1.4736544073912228e-07,
+    "perda_vq": null,
+    "violacoes_contrato": 0,
+    "economia_bits_por_slot": 0.9990234375
+  },
+  "treino_crescimento": [],
+  "memoria_execucao": {
+    "slots": 32,
+    "capacidade": 32,
+    "escritas": 45,
+    "rejeitadas_confianca": 0,
+    "hit_rate": 1.0,
+    "comprimidos": 32,
+    "entropia_codebook": 3.4869675636291504,
+    "perda_vq": "tensor(1.2586)",
+    "violacoes_contrato": 0,
+    "economia_bits_por_slot": 0.9990234375,
+    "escritas_aceitas": 45,
+    "consultas_com_acerto": 15,
+    "comprimidos_agora": 32
+  },
+  "curva_epocas": [
+    {
+      "epoca": 0,
+      "perda_media": 7.563339779175908,
+      "ppl_lm": 3175.163243261297
+    },
+    {
+      "epoca": 1,
+      "perda_media": 8.527180158174955,
+      "ppl_lm": 3338.0887647367836
+    },
+    {
+      "epoca": 2,
+      "perda_media": 7.530729611714681,
+      "ppl_lm": 2609.7989711637842
+    },
+    {
+      "epoca": 3,
+      "perda_media": 7.470894780158996,
+      "ppl_lm": 2415.108953044255
+    },
+    {
+      "epoca": 4,
+      "perda_media": 7.043362287374643,
+      "ppl_lm": 2283.2964058650737
+    },
+    {
+      "epoca": 5,
+      "perda_media": 7.089543087537899,
+      "ppl_lm": 2672.6735231256753
+    },
+    {
+      "epoca": 6,
+      "perda_media": 9.40745317524877,
+      "ppl_lm": 4403.193619695888
+    },
+    {
+      "epoca": 7,
+      "perda_media": 7.231130578782824,
+      "ppl_lm": 2572.532733229914
+    }
+  ],
+  "coerencia": {
+    "corpus_25pct": {
+      "n_registros": 887,
+      "repeticao_pct": 69.85,
+      "ancoragem_bigramas": 0.0,
+      "entropia_logits": 0.6818
+    },
+    "corpus_50pct": {
+      "n_registros": 1774,
+      "repeticao_pct": 72.06,
+      "ancoragem_bigramas": 0.0,
+      "entropia_logits": 0.6818
+    },
+    "corpus_100pct": {
+      "n_registros": 3548,
+      "repeticao_pct": 56.62,
+      "ancoragem_bigramas": 0.0071,
+      "entropia_logits": 0.6818
+    },
+    "amostras": [
+      " ? ? ? ? Uma ?\n ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? corpo implant ? ? ? ? ? ? ? ? ? ? ? rotina",
+      " ? ? Ofeira\n ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?\n ? ? ? ? ?",
+      " ? ? ? ? O ? ? Ele ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? rotina imped ? ?\n ? ? ? ? ? ? ?",
+      " ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? Uma ? ? rotinaesquel ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?"
+    ]
+  },
+  "clip_score": {
+    "clip_real": -0.0921,
+    "clip_controle": -0.0923,
+    "margem": 0.0002,
+    "n": 32
+  },
+  "itm": {
+    "acuracia": 0.5,
+    "f1": 0.0,
+    "n": 16,
+    "tp": 0,
+    "fp": 0,
+    "fn": 8
+  },
+  "ppl_visual": {
+    "ppl_visual": 1.52,
+    "n": 192,
+    "codigos_distintos": 9
+  },
+  "ppl_multimodal": {
+    "ppl_mm": 1072.72,
+    "ce_mm": 6.978,
+    "n": 2733
+  },
+  "geracao_metricas": {
+    "medias": {
+      "bleu": 0.0,
+      "rouge_l": 0.0026,
+      "meteor": 0.0,
+      "cider": 0.0
+    },
+    "n": 12,
+    "amostras": [
+      {
+        "hipotese": " ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?",
+        "ref": "Na foto podemos ver um homem centralizado na imagem, posicio",
+        "bleu": 0.0,
+        "rouge_l": 0.0,
+        "meteor": 0.0,
+        "cider": 0.0
+      },
+      {
+        "hipotese": " ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?",
+        "ref": "Na foto podemos ver duas pessoas sobre uma prancha de stand ",
+        "bleu": 0.0,
+        "rouge_l": 0.0,
+        "meteor": 0.0,
+        "cider": 0.0
+      },
+      {
+        "hipotese": " ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?",
+        "ref": "Na foto podemos ver cinco pessoas reunidas ao redor de uma c",
+        "bleu": 0.0,
+        "rouge_l": 0.0,
+        "meteor": 0.0,
+        "cider": 0.0
+      },
+      {
+        "hipotese": " ? ? ? ? ? rotina básicos ? ? ? ? ? ? ? Uma ? ? ? ? ?",
+        "ref": "Na imagem podemos ver um homem usando uma jaqueta jeans de m",
+        "bleu": 0.0,
+        "rouge_l": 0.009666,
+        "meteor": 0.0,
+        "cider": 0.0
+      }
+    ]
+  },
+  "benchmarks": {
+    "mmmu": {
+      "benchmark": "MMMU-proxy-PT",
+      "n": 30,
+      "acuracia": 0.0,
+      "acertos": 0,
+      "distribuicao": {
+        "∅": 30
+      },
+      "acaso": 0.25,
+      "rotulo": "proxy em escala reduzida"
+    },
+    "mme": {
+      "benchmark": "MME-proxy-PT",
+      "n": 15,
+      "acc": 0.0,
+      "acc_mais": 0.0,
+      "score_mme": 0.0,
+      "rotulo": "proxy em escala reduzida"
+    },
+    "mathvista": {
+      "benchmark": "MathVista-proxy-PT",
+      "n": 2,
+      "acuracia": 0.0,
+      "acertos": 0,
+      "rotulo": "proxy em escala reduzida"
+    }
+  },
+  "som_expandido": {
+    "som": {
+      "k": 24,
+      "qe": 0.728719,
+      "te": 0.671875,
+      "distorcao": 74.685822,
+      "sigma0": 3.0,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 24,
+      "entropia": 3.178054,
+      "rank_efetivo": 24.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 2.167898,
+        "u_max": 6.077848,
+        "u_std": 1.605556,
+        "fronteiras_picos": 2
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "gg": {
+      "k": 4,
+      "qe": 9.097231,
+      "te": 0.878906,
+      "distorcao": 34.777397,
+      "sigma0": 3.0,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 4,
+      "entropia": 1.386294,
+      "rank_efetivo": 4.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 2.047124,
+        "u_max": 2.419761,
+        "u_std": 0.425792,
+        "fronteiras_picos": 1
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "gcs": {
+      "k": 3,
+      "qe": 1.699399,
+      "te": 1.0,
+      "distorcao": 28.847206,
+      "sigma0": 0.0,
+      "sigma_f": 0.0,
+      "alpha0": 0.0,
+      "alpha_ultimo": 0.0,
+      "n_ativos": 3,
+      "entropia": 1.037116,
+      "rank_efetivo": 2.8211,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 0.0,
+        "u_max": 0.0,
+        "u_std": 0.0,
+        "fronteiras_picos": 0
+      },
+      "taxa_ativos_ema": null
+    },
+    "gsom": {
+      "k": 4,
+      "qe": 10.148916,
+      "te": 0.859375,
+      "distorcao": 36.684849,
+      "sigma0": 3.0,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 4,
+      "entropia": 1.386294,
+      "rank_efetivo": 4.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 1.536023,
+        "u_max": 2.269848,
+        "u_std": 0.599166,
+        "fronteiras_picos": 1
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "hsom": {
+      "k": 12,
+      "qe": 0.678309,
+      "te": 0.820312,
+      "distorcao": 82.439156,
+      "sigma0": 2.5,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 12,
+      "entropia": 2.484907,
+      "rank_efetivo": 12.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 3.804719,
+        "u_max": 8.736095,
+        "u_std": 2.721405,
+        "fronteiras_picos": 2
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "tkm": {
+      "k": 32,
+      "qe": 0.216429,
+      "te": 0.851562,
+      "distorcao": 106.654846,
+      "sigma0": 2.0,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 32,
+      "entropia": 3.465736,
+      "rank_efetivo": 32.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 3.442991,
+        "u_max": 11.211287,
+        "u_std": 2.545307,
+        "fronteiras_picos": 5
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "rsom": {
+      "k": 32,
+      "qe": 1.095875,
+      "te": 0.917969,
+      "distorcao": 70.848114,
+      "sigma0": 2.0,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 32,
+      "entropia": 3.465736,
+      "rank_efetivo": 32.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 2.278218,
+        "u_max": 6.905422,
+        "u_std": 1.859771,
+        "fronteiras_picos": 7
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "cpn": {
+      "k": 24,
+      "qe": 0.182707,
+      "te": 0.3125,
+      "distorcao": 12.300114,
+      "sigma0": 2.5,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.462963,
+      "n_ativos": 24,
+      "entropia": 2.561003,
+      "rank_efetivo": 12.9488,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 1.221734,
+        "u_max": 3.020689,
+        "u_std": 0.860318,
+        "fronteiras_picos": 2
+      },
+      "taxa_ativos_ema": 1.0
+    },
+    "ssom": {
+      "k": 24,
+      "qe": 0.824301,
+      "te": 0.945312,
+      "distorcao": 84.187256,
+      "sigma0": 2.0,
+      "sigma_f": 0.4,
+      "alpha0": 0.5,
+      "alpha_ultimo": 0.49505,
+      "n_ativos": 24,
+      "entropia": 3.178054,
+      "rank_efetivo": 24.0,
+      "frac_vivas": 1.0,
+      "u_matrix_resumo": {
+        "u_media": 1.757095,
+        "u_max": 8.05575,
+        "u_std": 1.751349,
+        "fronteiras_picos": 3
+      },
+      "taxa_ativos_ema": 1.0
+    }
+  },
+  "inferencia_agente": {
+    "latencia_s": 0.414,
+    "tokens": 24,
+    "taxa_repeticao": 0.9167,
+    "coerencia_bigramas": 0.0
+  },
+  "difusao": {
+    "modo": "planejado",
+    "prompt_enriquecido": "o pantanal ao entardecer, com detalhes nítidos, com composição harmônica, com iluminação suave",
+    "latencia_s": 0.0,
+    "gerou_pixels": false
+  },
+  "agente_engenheiro": {
+    "revisoes_aprovadas": 0,
+    "revisoes_bloqueadas": 0,
+    "som_invariante_sem_orfaos": true,
+    "som_ativos": {
+      "ativos/som": 1.0,
+      "k/som": 24,
+      "ativos/gg": 1.0,
+      "k/gg": 4,
+      "ativos/gcs": 1.0,
+      "k/gcs": 3,
+      "ativos/gsom": 1.0,
+      "k/gsom": 4,
+      "ativos/hsom": 1.0,
+      "k/hsom": 12,
+      "ativos/tkm": 1.0,
+      "k/tkm": 32,
+      "ativos/rsom": 1.0,
+      "k/rsom": 32,
+      "ativos/cpn": 1.0,
+      "k/cpn": 24,
+      "ativos/ssom": 1.0,
+      "k/ssom": 24,
+      "A_global": 1.0
+    }
+  }
+}

comparacao_treino_v7.json

@@ -0,0 +1,153 @@
+{
+  "versao_atual": "v7-retreino-observado-ram",
+  "versao_anterior": "v6-roteamento-ssom-rpp-metricas",
+  "test_khtst_v6": {
+    "ok": 48,
+    "falhou": 0
+  },
+  "ram": {
+    "amostras": 6059,
+    "rss_min_mb": 542.6,
+    "rss_med_mb": 2692.2,
+    "rss_max_mb": 3579.5,
+    "disponivel_min_mb": 138.6,
+    "duracao_s": 12836.7
+  },
+  "perdas_tarefa": {
+    "asr": {
+      "anterior": 1.890599290529887,
+      "atual": 2.1221489111582437
+    },
+    "imagem_caption": {
+      "anterior": 1.6015255053838093,
+      "atual": 2.127371827761332
+    },
+    "instrucao": {
+      "anterior": 2.210473636786143,
+      "atual": 2.035900592803955
+    },
+    "lm": {
+      "anterior": 2.840959151585897,
+      "atual": 2.8384029467900596
+    },
+    "noticia": {
+      "anterior": 2.5332184632619223,
+      "atual": 2.5535371700922647
+    },
+    "ocr": {
+      "anterior": 2.109198252360026,
+      "atual": 1.418007344007492
+    },
+    "pontuacao": {
+      "anterior": 2.8601644039154053,
+      "atual": 2.648297905921936
+    },
+    "tts": {
+      "anterior": 1.7698550621668498,
+      "atual": 1.675029953320821
+    },
+    "vqa": {
+      "anterior": 2.4512375791867576,
+      "atual": 2.177152613798777
+    }
+  },
+  "som_taxa_ativos": {
+    "cpn": {
+      "anterior": null,
+      "atual": null
+    },
+    "gcs": {
+      "anterior": null,
+      "atual": null
+    },
+    "gg": {
+      "anterior": 1.0,
+      "atual": 1.0
+    },
+    "gsom": {
+      "anterior": null,
+      "atual": null
+    },
+    "hsom": {
+      "anterior": null,
+      "atual": null
+    },
+    "rsom": {
+      "anterior": 1.0,
+      "atual": 1.0
+    },
+    "som": {
+      "anterior": 1.0,
+      "atual": 1.0
+    },
+    "ssom": {
+      "anterior": null,
+      "atual": null
+    },
+    "tkm": {
+      "anterior": 1.0,
+      "atual": 1.0
+    }
+  },
+  "rpp": {
+    "anterior": {
+      "rho": 1.0,
+      "streak": 0,
+      "recompensas": 0,
+      "punicoes": 2,
+      "penalidades": 99,
+      "kappa_rotas_mortas": 0.01
+    },
+    "atual": {
+      "rho": 1.0,
+      "streak": 0,
+      "recompensas": 0,
+      "punicoes": 2,
+      "penalidades": 104,
+      "kappa_rotas_mortas": 0.01
+    }
+  },
+  "alinhamento": {
+    "anterior": {
+      "clip_real": 0.1104,
+      "clip_controle": 0.1169,
+      "ppl_mm": 5.59,
+      "ppl_visual": 1.06,
+      "itm_acc": 0.5
+    },
+    "atual": {
+      "clip_real": -0.1604,
+      "clip_controle": -0.1702,
+      "ppl_mm": 9.41,
+      "ppl_visual": 1.16,
+      "itm_acc": 0.5
+    }
+  },
+  "ppl_lm": {
+    "anterior": 17.132190026332925,
+    "atual": 17.088452564794597,
+    "delta_pct": -0.26
+  },
+  "perda_media_final": {
+    "anterior": 0.78661770003876,
+    "atual": 0.8830587758666997
+  },
+  "passos": {
+    "anterior": 3192,
+    "atual": 3192
+  },
+  "nao_regressao": {
+    "antes": {
+      "ppl_lm": 17.132190026332925,
+      "perda_media_final": 0.78661770003876,
+      "taxa_ativos_min": 1.0
+    },
+    "depois": {
+      "ppl_lm": 17.088452564794597,
+      "perda_media_final": 0.8830587758666997,
+      "taxa_ativos_min": 1.0
+    },
+    "regressoes": {},
+    "aprovado": true
+  }
+}

comparacao_treino_v8.json

@@ -0,0 +1,143 @@
+{
+  "versao_atual": "v8-khtst-melhorias-a-j",
+  "versao_anterior": "aurora-v7-baseline-publicado",
+  "test_khtst_v6": {
+    "ok": 48,
+    "falhou": 0
+  },
+  "ram": {
+    "amostras": 5919,
+    "rss_min_mb": 428.7,
+    "rss_med_mb": 2524.4,
+    "rss_max_mb": 3358.4,
+    "disponivel_min_mb": 435.4,
+    "duracao_s": 14340.3
+  },
+  "perdas_tarefa": {
+    "asr": {
+      "anterior": 2.1221489111582437,
+      "atual": 7.620069583257039
+    },
+    "imagem_caption": {
+      "anterior": 2.127371827761332,
+      "atual": 7.004336357116699
+    },
+    "instrucao": {
+      "anterior": 2.035900592803955,
+      "atual": 6.964608271916707
+    },
+    "lm": {
+      "anterior": 2.8384029467900596,
+      "atual": 7.840750614802043
+    },
+    "noticia": {
+      "anterior": 2.5535371700922647,
+      "atual": 7.552767038345337
+    },
+    "ocr": {
+      "anterior": 1.418007344007492,
+      "atual": 7.486716111501058
+    },
+    "pontuacao": {
+      "anterior": 2.648297905921936,
+      "atual": 7.724856456120809
+    },
+    "tts": {
+      "anterior": 1.675029953320821,
+      "atual": 6.79421067237854
+    },
+    "vqa": {
+      "anterior": 2.177152613798777,
+      "atual": 7.352211872736613
+    }
+  },
+  "som_taxa_ativos": {
+    "cpn": {
+      "anterior": null,
+      "atual": null
+    },
+    "gcs": {
+      "anterior": null,
+      "atual": null
+    },
+    "gg": {
+      "anterior": 1.0,
+      "atual": 1.0
+    },
+    "gsom": {
+      "anterior": null,
+      "atual": null
+    },
+    "hsom": {
+      "anterior": null,
+      "atual": null
+    },
+    "rsom": {
+      "anterior": 1.0,
+      "atual": 1.0
+    },
+    "som": {
+      "anterior": 1.0,
+      "atual": 1.0
+    },
+    "ssom": {
+      "anterior": null,
+      "atual": null
+    },
+    "tkm": {
+      "anterior": 1.0,
+      "atual": 1.0
+    }
+  },
+  "rpp": {
+    "anterior": {},
+    "atual": {
+      "rho": 1.0,
+      "streak": 0,
+      "recompensas": 2,
+      "punicoes": 1,
+      "penalidades": 90,
+      "kappa_rotas_mortas": 0.01
+    }
+  },
+  "alinhamento": {
+    "anterior": {
+      "clip_real": -0.1604,
+      "clip_controle": -0.1702,
+      "ppl_mm": 9.41,
+      "ppl_visual": 1.16,
+      "itm_acc": 0.5
+    },
+    "atual": {
+      "clip_real": -0.0921,
+      "clip_controle": -0.0923,
+      "ppl_mm": 1072.72,
+      "ppl_visual": 1.52,
+      "itm_acc": 0.5
+    }
+  },
+  "ppl_lm": {
+    "anterior": 17.088452564794597,
+    "atual": 2542.1122649587833,
+    "delta_pct": 14776.2
+  },
+  "nao_regressao": {
+    "antes": {
+      "ppl_lm": 17.088452564794597,
+      "taxa_ativos_min": 1.0
+    },
+    "depois": {
+      "ppl_lm": 2542.1122649587833,
+      "perda_media_final": 7.231130578782824,
+      "taxa_ativos_min": 1.0
+    },
+    "regressoes": {
+      "ppl_lm": {
+        "antes": 17.088452564794597,
+        "depois": 2542.1122649587833,
+        "queda_relativa": 147.762
+      }
+    },
+    "aprovado": false
+  }
+}

configs/base.json

@@ -0,0 +1,215 @@
+{
+  "modelo": {
+    "vocab": 16384,
+    "d_modelo": 192,
+    "n_camadas": 3,
+    "n_cabecas": 4,
+    "d_ff": 512,
+    "comprimento_ctx": 192,
+    "janela_sliding": 128,
+    "kv_cache_max": 2048,
+    "n_experts_fusao": 4,
+    "moe": {
+      "ativo": true,
+      "n_camadas_moe": 2,
+      "n_grupos": 3,
+      "experts_por_grupo": 2,
+      "d_ff_expert": 160,
+      "top_k": 2,
+      "margem_foco": 1.0,
+      "n_tarefas": 9,
+      "vetorial": true
+    },
+    "mtp": {
+      "ativo": true,
+      "k_cabecas": 2,
+      "beta_entropia": 0.05,
+      "k_adaptativo": true
+    },
+    "roteador": {
+      "ativo": true,
+      "k": 24,
+      "lambda_rota": 0.35,
+      "gamma_empate": 0.15,
+      "conf_min": 0.25,
+      "min_amostras": 200
+    },
+    "microunidades": {
+      "d_gru": 96,
+      "d_ramo": 96,
+      "d_refino": 128,
+      "kernel1": 3,
+      "kernel2": 5,
+      "gamma_rec": 0.5,
+      "k_rec_max": 2,
+      "eps_stop": 0.01,
+      "tau0": 0.8,
+      "kappa_conf": 1.0,
+      "delta_explora": 0.3
+    },
+    "atencao_moe": {
+      "ativo": true,
+      "alpha0": 0.0
+    },
+    "usar_atencao_arvore": true,
+    "moe_enc_dec": {
+      "ativo": true,
+      "n_encoders": 2,
+      "n_decoders": 4,
+      "d_ff_expert": 160,
+      "top_k": 2,
+      "fora_de_ordem": true
+    },
+    "autoajuste": {
+      "ativo": true,
+      "janela_lr": 200,
+      "lr_passo": 0.5,
+      "raio_min": 32,
+      "raio_max": 256,
+      "alpha_peso_arvore": 0.05,
+      "ppl_alvo": 17.0
+    }
+  },
+  "treino": {
+    "epocas": 8,
+    "lote": 8,
+    "lr_max": 0.003,
+    "lr_min": 0.0003,
+    "warmup": 60,
+    "clip_grad": 1.0,
+    "janela_estagnacao": 120,
+    "checkpoint_a_cada": 150,
+    "avaliar_a_cada": 100,
+    "qat_ultimos_passos": 80,
+    "fase_densa_ate_epoca": 5,
+    "pcgrad": true,
+    "lambda_moe_lb": 0.01,
+    "lambda_moe_ort": 0.01,
+    "lambda_mtp": 0.3,
+    "lambda_som": 0.05,
+    "mistura_tarefas": {
+      "instrucao": 0.22,
+      "lm": 0.14,
+      "noticia": 0.1,
+      "pontuacao": 0.1,
+      "imagem_caption": 0.1,
+      "vqa": 0.1,
+      "ocr": 0.07,
+      "asr": 0.09,
+      "tts": 0.08
+    },
+    "abmo": {
+      "ativo": true,
+      "margem": 0.25,
+      "cap_min": 0.05,
+      "cap_max": 500.0
+    },
+    "dpo": {
+      "ativo": true,
+      "passos": 100,
+      "beta": 0.1,
+      "lr": 5e-05,
+      "lr_beta": 0.001,
+      "kl_alvo": 0.5,
+      "lote": 4,
+      "beta_min": 0.05
+    },
+    "fase_som": {
+      "ativo": true,
+      "epocas": 2,
+      "alvo_ativos": 0.9,
+      "gamma_empate": 0.15,
+      "lambda_novidade": 0.25,
+      "dim_lote": 64
+    },
+    "prs_v8": {
+      "ativo": true,
+      "eta_up": 0.05,
+      "eta_down": 0.02,
+      "T_ciclo": 400,
+      "decay_piso": 1.0,
+      "percentil": 0.75,
+      "janela_clip": 50,
+      "coef_streak": 0.3,
+      "vel_alvo": 0.01,
+      "boost_max": 1.0
+    },
+    "confianca": {
+      "ativo": true,
+      "kappa_punicao": 0.3,
+      "kappa_premio": 0.1,
+      "janela_tau": 50,
+      "quantil_tau": 0.25,
+      "h_escrita_memoria": 0.25
+    },
+    "crescimento": {
+      "ativo": true,
+      "a_cada": 200,
+      "tau_expand": 0.1,
+      "tau_prune": 0.01,
+      "eps_gate": 0.05,
+      "janela_uso": 8,
+      "n_max_ramos": 5,
+      "n_sondas": 2
+    },
+    "rpp": {
+      "ativo": true,
+      "rho_max": 0.15,
+      "rho_step": 0.05,
+      "rho_decaimento": 0.5,
+      "janela": 30,
+      "kappa_rotas_mortas": 0.01,
+      "alvo_ativos": 0.9
+    },
+    "sgdr_t_mult": 2
+  },
+  "ciclo": {
+    "tau_escalada": 0.35,
+    "entropia_limite": 0.85,
+    "orcamento_passos": 6,
+    "cache_ferramentas_ttl": 600,
+    "cache_ferramentas_max": 64
+  },
+  "memoria_interna": {
+    "ativo": true,
+    "n_slots": 64,
+    "h_escrita": 0.25,
+    "idade_compressao_s": 900.0,
+    "n_codigos": 64,
+    "lambda_utilidade": 0.1,
+    "meia_vida_s": 1800.0,
+    "replay_a_cada": 40
+  },
+  "checkpoints": {
+    "dir_local": "/home/z/my-project/khtst/estados_local",
+    "pasta_publicacao": "estados/fase-v8"
+  },
+  "som_atencao": {
+    "ativo": true,
+    "tau": 0.5,
+    "gamma_novidade": 0.15
+  },
+  "difusao": {
+    "ativo": true,
+    "repo_id": "hf-internal-testing/tiny-stable-diffusion-torch",
+    "altura": 128,
+    "largura": 128,
+    "passos_inferencia": 8,
+    "guia_escala": 7.5
+  },
+  "agente_engenheiro": {
+    "ativo": true,
+    "intervalo": 50,
+    "tolerancia_regressao": 0.05
+  },
+  "janela_1m": {
+    "ativo": true,
+    "n_max_tokens": 262144,
+    "l_fino": 4096,
+    "w_segmento": 256,
+    "s_passo": 128,
+    "k_recall": 4,
+    "viz_r": 2,
+    "m_max": 2017
+  }
+}

docs/matematica/00-fundamentos-e-notacao.md

@@ -0,0 +1,87 @@
+# 00 — Fundamentos e Notação (KHTST)
+
+> **Regra do projeto (item 7 do escopo):** nenhum script é escrito antes da análise matemática
+> e da demonstração das equações que ele implementará. Este documento fixa a notação comum
+> a todos os demais. Os documentos são independentemente legíveis e cada teorema lista
+> explicitamente as hipóteses usadas.
+
+## 1. Notação
+
+| Símbolo | Significado |
+|---|---|
+| $\mathcal{X}$ | espaço de entrada (texto, imagem, áudio, vídeo, tabular, documentos) |
+| $x_t \in \mathcal{X}$ | amostra no instante discreto $t \in \mathbb{N}$ |
+| $W = \{w_1,\dots,w_K\}$, $w_i \in \mathbb{R}^d$ | protótipos/pesos de unidades de um SOM |
+| $c(x) = \arg\min_i \|x - w_i\|$ | unidade vencedora (Best Matching Unit, BMU) |
+| $\alpha(t) \in (0,1)$ | taxa de aprendizado no tempo |
+| $h_{ci}(t)$ | função de vizinhança, $0 \le h_{ci} \le 1$, máx. em $i=c$ |
+| $\sigma(t)$ | raio efetivo da vizinhança gaussiana |
+| $E_q$ | erro de quantização médio: $E_q = \mathbb{E}\,\min_i \|x - w_i\|^2$ |
+| $\theta$ | parâmetros treináveis do modelo neural (transformers etc.) |
+| $Q(\cdot), s$ | quantização W8A8 e fator de escala |
+| $\varphi(\cdot)$ | feature map de atenção linear (kernel trick) |
+| $\mathcal{L}(\theta)$ | perda escalar a minimizar |
+
+Convenções: vetores são colunas; $\|\cdot\|$ é a norma euclidiana; $\odot$ produto de Hadamard;
+$\mathbb{E}$ denota esperança empírica sobre o minibatch quando o contexto é amostral.
+Aproximações numéricas usam `float32`; provas são analíticas e independentes da precisão.
+
+## 2. Princípios de projeto derivados da matemática
+
+1. **Estabilidade antes de plasticidade.** Toda atualização de parâmetro tem a forma
+   $\theta_{t+1} = \theta_t + \Delta_t$ com $\|\Delta_t\|$ controlado (taxa decrescente ou clip).
+   Isso garante que o "punir/retreinar" (doc 09) não desestabiliza o modelo.
+2. **Convergência tipo Robbins–Monro.** Toda taxa de aprendizado cumpre
+   $\sum_t \alpha_t = \infty$ e $\sum_t \alpha_t^2 < \infty$ dentro de cada ciclo de treino
+   (ex.: decaimento coseno por reinício, doc 09, Teorema 9.4).
+3. **Erro limitado por construção.** Quantização (doc 08) e camadas ortogonais (doc 09)
+   têm cotas de erro/distorção provadas — o modelo nunca opera com erro não caracterizado.
+4. **Crescimento só com evidência.** Variantes crescentes de SOM (docs 02–04) inserem
+   unidades apenas onde o erro local o justifica; a monotonicidade do refinamento de
+   Voronoi (Teorema 2.1 do doc 02) garante que crescer nunca aumenta $E_q$.
+5. **Memória recursiva estável.** Contextos temporais (doc 05) são médias móveis
+   exponenciais com fator $(1-\alpha)\in(0,1)$ — garantia de estabilidade BIBO.
+
+## 3. Teorema 0.1 (contração da atualização de Kohonen)
+
+**Hipóteses.** $0 < \alpha(t) \le 1$; $0 \le h_{ci}(t) \le 1$ para todo $c,i$.
+
+**Afirmação.** A atualização
+$$w_i(t+1) = w_i(t) + \alpha(t)\,h_{c i}(t)\,\big(x(t) - w_i(t)\big)$$
+é uma contração em relação ao alvo $x$: vale
+$$\|w_i(t+1) - x\| = \big(1 - \alpha(t) h_{ci}(t)\big)\,\|w_i(t) - x\| \;\le\; \|w_i(t) - x\|.$$
+
+**Demonstração.** Substituindo,
+$w_i(t+1) - x = w_i(t) - x + \alpha h_{ci}(x - w_i(t)) = \big(1 - \alpha h_{ci}\big)\big(w_i(t)-x\big)$.
+Tomando normas, $\|w_i(t+1)-x\| = |1-\alpha h_{ci}|\,\|w_i(t)-x\|$. Como
+$\alpha h_{ci} \in (0,1]$, tem-se $1-\alpha h_{ci} \in [0,1)$ e o resultado segue. $\blacksquare$
+
+**Corolário 0.1.1 (não-explosão).** Se $\|x\| \le M$ (dados normalizados), então
+$\|w_i(t)\| \le \max(M, \|w_i(0)\|)$ para todo $t$ — os pesos nunca divergem, o que
+fundamenta os guard-rails de telemetria (doc 09, §5).
+
+## 4. Teorema 0.2 (desigualdade de Bhattacharyya/erro de partição — usada nos SOMs crescentes)
+
+Seja $V(w)$ a célula de Voronoi do protótipo $w$ e $E_q(V,w)=\int_V \|x-w\|^2 p(x)\,dx$.
+Se $V$ é particionada em $V_1\cup V_2$ com novos protótipos $w_1\in V_1$, $w_2\in V_2$, então
+$$E_q(V_1\cup V_2,\; w_1,w_2) \;\le\; E_q(V,\; w)$$
+**Demonstração.** Para cada $x\in V_1$: $\|x-w_1\|^2 \le \|x-w\|^2$? Não em geral ponto a ponto —
+mas o ótimo por região satisfaz $w_1^\star=\mathbb{E}[x\mid x\in V_1]$ (centroide), e o mínimo
+de uma função convexa restrita a um subconjunto não pode ser maior que o mínimo no conjunto
+todo: $E_q(V_1,w_1^\star) \le E_q(V_1, w) \le E_q(V, w)$, pois $w\notin V_1$ é um candidato
+viável (pior) para $V_1$. Somando sobre $V_1, V_2$ obtém-se o resultado. $\blacksquare$
+
+**Uso prático:** inserção de unidades em SOMs crescentes (GG/GCS/GSOM) nunca piora o erro
+de quantização *global* quando os novos centros são inicializados perto do pai — é a base
+da prova do doc 02.
+
+## 5. Referências primárias
+
+- Kohonen, T. *Self-Organizing Maps*, 3ª ed. Springer (2001) — Teorema 0.1, condições de convergência.
+- Robbins & Monro (1951) — aproximação estocástica.
+- Fritzke, B. (1995; 1994) — Growing Grid, Growing Cell Structures.
+- Alahakoon et al. (2000) — GSOM; Voegtlin (2002) — RSOM; Hecht-Nielsen (1987) — CPN.
+- Roy & Vetterli (2007) — effective rank; Swets/Wu — PSI de população.
+- Vaswani et al. (2017); Katharopoulos et al. (2020) — atenção e atenção linear.
+- Dettmers et al. (2022) — LLM.int8(); W8A8 conforme docs 08.
+- Bengio et al. (2013) — straight-through estimator.

docs/matematica/01-som-kohonen-clasico.md

@@ -0,0 +1,84 @@
+# 01 — SOM de Kohonen clássico: derivação, convergência e ordenamento
+
+**Objetivo do módulo `memoria/som_base.py`.** Minimizar o erro de quantização vetorial
+*topologicamente ordenado*: aproximar $p(x)$ por um conjunto $W=\{w_i\}_{i=1}^K$ de protótipos
+dispostos numa grade cuja vizinhança preserva a topologia dos dados.
+
+## 1. Derivação da função objetivo
+
+O SOM minimiza (Erwin–Obermayer–Schulten, 1992)
+$$E(W) \;=\; \sum_{i=1}^{K}\int_{V_i} \sum_{j=1}^{K} h_{ij}\,\|x - w_j\|^2\, p(x)\,dx,$$
+onde $V_i$ é a célula de Voronoi de $w_i$. Fazendo gradiente em $w_j$ e usando
+$\int_{V_i} p(x) dx$ como frequência de ativação $n_i$:
+$$\frac{\partial E}{\partial w_j} \;=\; -2\sum_i h_{ij}\, n_i\,\big(\mathbb{E}[x \mid V_i] - w_j\big),$$
+logo o gradiente descendente estocástico sobre amostras produz exatamente a **regra de Kohonen**:
+$$\boxed{\;w_j(t+1) = w_j(t) + \alpha(t)\, h_{c(t),j}(t)\,\big(x(t) - w_j(t)\big),\qquad
+c(t)=\arg\min_i \|x(t)-w_i(t)\|\;} \tag{1.1}$$
+com vizinhança gaussiana
+$$h_{cj}(t) = \exp\!\Big(-\frac{\|r_c - r_j\|^2}{2\sigma(t)^2}\Big), \qquad \sigma(t)=\sigma_0\Big(\frac{\sigma_f}{\sigma_0}\Big)^{t/T}. \tag{1.2}$$
+
+## 2. Teorema 1.1 (estabilidade com alvos móveis — extensão do Teorema 0.1)
+
+**Hipóteses.** $\alpha h_{cj}\in[0,1)$; $\|x(t)\|\le M$.
+**Afirmação.** $\|w_j(t+1)\| \le (1-\alpha h)\,\|w_j(t)\| + \alpha h\, M$, e por indução
+$\limsup_t \|w_j(t)\| \le M$.
+**Demonstração.** Da regra (1.1), $\|w_j(t+1)\| \le (1-\alpha h)\|w_j(t)\| + \alpha h \|x(t)\|
+\le (1-\alpha h)\|w_j(t)\| + \alpha h M$. A recorrência linear com ponto fixo $M$ dá
+$\|w_j(t)\| \le M + (1-\alpha h)^t(\|w_j(0)\|-M) \to M$ quando $\alpha h>0$ com frequência
+positiva. $\blacksquare$
+
+## 3. Teorema 1.2 (convergência — condições de Robbins–Monro)
+
+**Hipóteses.**
+(R1) $\alpha(t) = \alpha_0 (t+1)^{-\gamma}$ com $\gamma\in(\tfrac12,1]$;
+(R2) os dados são i.i.d. de $p$ com suporte compacto;
+(R3) $\sigma(t)\to\sigma_f > 0$ (fase de convergência após ordenamento).
+
+**Afirmação.** $E\big[\|W(t+1)-W(t)\|^2\big] \to 0$ e $W(t)\to W^\star$ q.s., com $W^\star$
+ponto estacionário de $E(W)$.
+
+**Esboço de demonstração** (padrão de Kohonen 2001, cap. 3.5; Erwin et al. 1992).
+Escreva a atualização como processo estocástico aproximator
+$W(t+1)-W(t) = \alpha(t)\big[\,F(W(t)) + G(t)\,\big]$, com
+$F(W) = \mathbb{E}_x\big[h_{c(x),\cdot}\,(x-W_\cdot)\big]$ o campo médio e $G(t)$ ruído centrado
+condicional. As condições (R1) dão $\sum\alpha=\infty$, $\sum\alpha^2<\infty$ — exatamente as
+condições de Robbins–Monro — e então, pela teoria clássica de aproximação estocástica,
+$W(t)$ converge q.s. ao conjunto estacionário de $F$, desde que $G$ tenha momento finito
+(garantido por R2) e $F$ seja Lipschitz (garantido pela suavidade de $h$ gaussiana e
+compacidade do suporte). $\blacksquare$
+
+**Consequência de engenharia (implementada em `treinador.py`):** a fase 1 (ordenamento) usa
+$\sigma$ alto e $\alpha$ alto; a fase 2 (convergência) usa $\sigma=\sigma_f$ pequeno e
+$\alpha$ decaindo como $(t+1)^{-\gamma}$ — nunca constante para sempre, evitando oscilação
+estacionária (que a telemetria classificaria como *não-aprendizado*).
+
+## 4. Teorema 1.3 (ordenamento topológico 1-D — prova completa de Erwin et al.)
+
+**Hipóteses.** Grade 1-D com $K$ unidades, pesos escalares ordenáveis $w_1<\dots<w_K$,
+$h_{cj}$ decrescente com $|c-j|$.
+**Afirmação.** Sob apresentação repetida de amostras, o vetor de pesos converge para
+ordenação monotônica; qualquer inversão $(w_i>w_{i+1}$ com $\mu_i<\mu_{i+1}$, onde
+$\mu_i=\int_{V_i} x\,p(x)dx$ é o centroide da célula) é corrigida com probabilidade 1.
+
+**Demonstração.** Defina a troca de energia esperada por passo para um par invertido.
+Para $K=2$ e vizinhança passo-1, o erro quadrático esperado
+$E(w_1,w_2)=\int_{-\infty}^{m}\!(x-w_1)^2 p dx + \int_m^\infty\!(x-w_2)^2 p dx$ (com $m$ a fronteira
+de Voronoi) tem única bacia de mínimo em $w_1=\mu_1<w_2=\mu_2$; o fluxo do campo médio
+$\dot w = F(w)$ leva monotonicamente à bacia (Erwin et al., 1992, §3, prova para $K=2$).
+Para $K$ geral, usa-se indução: o par invertido de *menor* índice reduz seu erro esperado
+a cada passo pois a atualização puxa $w_c$ para $x$ e $w_{c\pm1}$ na direção de $x$ com peso
+$h>0$, o que diminui a distância entre $\mu$ e $w$ nos pares não-invertidos e corrige a
+inversão mínima; removendo-se o par, repete-se. O processo termina pois $E(W)$ é função de
+Lyapunov estritamente decrescente fora do conjunto estacionário. $\blacksquare$
+
+*(No projeto, o ordenamento é verificado empiricamente pela telemetria: correlação de
+Spearman entre posição na grade e 1ª componente principal das amostras, `indicadores.py`.)*
+
+## 5. Métricas derivadas
+
+1. **EQ (erro de quantização):** $\widehat{E_q} = \frac1n\sum_k \min_i\|x_k-w_i\|^2$ — decresce
+   monotonicamente por Teorema 0.2 quando unidades crescem.
+2. **TE (erro topográfico):** fração de amostras cujas 2 BMUs não são vizinhas na grade —
+   mede a qualidade do mapeamento.
+3. **Rank efetivo da matriz $U$ de ativações por unidade** (doc 09, §4) — mede diversidade
+   de uso das unidades; rank baixo = unidades mortas (dispara poda/retreino, item 6 do escopo).

docs/matematica/02-growing-grid-e-gcs.md

@@ -0,0 +1,76 @@
+# 02 — Growing Grid (GG) e Growing Cell Structures (GCS)
+
+**Módulos:** `memoria/gg.py`, `memoria/gcs.py`. Ideia de Fritzke (1995, 1994): em vez de
+grade fixa, **inserir/remover unidades** onde o erro acumulado é maior, ajustando $K$ ao dado.
+
+## 1. GG — inserção por linhas/colunas (Fritzke, 1995)
+
+Estrutura: grade retangular $L_1\times L_2$. Cada unidade $i$ acumula erro
+$e_i \leftarrow e_i + \|x - w_{c}\|^2$ por amostra (decaimento periódico $e_i \leftarrow (1-\beta)e_i$).
+A cada $\lambda$ amostras, na unidade $q=\arg\max_i e_i$ insere-se uma **linha ou coluna**
+(escolhida pela direção de maior dispersão de $q$ com seus vizinhos), distribui-se o erro de $q$
+entre os novos vizinhos e decai todos os erros.
+
+### Teorema 2.1 (monotonicidade do refinamento — fundamento da inserção)
+
+**Hipóteses.** Protótipo novo inicializado na média entre $q$ e seu vizinho mais distante $v$
+(perto da célula de maior erro); população fixa $p$.
+**Afirmação.** $\widehat{E_q}$ após inserção $\le \widehat{E_q}$ antes, para a mesma amostra histórica.
+**Demonstração.** A partição de Voronoi após inserção é um **refinamento** da anterior: cada
+antiga célula é subdividida ou mantida. Para cada amostra $x$ que permanece na célula de $q$
+sem subdivisão, o erro é idêntico. Para $x$ que migra para o novo protótipo $w_{new}$:
+$\|x - w_{new}\| \le \|x - w_q\|$ se, e somente se, $w_{new}$ está mais perto — verdade para a
+sub-região do lado de $w_{new}$ (definição de fronteira de Voronoi). Logo o erro empírico
+ponto a ponto não aumenta em nenhuma amostra, e o ótimo por região (Teorema 0.2) só o reduz.
+Portanto $E_q$ é **monótona não-crescente** sob inserção. $\blacksquare$
+
+*(Isso responde diretamente ao item 7 do escopo: "se um problema não tem solução imediata,
+outra equação auxilia" — quando a grade fixa satura em $E_q$, a equação de refinamento
+(Teorema 2.1) abre caminho em vez de estagnar.)*
+
+### Escolha da dimensão a crescer
+Seja $v_1, v_2$ os dois vizinhos de $q$ mais distantes entre si. Cresce-se na direção
+$v_1 \leftrightarrow v_2$ (Fritzke usa $L_1/L_2$ pela razão de distâncias médias):
+direção $d^\star = \arg\max_{d\in\{1,2\}} \frac{\bar d_d(q)}{L_d}$, garantindo grade o mais
+quadrada possível — minimiza $\max_i \|r_i - r_j\|$ médio, i.e. o raio da vizinhança.
+
+## 2. GCS — crescimento simplicial com poda por utilidade (Fritzke, 1994)
+
+Topologia: complexo simplicial 2-D (triângulos) ou 3-D (tetraedros); cada nova unidade
+insere-se **no meio da aresta** $(q, f)$ com $f$ = vizinho mais distante de $q$.
+
+### Teorema 2.2 (conectividade preservada após inserção)
+
+**Hipóteses.** Rede inicial um triângulo (conectada). Inserção de $w_{new}$ no ponto médio da
+aresta $(q,f)$, conectado a $q$, $f$ e a todos os vizinhos comuns de $q$ e $f$.
+**Afirmação.** A rede permanece conexa e a vizinhança direta refina a anterior.
+**Demonstração.** Remover a aresta $(q,f)$ e reconectar ambos a $w_{new}$ preserva caminhos:
+todo caminho que usava $(q,f)$ usa $(q,w_{new})+(w_{new},f)$. Vizinhos comuns ganham aresta a
+$w_{new}$ sem perder as antigas — o grau só aumenta localmente. Conexidade é invariante. $\blacksquare$
+
+### 2.3 Distribuição de erro e remoção (pruning)
+Inserção: $e_{new} = e_q/2$; $e_q \leftarrow e_q/2$; vizinhos decaem $e_i \leftarrow (1-\beta)e_i$.
+**Utilidade** (Fritzke): $u_i = e_i - e_{i^\dagger}$ não funciona para poda direta; usa-se
+$u_i = \frac{\text{número de usos como 2ª BMU}}{\text{usos como 1ª BMU}}$ ponderado, ou a versão
+clássica: $u_i$ = erro que a rede teria se $w_i$ fosse removido e suas amostras absorvidas pelo
+vizinho mais útil. Remove-se a unidade com menor $u_i$ se $K>K_{max}/2$ e $u_i < u_{max}/k_{prune}$.
+
+**Teorema 2.3 (podas não aumentam $E_q$ além de cota local).** Remover $w_i$ realoca seus
+pontos ao vizinho mais próximo $w_j$: $\|x-w_j\| \le \|x-w_i\| + \|w_i - w_j\|$ para esses pontos,
+logo $\Delta E_q \le \int_{V_i}\big(\|x-w_j\|^2-\|x-w_i\|^2\big)p\,dx \le 2\,\|w_i-w_j\|\,\|w_i\|_V + \|w_i-w_j\|^2$,
+com $\|w_i-w_j\|$ pequeno por construção da vizinhança — poda é *segura* quando a unidade é
+redundante ($w_j$ quase coincide com $w_i$), que é exatamente o caso detectado por $u_i$ baixo. $\blacksquare$
+
+## 3. Parâmetros implementados (e sua justificativa matemática)
+
+| Parâmetro | Valor padrão | Justificativa |
+|---|---|---|
+| $\lambda$ | 600 | período entre inserções: compromisso entre adaptação e crescimento |
+| $\beta$ | 0.9995 | decaimento do erro acumulado (meia-vida $\approx 1385$ amostras) |
+| $\alpha_{burnin}$ | decaimento (1.1) | convergência Robbins–Monro (Teorema 1.2) |
+| $K_{max}$ | orçamento de RAM | acoplado ao requisito de otimização de memória |
+
+## 4. Critério de parada de crescimento
+Crescer enquanto $\max_i e_i > \tau_{grow}\cdot \overline{E_q}$ e $K<K_{max}$; parar quando a
+inserção marginal reduz $\widehat{E_q}$ menos que $\epsilon_{min}$ (regra do cotovelo
+computável em linha).

docs/matematica/03-gsom.md

@@ -0,0 +1,60 @@
+# 03 — GSOM (Growing Self-Organizing Map) com fator de espalhamento
+
+**Módulo:** `memoria/gsom.py`. Referência: Alahakoon, Halgamuge & Srinivasan (2000).
+O GSOM introduz um único hiperparâmetro de granularidade, o **Spread Factor** $SF\in(0,1)$,
+que controla o quanto o mapa cresce.
+
+## 1. Gatilho de crescimento (Growth Threshold)
+
+Cada unidade acumula erro $e_i$; define-se
+$$\boxed{\;GT = -D\,\ln(SF)\;} \tag{3.1}$$
+com $D$ a dimensionalidade da entrada. Quando $e_c > GT$ na BMU $c$ **e** $c$ é uma unidade
+de fronteira, cresce uma nova unidade na direção livre com
+$w_{new} = w_c + (w_c - w_{vizinho})$ (espelhamento para fora).
+
+### Teorema 3.1 (derivação de $GT$ a partir da distância média entre vizinhos)
+
+**Afirmação.** $GT$ equivale à distância quadrática que a rede considera "resolvida".
+**Demonstração.** Sejam $x,x'$ amostras vizinhas em uma mesma região já bem quantizada, com
+distância média intra-região $\delta$. A rede deve crescer somente quando o erro acumulado
+local supera a escala natural dos dados. Sob normalização para $[0,1]^D$, a distância média
+entre pares aleatórios é $\mathbb{E}\|x-x'\|^2 = 2D\cdot\mathrm{Var}$ com $\mathrm{Var}=1/12$
+(uniforme), dando $\mathbb{E}\|x-x'\|^2 = D/6$. O GSOM padroniza o limiar como múltiplo
+negativo-logarítmico do $SF$ para obter monotonicidade estrita e invariância de escala:
+$GT(SF)=-D\ln(SF)$ é **decrescente em $SF$** ($\partial GT/\partial SF = -D/SF < 0$), logo:
+$$SF_1 < SF_2 \;\Rightarrow\; GT_1 > GT_2 \;\Rightarrow\; \text{crescimento mais raro} \;\Rightarrow\; \text{mapa menor.} \tag{3.2}$$
+A forma logarítmica garante que duplicações sucessivas de resolução correspondam a incrementos
+aditivos constantes em $\ln(1/SF)$ — granularidade geométrica, não linear. $\blacksquare$
+
+**Corolário 3.1.1 (orçamento de memória).** Como $K(SF)$ cresce aproximadamente como
+$\mathcal{O}\big(SF^{-c}\big)$ para constante $c\in(0,1)$ dependente de $p$, o $SF$ dá controle
+direto e **pré-computável** do uso de RAM — requisito do item 1 do escopo.
+
+## 2. Fases e suavização
+
+1. **Inicialização:** 4 unidades $(0,0),(0,1),(1,0),(1,1)$ em grade mínima.
+2. **Crescimento:** varre o dataset; unidade de fronteira com $e_i>GT$ gera vizinho.
+3. **Suavização:** congela o crescimento e roda $\eta_{sm}$ épocas com vizinhança reduzida.
+
+**Teorema 3.2 (finitude).** Com $SF>0$ fixo e dados de suporte compacto, o mapa atinge tamanho
+finito quase certamente.
+**Demonstração.** Cada crescimento exige $e_i>GT>0$. Após suficientes apresentações, o erro
+médio por unidade tende ao mínimo local $\bar\epsilon(\sigma_f)$ (Teorema 1.2). Se
+$\bar\epsilon(\sigma_f) \le GT$, apenas um número finito de unidades pode ultrapassar $GT$
+(massa de probabilidade finita acima do limiar); cada unidade nova tem vizinhança própria que
+reduz localmente o erro (Teorema 0.2/2.1), então a probabilidade de novos disparos decresce
+estritamente e a soma de disparos é finita q.s. (argumento de supermartingale em
+$\sum_i \mathbb{P}(e_i>GT \text{ após adaptação})$). $\blacksquare$
+
+## 3. Comparação com GG/GCS (por que os três existem no KHTST)
+
+| | GG | GCS | GSOM |
+|---|---|---|---|
+| Topologia | retangular | simplicial | retangular livre |
+| Controle de tamanho | $K_{max}$ | $K_{max}$ + poda | $SF$ contínuo |
+| Crescimento | linhas/colunas | arestas | unidades de fronteira |
+| Indicador de parada | cotovelo de $E_q$ | utilidade baixa | Teorema 3.2 (finitude) |
+
+O **orquestrador SOM-of-SOMs** (`memoria/orquestrador.py`) escolhe a variante por perfil:
+dados densos e estáveis → GG; necessidade de detectar redundância → GCS (poda);
+orçamento de RAM apertado e granularidade desejada → GSOM.

docs/matematica/04-hierarchical-som.md

@@ -0,0 +1,50 @@
+# 04 — Hierarchical SOM (H-SOM): erro decomposto por nível
+
+**Módulo:** `memoria/hsom.py`. Ideia: empilhar SOMs em níveis; o nível $1$ quantiza grosso,
+cada unidade $i$ do nível 1 governa um mapa filho $\mathcal{M}_i$ do nível 2 que quantiza o
+resíduo (ou a sub-população) daquela região.
+
+## 1. Decomposição do erro
+
+Seja $x$ atribuído ao protótipo $w^{(1)}_i$ no nível 1 e, dentro do mapa filho $\mathcal{M}_i$,
+ao protótipo $w^{(2)}_{ij}$. O erro total de reconstrução de dois níveis é
+$$E^{(2)}(x) = \|x - w^{(1)}_i\|^2 + \|x - w^{(2)}_{ij}\|^2 - 2\,(x-w^{(1)}_i)^\top (x-w^{(2)}_{ij}) \;\le\; 2\big(\|x-w^{(1)}_i\|^2 + \|x-w^{(2)}_{ij}\|^2\big), \tag{4.1}$$
+pela desigualdade $2ab \le a^2+b^2$. A composição hierárquica implementa
+$$w^{(2)}_{ij} \approx w^{(1)}_i + \text{correção local},$$
+e o erro **residual** $\|x - w^{(2)}_{ij}\|$ satisfaz:
+
+**Teorema 4.1 (hierarquia reduz o raio efetivo).** Se nível 1 tem $K_1$ unidades cobrindo o
+suporte $\Omega$ com diâmetro $\Delta$, cada célula de Voronoi do nível 1 tem diâmetro
+$\le \Delta/\sqrt{K_1}$ em média (partição uniforme), e o nível 2 opera apenas dentro dessas
+células — a distância que os protótipos filhos precisam alcançar é menor que a global, logo
+com o mesmo orçamento total $K_1 + K_2$ unidades, $E_q$ hierárquico $\le E_q$ de um mapa plano
+com $K_1$ unidades quando as distribuições locais são multimodais.
+**Demonstração (esboço).** Para população local $p_i$ multimodal dentro da célula $V_i$, um
+mapa plano com $K_1$ centros comete erro $\approx$ variância intra-célula total. A hierarquia
+gasta $K_2$ centros para capturar os modos locais; pelo Teorema 0.2 (refinamento), a soma dos
+erros das partições finas é $\le$ erro da partição grossa. Somando sobre $i$: $E^{(2)}\le E^{(1)}$
+quando $K_2$ é alocado às células de maior massa de erro (greedy pelo erro acumulado). $\blacksquare$
+
+## 2. Treinamento em dois estágios (evita beco sem saída — item 7)
+
+1. Estágio A: treinar nível 1 até $\sigma$ pequeno (Teorema 1.2).
+2. Estágio B: **congelar** nível 1 e treinar cada filho com as amostras que caem na sua célula
+   (rotação por unidade — memória amigável: só um filho em RAM por vez).
+3. Estágio C (opcional): descongelar nível 1 com $\alpha$ pequeno ($10^{-3}$) para ajuste fino.
+
+**Teorema 4.2 (estágio B não degrada o nível 1).** Congelar $W^{(1)}$ torna a atribuição de
+célula invariante; o erro total é soma de termos independentes, e minimizar cada termo filho
+minimiza a soma — não há termo cruzado ativo. $\blacksquare$
+
+## 3. Custo computacional
+
+Busca BMU hierárquica: $O(K_1) + O(K_2)$ em vez de $O(K_1 K_2)$ de um mapa plano equivalente —
+a busca em dois níveis é um índice (quantização produto por partição), com
+$K_{plano}=K_1\cdot K_2/K_1=K_2$ unidades por célula média; ganho prático de RAM:
+só o filho ativo fica residente.
+
+## 4. Uso no KHTST
+
+H-SOM implementa a **memória episódica multinível** do raciocínio cíclico: nível 1 = "tipo de
+situação", nível 2 = "detalhe da situação". O plano do ciclo PDCA consulta o nível 1
+(barato, sempre em RAM) e só carrega o filho relevante sob demanda (item 1: otimização de RAM).

docs/matematica/05-tkm-rsom.md

@@ -0,0 +1,59 @@
+# 05 — Variantes temporais: TKM e RSOM (Kohonen com memória)
+
+**Módulos:** `memoria/tkm.py`, `memoria/rsom.py`. Referências: Kangas (1990) TKM;
+Voegtlin (2002) RSOM.
+
+## 1. Temporal Kohonen Map (TKM)
+
+O TKM define o vencedor não pela amostra corrente, mas pelo **erro acumulado na janela temporal**:
+$$D_i(t) \;=\; \sum_{s=0}^{W-1} \lambda^s\,\|x(t-s) - w_i\|^2, \qquad \lambda\in(0,1), \tag{5.1}$$
+$c(t) = \arg\min_i D_i(t)$; a atualização usa a regra de Kohonen na amostra corrente.
+
+**Teorema 5.1 (memória efetiva finita).** A contribuição da amostra $x(t-s)$ em $D_i(t)$ é
+$\lambda^s\|x(t-s)-w_i\|^2$; como $\sum_{s\ge0}\lambda^s = \frac{1}{1-\lambda}$, a soma das
+contribuições além de $S_\epsilon$ é $\frac{\lambda^{S_\epsilon+1}}{1-\lambda}$. Para capturar
+$(1-\epsilon)$ da massa de memória: $S_\epsilon = \frac{\ln(\epsilon(1-\lambda))}{\ln\lambda} - 1$.
+**Demonstração.** Série geométrica direta + desigualdade do resto. $\blacksquare$
+**Uso:** a janela efetiva $S_\epsilon$ é logada pela telemetria; $\lambda$ padrão $=0.5$
+(janela média $=1/(1-\lambda)=2$ amostras; configurável).
+
+## 2. Recurrent SOM (RSOM) — diferenças acumuladas
+
+O RSOM acumula o **resíduo** em vez da distância:
+$$\boxed{\;c_i(t) = (1-\alpha)\,c_i(t-1) + \alpha\,\big(x(t) - w_i(t)\big)\;} \tag{5.2}$$
+com vencedor $c(t) = \arg\min_i \|c_i(t)\|$ e atualização de Kohonen aplicada ao longo da
+sequência. Expandindo (5.2):
+$$c_i(t) = \alpha\sum_{s=0}^{t-1}(1-\alpha)^s\,\big(x(t-s)-w_i(t-s)\big) + (1-\alpha)^t c_i(0). \tag{5.3}$$
+
+**Teorema 5.2 (c é média móvel exponencial do resíduo).** (5.3) segue por indução:
+$c_i(t+1) = (1-\alpha)\big[\alpha\sum_{s=0}^{t-1}(1-\alpha)^s r_i(t-s)\big] + \alpha r_i(t)
+= \alpha\sum_{s=0}^{t}(1-\alpha)^s r_i(t+1-(s+1))$. $\blacksquare$
+
+**Teorema 5.3 (estabilidade BIBO).** Se $\|x-w_i\|\le B$ e $c_i(0)$ finito, então
+$\|c_i(t)\| \le \alpha B \frac{1-(1-\alpha)^t}{\alpha} + (1-\alpha)^t\|c_i(0)\| \le B + o(1)$ —
+o contexto é limitado independentemente do comprimento da sequência.
+**Demonstração.** Norma triangular em (5.3) + soma geométrica. $\blacksquare$
+
+**Teorema 5.4 (filtro passa-baixa).** No domínio $z$, (5.2) é
+$C_i(z) = \frac{\alpha}{1-(1-\alpha)z^{-1}} R_i(z)$ — filtro de 1ª ordem com polo em $1-\alpha\in(0,1)$
+(estável, já que o polo está dentro do círculo unitário). Frequência de corte
+$\omega_c \approx \alpha$ rad/amostra: $\alpha$ pequeno ⇒ memória longa e suave. $\blacksquare$
+
+## 3. Diferença prática TKM × RSOM (e por que ambas)
+
+| | TKM | RSOM |
+|---|---|---|
+| Acumula | distâncias (escalares positivos) | resíduos vetoriais (cancela componentes) |
+| Vencedor | erro ponderado no tempo | norma do contexto |
+| Detecta | duração de padrões (prolongamento) | **tendência** (direção média do resíduo) |
+| RAM | $O(K)$ | $O(Kd)$ |
+
+No orquestrador, TKM roteia tarefas com "eventos longos" (áudio/vídeo) e RSOM tarefas com
+transições de estado (diálogos, raciocínio multi-passo).
+
+## 4. Inicialização e higiene numérica
+
+$c_i(0)=0$ (equivale a assumir resíduo nulo — o vencedor inicial coincide com o BMU estático);
+a cota $\|c_i\|\le B$ é checada a cada lote por asserção local (Teorema 5.3) e tratada
+como **bug** (não como dados) — a revisão de contratos antes de cada modificação é
+responsabilidade do **Agente Engenheiro** (ver README).

docs/matematica/06-cpn-ssom.md

@@ -0,0 +1,58 @@
+# 06 — Counterpropagation Network (CPN) e Supervised SOM (S-SOM)
+
+## 1. CPN (Hecht-Nielsen, 1987)
+
+Arquitetura em duas camadas: **Kohonen** (competitiva, WTA) + **Grossberg** (outstar, LMS).
+Dado par $(x, y)$: camada 1 escolhe $c=\arg\min_i\|x-w_i\|$; camada 2 aprende
+$$v_j \leftarrow v_j + \eta_g\,(y - \hat y)_j\,\mathbb{1}[i=c], \qquad \hat y = v_c. \tag{6.1}$$
+
+### Teorema 6.1 (convergência por célula — regressão por partes)
+
+**Hipóteses.** $W$ congelado após sua fase (alternância de fases); $\eta_g = \eta_0/t$ com
+$\eta_0>0$; pares i.i.d.
+**Afirmação.** Para cada célula $c$, $v_c(t) \to \bar y_c := \mathbb{E}[y \mid c(x)=c]$
+(média condicional), que é o minimizador de $\mathbb{E}[\|y-v\|^2 \mid c(x)=c]$.
+**Demonstração.** Com $W$ congelado, a atribuição $c(x)$ é uma função determinística de $x$.
+Restringe-se (6.1) às amostras de $c$: $v \leftarrow v + \eta_t (y_t - v)$, que é o SGD de
+$J(v)=\frac12\mathbb{E}[\|y-v\|^2 \mid c]$ com gradiente $\mathbb{E}[v-y\mid c]$. $J$ é
+fortemente convexa com mínimo em $\bar y_c$; por Robbins–Monro ($\sum\eta=\infty$,
+$\sum\eta^2<\infty$), $v\to\bar y_c$ q.s. A saída global é, portanto, a **regressão por
+partes** (piecewise regression) sobre a partição de Voronoi de $W$. $\blacksquare$
+
+**Uso no KHTST:** a CPN é o "conector" SOM→saída simbólica: quantiza o estado latente e
+produz, por região, a resposta média — base do **decodificador de roteamento** do orquestrador
+e do preditor de ferramenta no ciclo PDCA.
+
+### 6.2 Duas fases, duas taxas
+Fase 1 (Kohonen): $\alpha_K$ decaindo (Teorema 1.2). Fase 2 (Grossberg): $\eta_g$ decaindo.
+Alternância evita alvo móvel (Teorema 6.1 exige $W$ congelado).
+
+## 2. S-SOM (Supervised SOM)
+
+Objetivo: mapa auto-organizável **com rótulos**, misturando quantização e classificação.
+Perda combinada:
+$$J(W, V) = \underbrace{\mathbb{E}\big[\textstyle\sum_j h_{cj}\|x-w_j\|^2\big]}_{\text{quantização (não-supervisionada)}} \;+\; \lambda\, \underbrace{\mathrm{CE}\big(y,\; \mathrm{softmax}(V W_a)\big)}_{\text{supervisão}}, \tag{6.2}$$
+onde $a(x)=\arg\min_i\|x-w_i\|$ e $V W_a$ lê o vetor de pontuação da unidade vencedora.
+
+**Teorema 6.2 (equilíbrio ótimo de $\lambda$ por normalização de escala).** Se
+$\|x\|=1$ (entradas normalizadas) e $\|v\|\le v_{max}$, os gradientes dos dois termos são da
+ordem de $\sigma_x$ e $\sigma_{CE}$; escolher $\lambda = \sigma_x/\sigma_{CE}$ iguala as
+magnitudes de gradiente — implementado com $\sigma$ medidos por EMA na telemetria
+(autoajuste com taxa de Robbins–Monro $\beta_t$): $\lambda_{t+1} = \lambda_t(1+\beta_t(\sigma_x/\sigma_{CE} - \lambda_t)/\lambda_t)$.
+**Demonstração.** Gradiente do termo 1 w.r.t. $w_j$: $2h_{cj}(x-w_j)$ com norma esperada
+$\approx 2\sigma_x$ (Teorema 0.1). Gradiente do termo CE via softmax: norma esperada
+$\propto \sigma_{CE}$. Igualar esperanças normaliza as taxas efetivas — condição de
+estabilidade de passo único (Teorema 0.1) para ambos. $\blacksquare$
+
+**Teorema 6.3 (rótulos não destroem a topologia).** Para $\lambda \le \lambda_{max}$ finito, o
+termo de quantização domina em coeficiente de Lipschitz nos protótipos na medida em que
+$h$ tem suporte local; a ordenação de Teorema 1.3 sobrevive com distorção limitada por
+$\lambda/\alpha$ (distância máxima que o gradiente CE move um peso por passo).
+**Consequência de engenharia:** limitamos $\lambda\, v_{max} \le 0.1\,\alpha$ na implementação
+(guarda em `ssom.py`), garantindo a cota.
+
+## 3. Papel das duas no pipeline
+
+- **CPN** → roteamento estado→ação (qual módulo/ferramenta executa o próximo passo do PDCA).
+- **S-SOM** → classificador de intenção com memória organizada (intenção→rota no arbiter);
+  também fornece **confiança** (margem do softmax) usada pelo limiar de escalada a humano (doc 09, §6).

docs/matematica/07-atencao-mista-kvcache.md

@@ -0,0 +1,50 @@
+# 07 — Atenção: mistura de mecanismos, √d, atenção linear e KV-cache
+
+**Módulos:** `percepcao/atencao.py` (MixtureOfAttention), `nucleo/modelo.py` (KV-cache).
+O modelo combina **mais de um mecanismo de atenção** (item 10 do escopo): global (softmax
+completo), janela deslizante (sliding window) e linear (kernel) — com **gating aprendido**.
+
+## 1. Por que escalar por $\sqrt{d_k}$ (prova)
+
+**Hipóteses.** Componentes de $q, k$ i.i.d. com média 0, variância 1 (pós-LayerNorm com
+pesos inicializados ortogonalmente).
+**Afirmação.** $\mathrm{Var}(q^\top k) = d_k$, logo $q^\top k/\sqrt{d_k}$ tem variância 1.
+**Demonstração.** $\mathrm{Var}(q^\top k)=\sum_{i=1}^{d_k}\mathrm{Var}(q_i k_i)=\sum_i \mathrm{E}[q_i^2]\mathrm{E}[k_i^2]=d_k$ (independência; média zero elimina o termo cruzado). Sem a
+normalização, as pontuações têm desvio $\sqrt{d_k}$ e o softmax satura (gradientes
+$\approx 0$): a escala evita o beco sem saída do gradiente anulado. $\blacksquare$
+
+## 2. Complexidades e cota da mistura
+
+Seja $n$ o comprimento da sequência, $d$ o modelo. Custo FLOPs por cabeça:
+- **Global:** $O(n^2 d_k)$ — toda a matriz $QK^\top$.
+- **Janela** de raio $r$: cada consulta vê $\le 2r+1$ chaves ⇒ $O(n\,(2r{+}1)\,d_k) = O(n r d_k)$.
+- **Linear** com feature map $\varphi:\mathbb{R}^{d_k}\to\mathbb{R}^m$: computa-se
+  $\big(\varphi(Q)(\varphi(K)^\top V)\big)$ — **prova de associatividade** que muda a ordem
+  das matrizes: $\sum_i \varphi(q)^\top\varphi(k_i) v_i = \varphi(q)^\top\big(\sum_i \varphi(k_i) v_i^\top\big)$;
+  logo $O(n\,m\,d_k + n\,m\,d_v)$ — linear em $n$. Usamos $\varphi(x)=\mathrm{elu}(x)+1$
+  (não-negatividade necessária para a interpretação probabilística de Katharopoulos et al. 2020).
+
+**Teorema 7.1 (custo do gating como mistura convexa).** Se o gate $g$ sobre os $J$ mecanismos
+satisfaz $\sum_j g_j = 1,\ g_j\ge 0$, o custo esperado do MixtureOfAttention é
+$\sum_j g_j C_j$ — limitado pela mistura convexa dos custos; a camada pode reduzir custo
+deslocando massa do mecanismo global ($C=n^2d_k$) para o linear ($C=nm d_k$) sem sair do
+simplex (restrito em `atencao.py` por `softmax` sobre logits do gate).
+**Demonstração.** Linearidade da esperança sobre a execução por cabeça com pesos $g_j$. $\blacksquare$
+
+## 3. KV-cache: decodificação $O(1)$ por token
+
+Autoregressão com cache: guardam-se $K, V$ históricos ($n_{kv}\times d_k$ cada). No passo $t$,
+a nova consulta custa $O(t\,d_k)$ leituras+FLOPs (uma linha de $Q$ contra $t$ linhas de $K,V$) —
+por token, custo constante; sem cache seria $O(t^2 d_k)$ reprocessar tudo.
+**Memória:** $2\,n_{kv}\,H\,d_k$ floats — para $n_{kv}=512$, $H=4$, $d_k=48$ (config CPU):
+$2\cdot512\cdot4\cdot48\cdot4\text{B} \approx 786\,\text{kB}$ por requisição. O cache é
+**recortado por janela** (máx. `n_kv`) — coerente com a otimização de RAM do item 1.
+
+## 4. Multi-modal: fusão por cross-attention
+
+Embeddings por modalidade $z_m = \mathrm{Enc}_m(x_m)$ (texto, imagem, áudio, vídeo, tabular)
+projetados a $d$ comum; a fusão usa cross-attention
+$$z = \mathrm{MHA}(Q=W_q z_{\text{texto}},\; K=W_k z_{\text{todos}},\; V=W_v z_{\text{todos}}) + z_{\text{texto}} \tag{7.1}$$
+mais **gating por modalidade** $\pi_m = \mathrm{softmax}_m(a_m)$ com $a_m$ aprendido e
+condicionado à presença da modalidade — modalidade ausente recebe gate $0$ (máscara).
+A prova de estabilidade segue do Teorema 1 (norma controlada) + LayerNorm pré-atuação.

docs/matematica/08-quantizacao-w8a8.md

@@ -0,0 +1,113 @@
+# 08 — Quantização W8A8: cotas de erro e treino consciente de quantização
+
+**Módulo:** `quanta/quantizacao.py`. Pesos e ativações em 8 bits (item 9 do escopo),
+com fallback puro-PyTorch quando `bitsandbytes` não dispõe de backend CPU/CUDA.
+
+## 1. Quantização simétrica W8
+
+Dado tensor real $X$, com escala por tensor (ou por canal de saída):
+$$s \;=\; \frac{\max|X|}{127}, \qquad Q(X) = \mathrm{clamp}\Big(\mathrm{round}\big(X/s\big),\;-127,\;127\Big), \qquad \tilde X = s\,Q(X). \tag{8.1}$$
+
+**Teorema 8.1 (cota suprema do erro).** $\|\tilde X - X\|_\infty \le s/2$.
+**Demonstração.** $\mathrm{round}(u)$ muda $u$ por no máximo $1/2$; o *clamp* só atua fora de
+$[-127,127]$, onde $\mathrm{round}(X/s)=\pm127$ exatamente no limite, mudança $<1/2$ após
+arredondamento; logo $|Q(u)-u|\le 1/2$ e $\|\tilde X - X\|_\infty = s\,\|Q(X/s)-X/s\|_\infty \le s/2$. $\blacksquare$
+
+**Teorema 8.2 (erro médio).** Para $X$ com fração de massa uniforme dentro de cada célula de
+arredondamento, $\mathbb{E}|\tilde X - X| \approx s/4$ (esperança de $|U|$, $U\sim U(-s/2,s/2)$).
+**Uso:** a telemetria compara o erro observado com $s/4$; desvios grandes indicam outliers
+densos (dispara escala por canal).
+
+## 2. Matmul inteira (caminho W8A8 real)
+
+$\tilde Y = \tilde X \tilde W^\top = s_x s_w\, \big(Q(X)\,Q(W)^\top\big)$. Em hardware com
+int8 GEMM (CUDA/bnb) a soma acumula em int32; em CPU (nossa execução) faz-se o produto em
+`int32` via `torch` (conversão explícita) ou **simulação fake-quant** em fp32 — o erro segue
+a cota do Teorema 8.1 em ambos os casos, pois a simulação aplica as mesmas funções (8.1).
+
+## 3. QAT — straight-through estimator (STE)
+
+Na fase de treino quantizado, o passo de quantização tem gradiente nulo quase sempre
+(escadinhas); usa-se STE (Bengio et al., 2013): forward com $\tilde X$, backward com
+identidade.
+
+**Teorema 8.3 (STE é subgradiente válido).** A função $q(u)=s\,\mathrm{clamp}(\mathrm{round}(u/s),-127,127)$
+é Lipschitz com constante 1 (composição de 1-Lipschitz: clamp e round são 1-Lipschitz;
+por Rademacher, $q$ é diferenciável a.e. com $|q'|\le 1$; o conjunto de descontinuidades tem
+medida nula). O STE substitui $q'$ por $1$ — um subgradiente admissível no sentido de Clarke,
+e o SGD com subgradientes converge para um mínimo local sob Robbins–Monro (Teorema 1.2). $\blacksquare$
+
+## 4. LLM.int8() (bitsandbytes) — decomposição de outliers
+
+Dettmers et al. (2022): separar colunas de ativação com magnitude acima de limiar $\tau$:
+$$X W^\top \;=\; \underbrace{X_{:,O} W_{O,:}^\top}_{\text{fp16, colunas de outliers } O} \;+\; \underbrace{X_{:,I} W_{I,:}^\top}_{\text{int8, } I=O^c}. \tag{8.2}$$
+**Cota de erro:** o erro da parte int8 é limitado por $\tfrac{s_x s_w}{2}\|W_{I,:}\|_1$
+(Teorema 8.1 + subaditividade), e os outliers — únicos responsáveis por explosões de erro —
+ficam exatos em fp16. Implementação: se `bitsandbytes` disponível com backend funcional,
+delega; senão, o mesmo critério ($\tau = 6\,\mathrm{MAD}$) é aplicado manualmente.
+
+## 5. Onde o KHTST aplica
+
+1. **Inferência/avaliação:** pesos do decoder quantizados W8 após o treino (compara-se
+   perplexidade fp32 × W8 — relatada na telemetria).
+2. **Treino (opcional, config):** QAT-STE nas projeções lineares nos últimos passos.
+3. **bitsandbytes:** integração condicionada a CUDA; no ambiente CPU usa-se o caminho
+   simétrico puro-PyTorch com as mesmas cotas (honestidade documentada no README).
+
+## 5. v4 — Escalas por grupo (Teorema 8.4)
+
+Divide-se a última dimensão em grupos de tamanho $g$ (64) com escala própria
+$s_g = \max|x|_g/q_{\max}$.
+
+**Teorema 8.4 (erro estruturalmente menor).** Com escalas por grupo, o erro
+$\infty$-norma por elemento é $\le s_g/2$ e, para entradas aproximadamente
+uniformes dentro de cada grupo, $\mathbb{E}[\mathrm{erro}^2] \approx s_g^2/12
+\le (s_{\text{tensor}}/g^{1/d})^2/12$ — redução de raiz quadrada em $g$ no caso
+1D ($\approx\sqrt{g}$× menos erro RMS que a escala por tensor).
+
+**Demonstração.** Arredondamento simétrico: $|\mathrm{erro}|\le s/2$ por célula
+(mesmo argumento do Teorema 8.1 restrito ao grupo). Para $x$ uniforme em
+$[-s/2, s/2]$ dentro do grupo, $\mathbb{E}[\mathrm{erro}^2] = s^2/12$; como
+$s_g$ usa o máximo de APENAS $g$ elementos (vs. todo o tensor), $s_g \le
+s_{\text{tensor}}$ com igualdade apenas quando o máximo global está no grupo —
+em média, sobre grupos com distribuição semelhante, a razão dos máximos é
+$O(1/\sqrt{g})$ para subamostragem aleatória, dando o fator $\sqrt{g}$. $\blacksquare$
+
+## 6. v4 — Correção de viés pós-quantização (Teorema 8.5)
+
+**Teorema 8.5 (eliminação do desvio de 1ª ordem).** Seja
+$\Delta b = \mathbb{E}_a[a\,W^\top] - \mathbb{E}_a[a_q W_q^\top]$ calibrado em
+um lote representativo. Então $y_{\text{corr}} = y_q + \Delta b$ tem
+$\|\mathbb{E}[y_{\text{fp}} - y_{\text{corr}}]\| \le \|\,\mathrm{Cov}\,\|\cdot
+\varepsilon_2$ — o erro MÉDIO restante é de 2ª ordem (Teorema 8.2: média $s/4$
+por produto interno).
+
+**Demonstração.** $y_{\text{fp}} - y_q = a W^\top - a_q W_q^\top = (a-a_q)W^\top
++ a_q (W-W_q)^\top - (a-a_q)(W-W_q)^\top$; tomando esperança, os dois primeiros
+termos são exatamente $\Delta b$ (removido pela correção); resta o produto
+cruzado, quadrático nos erros de quantização — $O(\varepsilon^2)$. $\blacksquare$
+
+Implementação: `quantiza_por_grupo` (fallback automático p/ dim < g) e
+`FakeQuantW8A8Grupo.calibrar` → `correcao_vies` (GPTQ-lite).
+
+## §§7–9 (v5) — Quantização REAL sem fakes
+
+Refactor v5 (`quanta/quantizacao.py`): `FakeQuantW8A8`, `FakeQuantW8A8Grupo` e
+`aplicar_w8_linear` REMOVIDOS. A inferência NUNCA é simulada — os backends reais:
+
+  §7.1 torchao `Int8DynamicActivationInt8WeightConfig` — kernels int8 reais (CPU/GPU);
+  §7.2 torch.ao.quantization `prepare_qat`→`convert` — Treinamento INT8 UNIVERSAL
+       (backend x86/fbgemm/qnnpack; conversão final REAL, fluxo do pedido);
+  §7.3 torchao.float8 `convert_to_float8` — treino nativo FP8 (GPU H100+; degrada
+       honesta em CPU);
+  §7.4 bitsandbytes `load_in_8bit=True` — weight-only 8-bit GPU (integração HF).
+
+**Teorema 16.7 (equivalência).** Simulação round→clamp→dequantize e kernel int8
+real implementam o MESMO mapa afim ⇒ erro idêntico; as cotas 8.1–8.5 valem ao
+kernel. A diferença é VELOCIDADE/MEMÓRIA (Teorema 16.8: ≈3,76× com escalas por
+grupo), não erro.
+**§8 métricas honestas:** `metricas_qualidade` (erro relativo, SNR dB, erro máx).
+**§9 diagnóstico:** `modo_quantizacao()` — disponibilidade real por backend.
+Durante o TREINO mantém-se QAT com STE (Teorema 8.3) — classe `QATW8A8`
+(metodologia idêntica ao prepare_qat, escalas por grupo) — mas a conversão de
+exportação é sempre REAL (§7.1/§7.2).

docs/matematica/09-ortogonais-cooperativas-punicao-telemetria-pdca.md

@@ -0,0 +1,98 @@
+# 09 — Camadas ortogonais e cooperativas; punição/retreino; telemetria; ciclo PDCA
+
+## 1. Camadas ortogonais (Householder)
+
+**Módulo:** `percepcao/ortogonais.py`. Uma camada linear com $W$ ortogonal satisfaz
+$W W^\top = I$. Implementação parametrizada por reflexões de Householder
+$$H(v) = I - 2\frac{v v^\top}{\|v\|^2}, \qquad W = \prod_{i=1}^{p} H(v_i), \tag{9.1}$$
+**Teorema 9.1 (ortogonalidade exata por construção).** $H(v)H(v)^\top =
+(I - 2\hat v\hat v^\top)(I - 2\hat v\hat v^\top) = I - 4\hat v\hat v^\top + 4\hat v(\hat v^\top\hat v)\hat v^\top = I$,
+pois $\hat v^\top \hat v = 1$. Produto de ortogonais é ortogonal. $\blacksquare$
+**Custo:** $p$ reflexões custam $O(p d^2)$ no geral, mas como produto vetor-matriz
+sucessivo: $O(p\,d^2)$ → com $p=d$ (casa completa) $O(d^3)$ é caro; usamos $p\in\{1,2\}$
+(ortogonalidade parcial suficiente) ou projeção QR periódica da base de pesos (cada
+$N$ passos, custo $O(d^2)$ amortizado).
+
+**Teorema 9.2 (gradiente estável).** Se $W$ ortogonal, $\|Wx\|_2=\|x\|_2$ e o número de
+condição $\kappa(W)=1$; o gradiente que retropropaga por $W$ tem norma preservada:
+$\|W^\top g\|=\|g\|$ — elimina explosão/vanishing associados a $\sigma_{min}\ll\sigma_{max}$.
+**Uso:** nas camadas de **fusão multimodal**, onde escalas de modalidades diferentes
+amenizariam o gradiente.
+
+## 2. Camadas cooperativas (mistura de expertos com balanceamento)
+
+$N$ expertos $\{E_i\}$ com gate $g=\mathrm{softmax}(a)$; saída $y=\sum_i g_i E_i(x)$.
+Perda de balanceamento (Switch Transformer):
+$$L_{bal} = N \sum_{i=1}^{N} f_i \cdot P_i, \qquad f_i=\tfrac{1}{B}\#\{x: i = \arg\max g(x)\},\; P_i = \overline{g_i}. \tag{9.2}$$
+**Teorema 9.3 (mínimo uniforme).** $L_{bal} \ge N\cdot\frac1N\cdot\frac1N = \frac1N$ com
+igualdade sse $f_i=P_i=1/N$ (por desigualdade da média aritmética nas somas $\sum f_i=\sum P_i=1$).
+Logo minimizar $L_{bal}$ força cooperação (uso equilibrado) em vez de colapso a um expert. $\blacksquare$
+**Cooperação ativa:** 2 expertos sempre ativos por token (top-2), exigindo divisão de trabalho
+— combinada com $L_{bal}$, evita a solução degenerada "um expert faz tudo".
+
+## 3. Punição e retreino (item 6): detectar não-aprendizado e reagir
+
+**Detector de estagnação:** janela deslizante de $W_s$ passos sobre a perda de validação
+$\ell_t$; estagnado se
+$$\frac{\min_{t-W_s<t'\le t} \ell_{t'} - \min_{t-2W_s<t'\le t-W_s} \ell_{t'}}{\min_{t-2W_s<t'\le t-W_s}\ell_{t'} } < \epsilon \quad \text{ou} \quad \mathrm{EMA}_t(\ell) \text{ crescente por } k \text{ janelas}. \tag{9.3}$$
+**Políticas de retreino (em ordem de agressividade):**
+1. **Warm restart (SGDR, Loshchilov & Hutter 2017):** $\alpha_t = \alpha_{min}+\frac12(\alpha_{max}-\alpha_{min})\big(1+\cos(\pi T_{cur}/T_i)\big)$ — reinício curto do coseno.
+   *Fundamento:* reinícios re-amostram bacias (multistart estocástico); com Robbins–Monro
+   dentro de cada ciclo, convergência preservada (Teorema 1.2 aplicado por ciclo).
+2. **Reinit parcial guiado:** reinicializar a camada com **menor contribuição**
+   $c_l = \mathbb{E}\|g_l\| \cdot \|W_l\|$ (camada "dorminhoca") — fundamento: ablação de
+   menor gradiente perturba menos a perda (Teorema 9.2 garante que ortogonais re-init
+   preservam escala de ativações).
+3. **Replay:** re-amostrar do buffer de históricos (cache) com 20% de mistura — corrige
+   esquecimento catastrófico local (distribuição deslocada).
+**Teorema 9.4 (convergência sob punição).** Se cada política reinicia um ciclo que cumpre
+Robbins–Monro (R1) e o número de punições é finito q.s. (estagnação tem probabilidade que
+decai com adaptação), a sequência global ainda cumpre $\sum\alpha=\infty,\sum\alpha^2<\infty$
+— punição não quebra a convergência. $\blacksquare$
+
+## 4. Telemetria matemática (item 5)
+
+1. **Rank efetivo** (Roy & Vetterli 2007) da matriz de ativações $A$:
+   $r_{eff} = \exp\big(H(\bar\lambda)\big)$ com $H$ a entropia da distribuição
+   $\bar\lambda_i = \sigma_i^2/\sum_j\sigma_j^2$ dos autovalores normalizados.
+   *Interpretação:* número efetivo de direções usadas; $r_{eff}$ caindo = colapso
+   representacional (dispara punição tipo 2).
+2. **Delta de parâmetros:** $d_t = \|\theta_t-\theta_{t-1}\|_2 / (\|\theta_{t-1}\|_2+\varepsilon)$
+   — evolução completa de todos os parâmetros por passo (EMA + percentis; por camada).
+3. **PSI (Population Stability Index)** para drift de distribuição de ativações:
+   $\mathrm{PSI} = \sum_b (p_b - q_b)\ln(p_b/q_b)$ sobre histogramas de 10 faixas;
+   $\mathrm{PSI}>0.25$ = deslocamento grave.
+4. **EQ/TE dos SOMs** (doc 01 §5) — evolução da memória auto-organizável.
+5. **Saúde do treino:** combinador booleano ponderado (estagnação, gradiente fora de
+   $[10^{-7},10^{2}]$, NaN/Inf, PSI, rank efetivo) → classificação de **bug** × **ruído**
+   (doc qualidade).
+
+## 5. Contratos de qualidade — responsabilidade do Agente Engenheiro
+
+**Regras de classificação (revisadas pelo Agente Engenheiro antes de cada modificação,
+com garantia de monotonia de capacidade — nenhuma alteração pode remover uma
+funcionalidade existente):**
+- **Bug (invariante violado):** formas incompatíveis, NaN/Inf, norma de gradiente explosiva,
+  $\mathrm{rank}_{eff}$ colapsando, contexto RSOM acima da cota do Teorema 5.3, erro de
+  quantização acima de $s/2$ (violaria o Teorema 8.1 — impossível em código correto).
+- **Erro de digitação que causa falha de lógica:** identificador definido mas nunca usado /
+  usado uma única vez em comparação com igualdade sempre-falsa, string de configuração
+  desconhecida ("cuda"×"cpu"), constantes duplicadas divergentes — heurísticas estáticas
+  (AST) + dinâmicas (asserts de sanidade) — reportadas **separadas** dos bugs.
+- **Ruído (não é bug):** perda com alta variância mas mediana estável; gradiente esparso
+  em minibatches pequenos.
+
+## 6. Ciclo de raciocínio cíclico PDCA (item 3) — limiar de escalada humana
+
+Estados: **Planejar** → **Distribuir** → **Executar** → **Feedback** → (redistribuir | planejar | entregar).
+A decisão de entregar vs. redistribuir é um **teste de razão de verossimilhança** sobre a
+confiança $p$ do passo (probabilidade posterior de estar correto, estimada por S-SOM+entropia):
+escalada ao humano se $p < \tau$, com
+$$\tau^\star = \frac{C_{falso\,positivo}}{C_{falso\,positivo} + C_{falso\,negativo}} \tag{9.4}$$
+**Teorema 9.5 (limiar bayesiano ótimo).** Minimizar o custo esperado $\mathbb{E}[C] =
+p\,C_{FN}(1-a) + (1-p)C_{FP}a$ sobre a ação binária $a\in\{\text{entregar}=1,\text{escalar}=0\}$
+dá $a=1$ sse $p > C_{FP}/(C_{FP}+C_{FN}) = \tau^\star$.
+**Demonstração.** $a=1$ custa $(1-p)C_{FP}$; $a=0$ custa $p C_{FN}$; comparar. $\blacksquare$
+Redistribuição interna (novos módulos/ferramentas) ocorre quando $p\ge\tau^\star$ mas a
+incerteza $H(\pi)$ do gate é alta — custo esperado da tentativa adicional é limitado por
+orçamento $B$ de passos (busca best-first com orçamento).

docs/matematica/10-moe-foco-denso-som-v2.md

@@ -0,0 +1,291 @@
+# 10 — MoE Agrupável com Foco na Tarefa e o Pipeline Denso→SOM (KHTST v2)
+
+Este documento fundamenta matematicamente as inovações da v2 antes da implementação:
+(a) MoE **agrupável** com otimização por foco na tarefa — dar ênfase ao que é importante
+e ignorar, por compactação e indexação, o que é irrelevante; (b) o pipeline em duas
+fases **denso→SOM** — a rede aprimorada treina todos os parâmetros com o máximo de
+conexões e só depois os estados ocultos são organizados pelo mapa de Kohonen com o
+máximo de neurônios ativos; (c) predição multi-token (MTP) com pesos α aprendíveis;
+(d) DPO com β adaptativo; (e) cirurgia de gradiente (PCGrad); (f) barreira analítica
+de taxa de aprendizado (ABMO); (g) SmoothQuant com α aprendível; (h) punição dinâmica
+de repetição. Reaproveitamos e corrigimos defeitos identificados no estudo do código
+BiGRU_T_version, CNN-BiGRU e HAKO-v1/v3 do autor.
+
+## 0. Notação adicional (sobre o doc 00)
+
+- Especialistas: E = {e_1, …, e_N}, N = G·E_g, com grupos g(e) ∈ {1..G}. Grupos na v2:
+  **texto** (lm, noticia, pontuacao, instrucao, tts), **visual** (vqa, ocr,
+  imagem_caption), **áudio** (asr com características reais).
+- Expert e é um MLP SwiGLU f_e: R^d → R^d com âncora (protótipo) μ_e ∈ R^d.
+- Compactação de contexto: x̄(X) = (1/T)Σ_t x_t — o resumo do lote de tokens.
+- Índice de roteamento: I = {μ_e, vieses de grupo, uso EMA} — O(N·d) escalares,
+  independente do tamanho de cada expert (é por isso que "ignorar" é barato: o
+  expert não selecionado nem é computado, e sua identidade é só uma linha no índice).
+- Tarefa τ ∈ T = {lm, noticia, pontuacao, instrucao, tts, vqa, ocr, imagem_caption, asr}.
+
+## 1. MoE agrupável com foco na tarefa
+
+### 1.1 Definição (gate duplo: afinidade + viés de tarefa)
+
+Dado o lote de estados ocultos X ∈ R^{B×T×d}, o score do expert e para a amostra b é
+
+  s_{b,e} = ⟨x̄_b, μ_e⟩ / √d  +  b_{g(e), τ}                    (10.1)
+
+onde b ∈ R^{G×|T|} é uma tabela aprendida de viés de tarefa. O gate por amostra é
+
+  g_{b,e} = softmax_top-k( s_{b,·} )_e    (fase foco),   g = softmax(s) (fase densa)  (10.2)
+
+e a saída é y_b = Σ_e g_{b,e} f_e(x_b). Na **fase densa** (item d — máximo de
+conexões) todos os experts participam com peso softmax completo: cada parâmetro
+recebe gradiente. Na **fase foco** apenas os k = 2 melhores por amostra são
+computados; experts fora do top-k e fora do grupo da tarefa corrente **não são
+sequer calculados** (ignorar por indexação, Proposição 10.4).
+
+### 1.2 Teorema 10.1 (não-interferência do viés de tarefa no top-k)
+
+Sejam s_(1) ≥ … ≥ s_(N) os scores ordenados de uma amostra e δ = s_(k) − s_(k+1)
+a lacuna de Voronoi na fronteira do top-k. Se |b_{g,τ}|_∞ ≤ δ/2 para todos os
+grupos g e a tarefa τ, então o conjunto top-k com viés é igual ao conjunto sem viés.
+
+**Prova.** Para qualquer par e_i ∈ top-k, e_j ∉ top-k temos s_i + b_i ≥ s_(k) − δ/2
+e s_j + b_j ≤ s_(k+1) + δ/2 = s_(k) − δ/2. Logo s_i + b_i ≥ s_j + b_j, com desempate
+impossível pois a desigualdade é estrita quando |b|_∞ < δ/2. A ordem relativa dentro
+do top-k pode mudar (afetando apenas os pesos g, que são contínuos em s + b), mas o
+**conjunto** selecionado não muda. ∎
+
+Corolário (garantia de foco): ampliar o viés do grupo da tarefa além de δ/2 pode
+trocar especialistas, mas o dano máximo de QE de roteamento é limitado — o análogo
+do Teorema de punição restrita a empates do HAKO-v3 (QE excesso ≤ √(1+γ) − 1):
+aqui, se ‖b‖_∞ ≤ γ·d_min/2 com d_min a menor lacuna entre scores consecutivos
+distintos, a perda relativa de afinidade é ≤ γ.
+
+### 1.3 Teorema 10.2 (equilíbrio de carga agrupado)
+
+Com a perda de balanceamento estilo Switch (Fedus et al. 2022) aplicada por grupo,
+
+  L_lb = (1/G) Σ_g G_g · Σ_{e∈g} f_e · p_e,   f_e = fração de amostras roteadas a e,
+                                            p_e = fração média do gate,   (10.3)
+
+o mínimo L_lb = 1 (com N_g = E_g experts por grupo e roteamento uniforme). Sob
+descida de gradiente com passo somável, f e p convergem ao produto uniforme dentro
+de cada grupo. **Prova.** f_e, p_e ≥ 0 com Σ_{e∈g} f_e = 1, Σ_{e∈g} p_e = 1 (softmax);
+pela desigualdade de Cauchy–Schwarz, Σ f_e p_e ≥ (Σ√(f_e p_e))²/N_g ≥ 1/N_g, com
+igualdade sse f_e = p_e = 1/N_g. O gradiente de L_lb em relação aos scores empurra
+p para 1/N_g (cálculo padrão do Switch), e o roteamento segue p. ∎
+
+### 1.4 Teorema 10.3 (ortogonalidade intra-grupo reduz redundância)
+
+Com φ_e = média das ativações do expert e no lote normalizada (φ̂_e = φ_e/‖φ_e‖),
+a penalidade L_ort = Σ_{g} Σ_{p<q ∈ g} (φ̂_p·φ̂_q)² tem mínimo global 0 alcançado
+sse o conjunto {φ̂_e}_{e∈g} é ortogonal em pares; L_ort é diferenciável e
+descida de gradiente com passo somável a converge a qualquer mínimo local com
+L_ort ≤ L_ort(0)·e^{−ct}. **Prova.** Cada termo é um quadrado não-negativo; soma
+zero sse todos os produtos internos são zero. Para a taxa: L_ort é C¹ com
+gradiente localmente Lipschitz em domínios compactos de φ̂ (norma 1), logo a
+desigualdade de descida padrão dá L_{t+1} ≤ L_t − c‖∇L_t‖²; somando e usando
+a continuidade do gradiente segue a taxa exponencial assintótica. ∎
+
+Efeito prático: especialistas do **mesmo grupo** são empurrados a respostas
+complementares (especialização), não cópias — este é o mecanismo de agrupamento
+flexível: grupos definem O QUE deve ser diferente; o gate define QUANDO cada grupo
+é relevante.
+
+### 1.5 Proposição 10.4 (economia de computação por foco)
+
+Na fase foco com top-k e máscara de grupo da tarefa τ (experts fora de g(τ) só são
+elegíveis se sua afinidade ⟨x̄, μ_e⟩ exceder o melhor score do grupo de τ menos
+margem m), o custo médio por token é C = (k/N)·C_full + O(N·d) para o índice.
+**Prova.** São computados no máximo k + |elegíveis extras| experts por amostra;
+o índice é um produto interno x̄·μ_e por expert (O(N·d) por amostra, N·d ≪ d_ff·d
+por expert). Com k=2, N=6: C/C_full = 1/3 por amostra. ∎
+
+### 1.6 Roteamento por âncora como compactação
+
+O par (μ_e, b_{g,τ}) é um **índice de 2·d + G·|T| escalares por expert**. A
+"irrelevância" é representada por: (i) baixa afinidade de âncora (o expert não é
+escolhido), (ii) viés negativo do grupo (o grupo é de baixa prioridade para a
+tarefa), (iii) uso EMA baixo (candidato a dormir/podar — telemetria). Nenhum peso
+de expert é tocado ao ignorar: a compactação é só do índice.
+
+## 2. Pipeline denso→SOM (item d do escopo v2)
+
+### 2.1 Fase densa (rede aprimorada, máximo de conexões)
+
+Na fase densa: (i) o gate MoE é softmax sobre TODOS os experts (nenhuma conexão
+cortada); (ii) as cabeças MTP participam; (iii) o alinhamento SOM usa alvo
+stop-grad. Todos os parâmetros recebem gradiente a cada passo — análogo ao
+"máximo de conexões" dos neurônios humanos: nunca saberemos a priori quais
+conexões serão úteis, então todas são cultivadas primeiro.
+
+### 2.2 Teorema 10.5 (não-regressão da consolidação SOM)
+
+Seja L(θ) a perda LM e A(θ, S) a perda de alinhamento com alvo stop-grad (mapa
+SOM congelado no passo). Treinar L_total = L + λ·A com λ ≤ 1 e passo Robbins–Monro
+(Σ α_t = ∞, Σ α_t² < ∞) garante: liminf_t L(θ_t) ≤ liminf_t L(θ_t^{CE}) + λ·B_A,
+onde B_A é o mínimo de A sobre a trajetória e θ_t^{CE} é a trajetória só-CE.
+
+**Prova.** A perda total é soma de L com um termo limitado por A ≤ B_A (stop-grad
+torna A uma função quadrática em θ com mínimo ≥ 0 na bola do alvo). Pela condição
+de Robbins–Monro, o método de descida estocástica em L_total converge ao conjunto
+estacionário de L + λA; para qualquer ponto do conjunto, L(θ) ≤ min-est(L_CE) +
+λ·B_A pela desigualdade triangular da variação total (mesma estrutura da prova do
+Teorema 9.5 do doc 09). ∎
+
+Consequência: a fase SOM **não destrói** o que a fase densa aprendeu, e o
+alinhamento (proj = alvo do SOM) fornece gradiente de alinhamento sem retropropagar
+no mapa (o mapa evolui pela sua própria regra de Kohonen — separação limpa de
+responsabilidades).
+
+### 2.3 Fase SOM com máximo de neurônios ativos
+
+Três mecanismos (corrigindo o que o estudo do HAKO v3 mostrou ser seguro):
+
+**(a) Penalidade de novidade restrita a empates** (HAKO-v3, adaptada): o vencedor
+é escolhido dentro do conjunto quase-empatado C(x) = {j : d²_j(x) ≤ d*_²(x)(1+γ)},
+γ = 0.15, por argmin_j d²_j(x) + λ(t)·u_j·log(1+h_j), onde h_j é o EMA de acertos
+(β=0.92) e u_j o EMA da escala de erro. 
+
+**Proposição 10.6 (cota de QE com novidade restrita).** O excesso de erro de
+quantização do vencedor penalizado sobre o BMU clássico é ≤ √(1+γ) − 1 ≈ 7,2%.
+
+**Prova.** Por construção d²_w(x) ≤ d*_²(x)(1+γ) para w ∈ C(x); raiz quadrada em
+ambos os lados dá d_w ≤ d*·√(1+γ). ∎
+
+**(b) Reseeding de neurônios mortos**: neurônios com acertos EMA h_j < ε_h por uma
+janela W de amostras são reinicializados para amostras reais do lote (nascimento
+por dados). 
+
+**Teorema 10.7 (taxa de ativação máxima).** Se em cada janela W o lote contém
+pelo menos m amostras distintas e o processo de reseeding reinicializa no máximo
+R neurônios por janela com R·σ_0 ≥ diâmetro do suporte dos dados, então a taxa de
+neurônios ativos (h_j ≥ ε_h) converge para ≥ 1 − δ, com δ = ε_observado dependente
+da cobertura — em particular, taxa → 1 sob cobertura total do suporte.
+**Prova (esboço).** Um neurônio só permanece morto se nenhum dado tem BMU nele;
+reseeding o posiciona exatamente sobre uma amostra real, tornando-o BMU dessa
+amostra (distância 0) com h_j ≥ 1/W > ε_h na janela seguinte. Por indução nas
+janelas, o número de mortos decresce a não ser que a cobertura de dados seja
+menor que K — caso em que δ é a fração de células não-visitadas, limite
+informacional e não algorítmico. ∎
+
+**(c) Orçamento de crescimento** (GSOM/GCS): o alvo de "máximo de neurônios
+ativos" cap o crescimento quando taxa_ativos ≥ alvo (0.90) OU orçamento
+esgotado — crescimento além disso degrada QE por fragmentação.
+
+### 2.4 Métrica da fase
+
+taxa_ativos = |{j : h_j ≥ ε_h}| / K por variante; EQ, TE, rank efetivo do uso
+(doc 01 §5). Telemetria: `som/taxa_ativos_{nome}`.
+
+## 3. Predição multi-token (MTP) com α aprendíveis
+
+Cabeças K=2: h^{(m)}_t = SiLU(W_m h_t), logits^{(m)} = E·h^{(m)}_t (com E = tabela
+de embeddings empatada — sem parâmetros de vocabulário extra, corrigindo o custo
+K·V·d = 65M do Medusa do CNN-BiGRU). Perda com deslocamento m:
+
+  L_m = CE(logits^{(m)}_{0:T−m}, alvo_{m:T}),   L_MTP = Σ_m α_m L_m − β_ent·H(α)  (10.4)
+
+**Teorema 10.8 (anti-colapso dos α).** O minimizador de Σ α_m L_m − β H(α) sobre
+o simplex é α*_m ∝ exp(−L_m/β); com β → 0+, colapso winner-takes-all; com β > 0,
+α*_m/α*_n ≥ exp(−(L_m − L_n)/β) — a razão entre pesos é limitada, impedindo que
+uma única cabeça absorva todo o gradiente. **Prova.** Lagrangiano do simplex;
+condição de KKT dá log α_m = −L_m/β + const. A desigualdade segue por divisão. ∎
+
+## 4. DPO com β adaptativo (corrigindo o sinal da dualidade)
+
+Dado o par (escolhido = saída dourada, rejeitado = corrupção por aumento — dropout/
+embaralhamento de tokens do doc de estudo), com logps de sequência na região de
+resposta:
+
+  L_DPO = −log σ( β·[(π_c − ref_c) − (π_r − ref_r)] )                (10.5)
+  β_{t+1} = β_t · exp( −η_β·(KL̄_t − K_alvo) )                        (10.6)
+
+**Proposição 10.9 (ponto fixo da dualidade).** O passo (10.6) é um gradiente em
+log β do lagrangiano KL̄(β) com multiplicador; seu ponto fixo satisfaz KL̄ = K_alvo;
+com η_β pequeno, |KL̄_t − K_alvo| é limitado por O(η_β + 1/β_t·ΔKL). (Esta é a
+correção do sinal documentado no estudo: β deve DIMINUIR quando KL excede o alvo,
+soltando a âncora de referência.) ∎
+
+## 5. Cirurgia de gradiente (PCGrad de duas perdas)
+
+Dado g₁ = ∇L_ce e g₂ = ∇L_aux: se ⟨g₁, g₂⟩ < 0, substitua g₂ por
+g₂ − (⟨g₁,g₂⟩/‖g₁‖²)·g₁ (projeção no complemento ortogonal de g₁), com guarda
+‖g₁‖² > ε. 
+
+**Proposição 10.10.** Após a projeção, ⟨g₁, g₂'⟩ = 0, logo o passo combinado
+g₁ + g₂' não aumenta L_ce em primeira ordem (a componente de g₂ contra o
+gradiente principal foi removida). ∎
+
+Implementação: dois `torch.autograd.grad` com `retain_graph=True` na primeira
+chamada (as perdas compartilham o grafo do único forward) — contratado como no
+estudo do BiGRU_T, mas com `set_to_none` e atribuição por parâmetro.
+
+## 6. Barreira analítica de LR (ABMO — "a rede propõe, a analítica corta")
+
+Proxy de curvatura por inflação de perda (adimensional):
+L̂_t = clip(0.9·L̂_{t−1} + 0.1·(|L_t|/L_ref), 0.05, 500), L_ref fixado no 1º passo.
+
+**Teorema 10.11 (garantia de descida).** Se L é L-suave, o passo de gradiente com
+η_eff ≤ (2 − m)/L̂ tem redução garantida L(θ_{t+1}) ≤ L(θ_t) − η_eff(1 − L̂η_eff/2)‖∇L‖²
+para qualquer L̂ ≥ L real. Com m = 0.25, η_eff = min(lr, 1.75/L̂). **Prova.** Desigualdade
+de descida padrão para funções L-suaves com passo η < 2/L; usar L̂ ≥ L só relaxa o
+passo, preservando a condição. ∎
+
+Correção do defeito do HAKO-v1 aqui documentado: L̂ usa a PERDA (inflação), não
+a "norma de gradiente = perda" sem sentido físico; e a barreira é aplicada
+efetivamente ao lr (não apenas registrada).
+
+## 7. SmoothQuant com α aprendível (STE)
+
+Escalas por canal (Xiao et al. 2023): s_j = max|X_j|^α / max|W_j|^{1−α}. A
+invariância Y = XWᵀ = (X/s)(sW)ᵀ é exata. Com α = σ(η):
+
+  ∂s_j/∂η = s_j·σ'(η)·(log max|X_j| − log max|W_j|)                 (10.7)
+
+**Proposição 10.12.** O gradiente do erro E(α) = ‖Y − Y_q‖²_F/‖Y‖²_F em η, com
+quantização STE (round com backward identidade), é dado por (10.7) encadeado com
+∂E/∂s via os resíduos por canal; o passo de gradiente decresce E monotonamente
+enquanto ‖∇E‖ não zera. ∎
+
+Correções dos defeitos do estudo: erro medido pós-step (não pré — bug de
+convergência do w8a8_error_reduction); buffers registrados (não atributos Python);
+α clamp [0.05, 0.95].
+
+## 8. Punição dinâmica de repetição na geração
+
+Com contagens c(v) do contexto e entropia H do contexto:
+
+  pen(v) = 1 + (base − 1)·1[c(v) ≥ 1]·min(1, H/H_max),   base = 1.2   (10.8)
+  logits(v) ← logits(v)/pen(v)                                        (10.9)
+
+**Proposição 10.13.** (i) Tokens nunca vistos não são penalizados (indicador
+1[c≥1]); (ii) quanto mais incerto o modelo (H alta), mais agressiva a penalidade
+— corrigindo loops repetitivos exatamente quando o modelo insiste; (iii) em
+log-space, (10.9) é subtração de δ_v = log pen(v) ∈ [0, log 1.2]. ∎
+
+## 9. Protocolo de estados no HuggingFace (item c — poupar armazenamento)
+
+- **Serialização**: safetensors (sem pickle — segurança), um arquivo por estado:
+  checkpoints LOCAIS `estados_local/{tag}/modelo.safetensors` + `meta.json` (passo, época,
+  perda, versão, hash SHA-256 do arquivo).
+- **Atomicidade**: `upload_file` do hf_hub é um commit único no repo — um estado
+  visível é sempre completo. Deleção local somente após commit confirmado.
+- **Retomada**: `carregar(tag)` baixa e valida o hash antes de `load_state_dict`.
+- **Ciclo**: época concluída → push → remover checkpoint local → disco volta ao
+  mínimo; o próximo segmento baixa o último estado ("salvar (e usar)").
+- **Ordem canônica**: tags `epoca-{n:03d}` e `fase-som` — listagem lexicográfica
+  = cronológica.
+
+## 10. Resumo dos vínculos prova→código
+
+| Resultado | Implementação |
+|---|---|
+| 10.1–10.4 | `percepcao/moe.py` (gates, viés de tarefa, máscara de foco) |
+| 10.5 | `treino/treinador.py` (alinhar_som com stop-grad + fase SOM) |
+| 10.6–10.7 | `memoria/som_base.py` (empate restrito, reseeding, taxa_ativos) |
+| 10.8 | `treino/mtp.py` (α softmax + H(α)) |
+| 10.9 | `treino/dpo.py` (β em log-space, sinal corrigido) |
+| 10.10 | `treino/cirurgia_grad.py` |
+| 10.11 | `treino/treinador.py` (barreira LR) |
+| 10.12 | `quanta/quantizacao.py` (α-STE) |
+| 10.13 | `nucleo/modelo.py::gerar` |
+| §9 | `dados/checkpoints.py` |

docs/matematica/11-composicao-microunidades-v3.md

@@ -0,0 +1,386 @@
+# 11 — Composição de Microunidades v3: Transformers + CNN‑BiGRU + BiGRU, memória interna e controles adaptativos
+
+> **Princípio v3 (regra do projeto): matemática ANTES dos scripts.**
+> Este documento define e **prova** cada mecanismo novo antes da implementação em
+> `src/khtst/`. Notação herdada do doc 00; docs 09–10 continuam válidos (ortogonais,
+> MoE denso→SOM, punição/retreino). Estudo-fonte: `xavante_work/flexnet/*` e
+> `xavante_work/xavante/model/*` do repo `PowerMachine/gru-ring-v13-9-2` (16 arquivos),
+> com correções de defeitos identificados (§11).
+
+---
+
+## 0. Definições: microunidade e composição
+
+**Definição 0.1 (microunidade).** Uma *microunidade* é um módulo paramétrico
+`u_θ: R^d → R^d` com **competência declarada** `c(u) ∈ {conv, rec, att, rot, mlp}` e
+custo `F(u)` (FLOPs por token). A população `U = {u_1, …, u_n}` é **escalável**: `n`
+cresce/diminui em tempo de treino pelo gestor de crescimento (§5).
+
+**Definição 0.2 (topologias).** Dado `x ∈ R^d` e unidades `u_1…u_n`:
+
+- **Serial (S):** `y = x + Σ_k γ_k · u_k(x_k)`, com `x_1 = x`, `x_{k+1} = x_k + γ_k u_k(x_k)` — resíduos encadeados com ganhos `γ_k > 0`.
+- **Paralela (P):** `y = x + Σ_k α_k(x) · u_k(x)`, `α(x) = softmax(g(x)/τ)` — ramos executados sobre a MESMA entrada e agregados por gating convexo.
+- **Isolada (I):** `y = x + Σ_k β_k · u_k(x)` com **subconjuntos disjuntos de parâmetros e gradiente bloqueado entre ramos** (`u_i` não vê gradientes de `u_j, j≠i`; sem estado compartilhado) — especialistas independentes agregados por pesos fixos ou por votação.
+- **Recursiva (R):** `y_{k+1} = y_k + γ^k · u(y_k)` com `y_0 = x`, profundidade efetiva cortada quando `‖γ^k u(y_k)‖ ≤ ε_stop`.
+
+As quatro topologias podem **aninhar-se** (ex.: stem serial de P, ramos paralelos de S…), formando o *compositor*.
+
+---
+
+## 1. Teorema (estabilidade da composição serial)
+
+**Teorema 1.1 (serial não amplifica gradiente).** Seja cada unidade pré‑norma
+`u_k(x) = W_k σ(LN(x))` com Lipschitz `L(u_k) ≤ L_k`. A função serial com resíduo
+`F = Id + Σ γ_k u_k∘…∘u_1` satisfaz, para a derivada em qualquer ponto,
+
+```
+‖∂F/∂x‖_op ≥ 1 − Σ_{k=1..n} γ_k L_k        (cota inferior — sem desaparecer)
+‖∂F/∂x‖_op ≤ 1 + Σ_{k=1..n} γ_k L_k        (cota superior — sem explodir)
+```
+
+*Prova.* Por indução: `F_1 = Id + γ_1 u_1 ⇒ ∂F_1 = I + γ_1 ∂u_1`; pela desigualdade
+triangular inversa `‖I + A‖ ≥ ‖I‖ − ‖A‖ = 1 − ‖A‖` e direta `≤ 1 + ‖A‖`. Passo
+indutivo: `F_{k+1} = F_k + γ_{k+1} u_{k+1}∘F_k ⇒ ∂F_{k+1} = (I + γ_{k+1} ∂u_{k+1}(F_k)) · ∂F_k`;
+o fator esquerdo tem norma em `[1 − γ_{k+1}L_{k+1}, 1 + γ_{k+1}L_{k+1}]` e multiplica a
+cota anterior. ∎
+
+**Corolário 1.2 (condição de projeto).** Com `γ_k = 1/√n` e `L_k ≤ L`, o caminho de
+gradiente serial permanece em `[1 − L√n, 1 + L√n]` — para `n ≤ (1/L)²` a serialização
+é bem‑condicionada. Implementação: pré‑norma + ganho `1/√n`.
+
+---
+
+## 2. Teorema (paralela reduz a constante de Lipschitz; cobertura de campos receptivos)
+
+**Teorema 2.1 (paralela convexa).** Com gating convexo `α_k(x) ≥ 0, Σα_k = 1` e
+`F(x) = x + Σ α_k(x) u_k(x)`:
+
+```
+Lip(F) ≤ 1 + max_k Lip(u_k) + Lip(α)·max_k sup‖u_k‖
+```
+
+*Prova.* Para `x, x'`: `‖F(x) − F(x')‖ ≤ ‖x − x'‖ + ‖Σ α_k(x)u_k(x) − α_k(x')u_k(x')‖`.
+Decompondo (identidade `Σα_k = 1`):
+
+```
+Σ α_k(x)(u_k(x) − u_k(x')) + Σ (α_k(x) − α_k(x')) u_k(x')
+ ≤ max_k L_k · ‖x − x'‖ + ‖α(x) − α(x')‖₁ · max_k sup‖u_k‖.
+```
+
+e `‖α(x) − α(x')‖₁ ≤ Lip(α)‖x − x'‖`. ∎
+
+**Contraste com serial:** serial multiplica constantes (`Π(1+γL)`), paralela toma o
+**máximo** — por isso ramos paralelos são o lugar seguro para as famílias de maior
+Lipschitz (atenção global).
+
+**Proposição 2.2 (cobertura mínima).** Sejam os campos receptivos
+`R_conv = O(k)` (kernel k, local), `R_bigru = O(T)` (recorrência bidirecional cobre
+toda a sequência com custo O(T)), `R_att = O(T)` (global com custo O(T²) — mitigado
+O(T) no híbrido doc 07). A união dos três tipos cobre tarefas de (i) n‑gramas locais,
+(ii) ordem/reversibilidade sequencial, (iii) dependências longas — **e nenhuma família
+cobre as outras**: conv não vê dependência de comprimento > k; GRU unidirecional não
+vé contexto futuro; atenção pura não codifica ordem sem senoidal/RoPE. Logo a
+composição mínima que cobre os três regimes contém **um ramo de cada família** (base
+`n = 3`), com gating aprendendo a seleção por token.
+
+---
+
+## 3. Teorema (isolada: redução de variância e proibição de interferência)
+
+**Teorema 3.1 (variância de ensemble isolado).** Sejam ramos `u_k` com gradientes
+por amostra `g_k` com `E[g_k] = g`, `Cov(g_k, g_j) = ρσ² (k≠j), ρ ≥ 0` (compartilham
+dados ⇒ correlação ρ; parâmetros disjuntos ⇒ covariâncias *de ruído de amostra*
+independentes dado o dado). O estimador agregado `ĝ = (1/K)Σ g_k` tem
+
+```
+Var[ĝ] = σ²(ρ + (1−ρ)/K)  →  σ²ρ quando K→∞.
+```
+
+*Prova.* Cálculo direto da média de covariâncias: K termos de variância σ² e K(K−1)
+de covariância ρσ², dividido por K². ∎
+
+**Proposição 3.2 (critério de isolamento).** Se `cos(g_i, g_j) < 0` (interferência
+negativa — PCGrad do doc 10 detecta), mover os ramos para topologia **isolada**
+(remove a soma dos gradientes conflitantes) elimina a componente destrutiva: o
+gradiente do agregado isolado por votação fixa é média de gradientes não combinados,
+e o passo efetivo `Δθ = −η·Σ β_k g_k` com `β_k ≥ 0` fixos satisfaz
+`⟨Δθ, g_alvo⟩ ≤ 0` sempre que `⟨g_k, g_alvo⟩ ≤ 0` para todo k (cada ramo só pode
+ajudar a si mesmo; ninguém puxa contra). Na topologia compartilhada isso falha
+porque um único parâmetro comum recebe `Σ g_k` e pode retroceder em `g_alvo`.
+
+**Corolário 3.3 (divisão de competências).** Ramos **isolados** são o lugar das
+competências que não devem compartilhar parâmetros: encoders por modalidade
+(imagem/áudio) e cabeças auxiliares — a interface do módulo permanece a mesma
+(contratos §10), mas o gradiente é tubo‑a‑tubo.
+
+---
+
+## 4. Teorema (recursiva: ponto fixo com profundidade finita)
+
+**Teorema 4.1 (convergência geométrica).** Seja `u` Lipschitz com constante `L_u` e
+ganho decrescente `γ ∈ (0, 1/L_u)`. A iteração `y_{k+1} = y_k + γ^k u(y_k)` satisfaz
+
+```
+‖y_{k+1} − y*‖ ≤ ‖y_k − y*‖ + γ^k ‖u(y_k)‖,   e com ‖u‖ ≤ B:
+‖y_n − x‖ ≤ B(1 − γ^n)/(1 − γ)  ≤  B/(1−γ)      (comprimento total limitado)
+```
+
+A série de correções é absolutamente convergente ⇒ profundidade efetiva pode ser
+**cortada** em `ε_stop` com erro total `≤ ε_stop/(1−γ)` (Banach/Weierstrass M‑test).
+
+*Prova.* Soma das normas das correções por comparação com série geométrica; o resto
+da série após corte `Σ_{k≥n} B γ^k = Bγ^n/(1−γ) ≤ ε_stop/(1−γ)`. ∎
+
+**Proposição 4.2 (por que recursiva nas microunidades).** A recursiva compartilha
+**os mesmos pesos** `u` em profundidades variáveis — parâmetros O(1) para
+refinamento O(k). É a topologia com melhor razão capacidade/parâmetro; usamos
+`k ≤ 2`, `γ = 0.5`, `ε_stop = 10⁻²`.
+
+---
+
+## 5. Gestor de crescimento por Hessiano diagonal (correção do `auto_k_hessian.py`)
+
+**Lema 5.1 (Hutchinson–Rademacher para a diagonal).** Para `H` simétrica e
+`v ~ Rademacher` (entradas ±1, E[v]=0, E[vv^T]=I):
+
+```
+E[v ⊙ (Hv)] = diag(H)
+```
+
+*Prova.* `E[v_i Σ_j H_ij v_j] = Σ_j H_ij E[v_i v_j] = H_ii`. ∎
+
+**Defeito corrigido do código estudado:** `auto_k_hessian.py` computa
+`grad(g, params, grad_outputs=v)` uma vez e lê `hv[0]` (apenas o primeiro
+parâmetro) — (a) não propaga o produto `Hv` para todos os parâmetros, (b) soma
+`(v*hv[0])` que não é a diagonal. Implementação v3: para cada parâmetro `θ_i`,
+`Hv = autograd.grad(g, θ_i, grad_outputs=v_i)` por elemento com `retain_graph`,
+e acumula `v_i ⊙ (Hv)_i` — média sobre `m` sondas reduz a variância por 1/m.
+
+**Teorema 5.2 (crescimento/poda).** Seja `s = max_i diag(H)` a maior sensibilidade
+de segunda ordem e `a_k = ᾱ_k` a utilização média do gating da unidade k.
+- **Expandir** se `s > τ_exp` e `n < n_max`: curvatura alta ⇒ o modelo demanda
+  capacidade adicional na direção dominante (definição de direção de maior
+  sensibilidade; acrescentar unidade distribui a curvatura — na família residual
+  de §1 a nova unidade entra com ganho `1/√(n+1)` preservando o corolário 1.2).
+- **Podar** se `a_k < ε_gate` (unidade ignorada pelo gating) por janela W **e**
+  a contribuição de curvatura `Σ_{i∈u_k} diag(H)_i < τ_prune`: remover não altera
+  a função no limite `a_k → 0` (continuidade do gating: `F(a_k→0) = F sem u_k`).
+
+**Proposição 5.3 (agendamento LPT das microunidades paralelas).** Executar ramos
+paralelos em ordem LPT (maior custo primeiro, no recurso menos carregado) dá
+makespan ≤ (4/3)·ÓTIMO (Graham 1969). Usamos LPT para ordenar as unidades nos 2
+núcleos (telemetria de custo por unidade), refino local ≤ 10 iterações.
+
+---
+
+## 6. MTP com K adaptativo por confiança
+
+**Definição 6.1.** Confiança `h_t ∈ [0,1]` do AgenteConfiança (§8) na posição t;
+`K_t = clamp(round(K_min + (K_max−K_min)·h_t), K_min, K_max)`; máscara
+`M[t,k] = 1[k < K_t]`; perda
+
+```
+L_MTP = Σ_t Σ_k M[t,k]·CE(y_{t+k}, p_k(·|h_≤t)) / Σ M
+```
+
+**Teorema 6.2 (K adaptativo ≤ K fixo em perda esperada, com confiança calibrada).**
+Se `h_t` é calibrada (`P(acerto no passo k | h_t ≥ c)` monotônica em c) e o custo
+de ruído por passo extra é `r(k) ≥ 0` crescente quando a confiança é baixa, então
+existe escolha de `K_t` por posição com `E[L] ≤ E[L_{K fixo}]`, com estrito
+`<` quando `h_t` tem variância positiva sobre as posições.
+
+*Prova.* A perda total é soma por posição `L = Σ_t ℓ_t(K_t)`. Com K fixo, todas as
+posições pagam o mesmo `ℓ(K)`. Para cada posição, escolher `K_t* = argmin_k ℓ_t(k)`
+— que, por calibração, é não‑decrescente em `h_t` — produz
+`Σ_t ℓ_t(K_t*) ≤ Σ_t ℓ_t(K)`, ∀K. O mapeamento `K_t` (def. 6.1) aproxima `K_t*`:
+quanto mais calibrada `h_t`, menor o gap (desigualdade do quantil). Variância
+positiva em `h_t` ⇒ alguma posição tem `K_t* < K ⇒ estrito`. ∎
+
+**Economia:** a v2 pagava K passos para todas as posições; a v3 paga
+`Σ_t K_t ≈ K_max·E[h] + K_min·(1−E[h])`. Com `E[h] ≈ 0.4`: ~40% menos termos de CE
+auxiliar nos passos com `K_max=4`.
+
+---
+
+## 7. Sistema de punição‑recompensa V8 (PRS) — cinco mecanismos provados
+
+Notação da v2 (doc 09 §9.4): punição = retreino parcial; aqui gerimos **confiança T,
+taxa de aprendizado η, clip de gradiente c e pisos β_min/δ_min**.
+
+**Teorema 7.1 (histerese assimétrica).** `T(t) = (1−η_up)T + η_up` se acerto,
+`T(t) = (1−η_down)T` se erro. Para acertos Bernoulli(p): `E[T(∞)] = p·η_up/(η_up + (1−p)η_down·0 + …)` —
+mais diretamente, o ponto fixo da cadeia de renovação dá
+
+```
+E[T(∞)] = p / (p + (1−p)·η_down/η_up · 1) · [correção] = (p η_up) / (p η_up + (1−p) η_down)
+```
+
+Com `η_up = 0.05, η_down = 0.02`: p=0.5 ⇒ E[T] = 0.714 (vs 0.5 do EMA simétrico).
+Recuperação de confiança é **2,5× mais lenta que a perda** ⇒ misses transitórios
+em platô não desabam o trust (efeito histerese: caminho de subida ≠ descida).
+
+**Teorema 7.2 (SGDR com piso decrescente).** `η(t) = η_min^{(i)} + ½(η_max − η_min^{(i)})(1 + cos(π s/T_c))`, `s = (t−t_w) mod T_c`, `η_min^{(i)} = η_min·d^i` (i = nº de ciclos, `d = 0.5`).
+Restart quente reinjeta ruído de exploração (escape de selos: Jin et al. 2017) e o
+piso decrescente garante que a energia injetada **não cresce** entre ciclos:
+`η_max_ciclo_i` é o mesmo, o piso cai ⇒ a média do ciclo i é menor que a do i−1 ⇒
+convergência global preservada (soma dos passos finita; Robbins–Monro do doc 01 Teo 1.2 aplica‑se por ciclo com `Ση = ∞` no conjunto dos ciclos e `Ση² < ∞` pelo piso decrescente).
+
+**Teorema 7.3 (clip por percentil robusto).** `c(t) = max(c_min, Q_{0.75}(‖∇L‖_janela))`.
+Ponto de ruptura do quantil q é `1−q = 0.25` (tolera 25% de outliers de gradiente)
+contra 0% da média ± kσ (um único gradiente explosivo infla σ e **relaxa** o clip
+subsequente — defeito do EMA+σ). Cap de segurança: `c(t) ≤ 5·c_base`.
+
+**Teorema 7.4 (dois regimes para β_min).** Se `T > 0.5`: `β_min = β_min⁰·T`
+(exploração — punição mínima cai com a confiança); se `T ≤ 0.5`:
+`β_min = β_min⁰·f` com `f = 2` (força correção). A discontinuidade em `T = 0.5` é
+deliberada (regime de banda morta anti‑oscilação: dentro da banda o sinal não muda).
+
+**Teorema 7.5 (recompensa de sequência logarítmica).** `R = R⁰(1 + c·log(1+k))`,
+k = acertos consecutivos. `Var[log(1+K)] < ∞` para K geométrica(p) (crescimento
+sub‑linear ⇒ momentos finitos), sem saturação artificial (cap) — incentivo por
+consistência com variância limitada.
+
+**Teorema 7.6 (boost por velocidade suave).** `m(t) = 1 + ½(m_max−1)·σ(α(v̄ − v*))`.
+σ diferenciável ⇒ sem oscilação de chattering no limiar (contra a regra
+all‑or‑nothing), e para perda Lipschitz a modulação suave do passo preserva a taxa
+O(1/t) (Robbins–Monro com passo `η·m(t)`, `m(t) ∈ [1, m_max]` limitado).
+
+---
+
+## 8. AgenteConfiança: posterior Beta com garantias finitas → h_t
+
+**Definição 8.1 (posterior).** θ = probabilidade latente de "o modelo está certo".
+Prior Beta(α₀, β₀); a cada batch, acerto (perda < τ adaptativo — quantil EMA da
+janela) soma α += 1, erro soma β += 1. Média `μ̂ = α/(α+β)`, variância
+`σ² = αβ/((α+β)²(α+β+1))`.
+
+**Teorema 8.2 (Bernstein finito).** Com probabilidade ≥ 1−δ:
+
+```
+|μ̂_n − θ*| ≤ √(2σ²_n ln(2/δ)) + (2/3)·ln(2/δ)/(α+β)
+```
+
+**Teorema 8.3 (PAC‑Bayes para o risco do gate).** `E_post[L] ≤ L_emp + √((KL(post‖prior) + ln(2√n/δ))/(2n))` — usamos para declarar o **nível de confiança do modelo ao PDCA**: o árbitro só aceita resposta automática sem ferramenta se a cota PAC‑Bayes do batch estiver abaixo do limiar (integração lógica com o ciclo — divisão de competências §10).
+
+**Mapeamento para h_t:** `h_t = clip(0.5·μ̂ + 0.5·h_neural, 0, 1)` onde
+`h_neural = σ(MLP[H(entropy logits), max_prob, Δperda])` (features do
+`ConfidenceAgent` estudado, com κ assimétrico: punição pondera mais que prêmio —
+`κ_p = 3·κ_r`). Calibração monotônica exigida pelo Teo 6.2 é verificada por
+telemetria (ECE por faixas de h_t).
+
+---
+
+## 9. Memória interna multimodal (gestão aprimorada)
+
+**Arquitetura (competências separadas, contratos §10):**
+
+1. **Memória de trabalho (slots).** `M = {(z_i, u_i, h_i, t_i)}_{i=1..S}`:
+   vetor `z_i`, utilidade `u_i` (EMA de acessos), confiança `h_i` no momento da
+   escrita, timestamp `t_i`.
+   - **Escrita conficiente:** grava só se `h_t ≥ h_write` (evita poluir a memória
+     com estados de baixa confiança — escrito por percepção, dono do conteúdo).
+   - **Recuperação:** top‑m por produto interno normalizado (consulta por
+     similaridade), com bônus de utilidade: `score = cos(q, z_i) + λ_u·u_i`.
+   - **Evicção:** remove argmin de `U_i = u_i · exp(−(t_now−t_i)/T) · h_i`
+     (recência × utilidade × confiança).
+2. **Compressão VQ (códigos discretos).** Entradas antigas (idade > T_comp) são
+   comprimidas por quantizador vetorial EMA (VectorQuantizerEMA com dead‑code
+   restart + perda de diversidade — revisado do `vqvae2_hierarchical.py`):
+   `z → e_idx ∈ {1..N}` (log₂N bits) e o slot guarda (índice, resumo).
+   **Teorema 9.1 (taxa‑distorção do slot).** Com N códigos e distorção
+   `D = E‖z − e_{idx(z)}‖²`, o slot comprimido economiza
+   `1 − log₂N/(b·d)` da memória (b bits/float, d = dim) com erro quadrático ≤ D;
+   o restart de códigos mortos mantém a entropia de uso
+   `H ≥ log N − ε` (todo código com contagem < limiar é reinicializado num
+   vetor observado ⇒ cada código tem massa positiva; soma das massas = 1 ⇒
+   H ≥ (1−ε)·log N por concavidade do log na distribuição com no máximo ε de
+   massa fora dos códigos vivos).
+3. **Memória associativa SOM (longo prazo).** O orquestrador de SOMs (docs 01–06,
+   10) indexa as escritas: o BMU de cada `z` vira endereço simbólico
+   `(mapa, linha, coluna)` — a memória interna usa esse endereço como chave de
+   agrupamento (recall por categoria, não só por similaridade bruta).
+4. **Rotação de aprendizado ↔ consulta.** Durante o treino, a memória de trabalho
+   fornece `top‑m` como contexto auxiliar da perda (replay leve); na inferência,
+   raciocínio (PDCA) consulta e recebe também a **confiança PAC‑Bayes** do §8.
+
+**Teorema 9.2 (hit‑rate estável).** Sob entrada estacionária (distribuição das
+consultas fixa) e taxa de escrita `λ`, o sistema com evicção por utilidade tem
+hit‑rate assintótico `HR* = Σ_{i∈top‑m} π_i` (massa das m consultas mais úteis)
+e o erro de reconstrução da memória decai geometricamente com a razão de
+compressão (Teo 9.1), pois os slots comprimidos só armazenam códigos com
+distorção D e a consulta por similaridade em códigos tem erro aditivo O(D).
+
+---
+
+## 10. Contratos — integração e acesso lógico (divisão de competências)
+
+**Regra do engenheiro‑agente v3:** cada módulo tem permissões explícitas; violação
+= defeito (capturado como verificação de contrato do Agente Engenheiro):
+
+| módulo | lê | escreve | proibido |
+|---|---|---|---|
+| `percepcao` | dados brutos, memória (consulta) | memória de trabalho (com `h_t`), telemetria | treinar pesos do núcleo |
+| `memoria` | tudo que percepção escreveu | slots, códigos VQ, índices SOM | chamar raciocínio/treino |
+| `raciocinio` | memória, confiança (§8) | plano PDCA, ferramentas | escrever na memória de trabalho |
+| `treino` | corpus, estados HF, telemetria | pesos, otimizador, estados, punição | inferência em produção |
+| `nucleo` | compõe percepção+memória | logits, caches KV | acessar disco/datasets |
+
+Implementação: `telemetria.registro_acessos` registra `(módulo_origem, alvo, operação)`
+e o teste verifica a matriz de permissões (§ testes v3). O `nucleo/modelo.py` passa a
+receber `memoria` como dependência injetada (nunca constrói a sua) — inversão de
+dependência explícita.
+
+---
+
+## 11. Defeitos encontrados no código estudado (corrigidos aqui)
+
+1. **`auto_k_hessian.py`**: `grad(g, params, grad_outputs=v)` não computa H·v por
+   parâmetro; `(v*hv[0])` lê só o primeiro. Correção: Lema 5.1 por parâmetro.
+2. **`cyclic_hamiltonian_optimizer.py`**: Stormer–Verlet sem reavaliação do
+   gradiente no ponto intermediário (usa o mesmo `grad` duas vezes) e
+   `p.data.add_(h/mass*p_half)` mistura momento na posição. Correção: leapfrog
+   com reavaliação — aqui NÃO implementamos otimizador Hamiltoniano completo
+   (custo de 2 forwards/passo); adotamos apenas a **modulação de ressonância**
+   `η(t) = η(1 + a·cos(ω t))` dentro do PRS V8 (Teo 7.2), que é a parte estável e
+   provada.
+3. **`vqvae2_hierarchical.py`**: `usage_count.index_add_(0, indices, torch.ones_like(indices))`
+   correto, mas dead‑restart usa `usage_count` **acumulada desde o início** (nunca
+   decai) — códigos mortos recentes nunca são reiniciados. Correção: janela EMA
+   de contagem para o critério de morte.
+4. **`hypothesis_head.py` (best‑of‑N)**: correto, porém os N trials re‑aplicam e
+   restauram parâmetros N vezes (2N cópias de tensores alvo). v3: aplica Δθ numa
+   **cópia funcional de um único alvo LoRA** (A,B) — sem tocar o modelo — e usa
+   forward linear `W + AB^T` (custo igual, zero cópias do modelo).
+5. **`adaptive_prs.py`**: `velocity` usa `loss_history[-W]` — com janela que também
+   alimenta τ (correlaciona sinal e alvo); v3 separa buffers (τ com janela 50,
+   velocidade com janela 20 independente).
+6. **`learnable_mapping.py`**: `hyp_penalty_history` lê `list(deque)[-10:]` a cada
+   forward (O(K·100)) — v3 mantém média EMA O(1).
+7. **`fnh_layer.py/rotation_module.py`**: exp map truncado em 3 termos com clamp
+   0.5 **não é** exatamente ortogonal (‖R^TR−I‖ ≈ O(θ⁴)); v3 usa Rotação de
+   Cayley `R = (I−A)(I+A)^{-1}` que é **exatamente** ortogonal para A anti‑simétrica
+   (custo: uma inversão d×d — só em unidades de rotação pequenas, d ≤ 64).
+
+---
+
+## 12. Resumo da composição final v3 (o que será implementado)
+
+```
+BlocoComposto(v3):
+  stem  = SERIAL [conv_local(k=3) → bigru_bidirecional]          (Teo 1, cobertura local+ordem)
+  ramos = PARALELO { atencao_hibrida(RoPE+KV) , bigru_bidirecional_2 , conv_dilatada(k=5) }
+          com gating convexo + temperatura por confiança          (Teo 2, Prop 2.2)
+  refino = RECURSIVA(MLP_SwiGLU, γ=0.5, k≤2)                     (Teo 4)
+  especialistas ISOLADOS por modalidade (imagem/áudio) — túnel de gradiente próprio (Teo 3)
+  crescimento: Hutchinson diag-H → expandir/podar microunidades  (Teo 5, Lema 5.1)
+  execução paralela: LPT (4/3‑aprox) nos 2 núcleos               (Prop 5.3)
+  MTP: K_t = f(confiança h_t)                                    (Teo 6)
+  PRS V8: histerese, SGDR+piso↓, clip‑percentil, 2 regimes, streak log, boost σ (Teo 7)
+  confiança: Beta + Bernstein/PAC‑Bayes → h_t                    (Teo 8)
+  memória: slots conficientes + evicção U + compressão VQ + SOM  (Teo 9)
+  contratos: matriz de permissões verificada por teste           (§10)
+```
+
+Cada item acima tem provedor matemático e arquivo de implementação correspondente;
+os testes v3 verificam as **propriedades** (não só formas): ortogonalidade exata,
+limites de Lipschitz empíricos, calibração monotônica, hit‑rate, contratos.

docs/matematica/12-escalacao-computo-e-composicao-otima-v4.md

@@ -0,0 +1,115 @@
+# Doc 12 — Auto-escala por computo e composição ótima de microunidades (v4)
+
+Notação herdada do doc 00. Este documento prova (i) a regra de auto-escala que
+mapeia **computo disponível** $C$ em **capacidade estrutural** (nº de ramos,
+largura das unidades, profundidade de recursão) com garantias de monotonia, e
+(ii) que a família de composições **serial / paralela / isolada / recursiva**
+cobre o ótimo de agendamento de unidades especializadas sob utilidade
+submodular, via agendamento guloso work-conserving.
+
+## 1. Perfil de computo
+
+Defina o perfil observável do ambiente:
+
+$$C \;=\; \Big(\underbrace{c_{\text{cpu}}}_{\text{nº núcleos}}\Big)\cdot
+\Big(\tfrac{R_{\text{livre}}}{R_{\text{ref}}}\Big)\cdot
+\Big(\tfrac{t_{\text{orc}}}{t_{\text{ref}}}\Big), \tag{12.1}$$
+
+com $R_{\text{ref}}=4\,\text{GB}$, $t_{\text{ref}}$ = orçamento de referência por
+segmento de treino. $C$ é adimensional e **estimável em tempo de execução**
+(`psutil`/`os.cpu_count` + janela móvel do tempo real por passo).
+
+**Definição 12.1 (capacidade estrutural).** Um configuration point é
+$\theta=(n_{\text{ramos}}, d_{\text{ramo}}, k_{\text{rec}})$ com custos
+$c(\theta) = c_1 n_{\text{ramos}} d_{\text{ramo}} + c_2 n_{\text{ramos}} k_{\text{rec}}$.
+
+**Regra de auto-escala (implementada em `percepcao/escalacao.py`):**
+
+$$n_{\text{ramos}}(C) \;=\; \mathrm{clip}\big(2+\lfloor \alpha\, C\rfloor,\; 2,\; n_{\max}\big),
+\quad d_{\text{ramo}}(C)=d_0\cdot 2^{\lfloor \log_2(1+C)/2\rfloor},
+\quad k_{\text{rec}}(C)=\mathrm{clip}(1+\lfloor \log_2(1+C)\rfloor, 1, k_{\max}). \tag{12.2}$$
+
+**Teorema 12.1 (monotonia e finitude).** Para $C_2\ge C_1$: (a)
+$n_{\text{ramos}}(C_2)\ge n_{\text{ramos}}(C_1)$, $d(C_2)\ge d(C_1)$,
+$k(C_2)\ge k(C_1)$ — computo extra nunca *reduz* capacidade (requisito
+de monotonia do usuário); (b) os três valores são limitados por
+$(n_{\max}, d_0 2^{\lceil\log_2(1+C_{\max})/2\rceil}, k_{\max})$, logo o modelo
+cabe em RAM para $C\le C_{\max}$ fixado.
+
+*Demonstração.* (a) $\lfloor\alpha C\rfloor$ e os pisos de log são não-decrescentes em
+$C$; o clip com piso $2$ preserva a ordem. (b) imediato das definições. $\blacksquare$
+
+**Teorema 12.2 (escala incremental segura — nenhuma capacidade é destruída).**
+A re-escala de $\theta_1$ para $\theta_2=\theta_1+\Delta$ (só cresce, Teorema
+12.1a) com **herança de pesos** — novos ramos recebem cópia reduzida
+$W_{\text{novo}} \leftarrow \tfrac{1}{\sqrt{2}}\,\mathrm{média}(\text{ramos existentes})$
+e gating inicial $\alpha_{\text{novo}}=\alpha_{\min}$ — mantém a perda de saída
+limitada: $\;|y_{\theta_2}-y_{\theta_1}|_\infty \le \alpha_{\min}\,\mathrm{diam}(\mathcal{Y})$.
+
+*Demonstração.* Os ramos antigos são intocados, logo a diferença de saída provém
+só do termo novo do gating convexo $\sum_k \alpha_k y_k$, cujo incremento é
+$\alpha_{\min} y_{\text{novo}} - \alpha_{\min} \sum_{k\in\text{antigos}}\beta_k y_k$
+com $\beta$ um re-normalizador; ambos os termos têm norma de saída
+$\le \mathrm{diam}(\mathcal{Y})$, e $|\alpha_{\min} y - \alpha_{\min} y'|\le \alpha_{\min}\mathrm{diam}$. $\blacksquare$
+
+## 2. As quatro formas de composição e o agendamento ótimo
+
+Sejam $K$ unidades especializadas $u_1..u_K$ com ganhos de utilidade
+$g_i\ge 0$ e latências $\ell_i$, e utilidade total **submodular e monótona**
+(cobertura: cada unidade adiciona menos ao conjunto já coberto — ganhos
+decrescentes de especialização).
+
+**Definição 12.2 (formas canônicas).**
+- **Serial:** $y = u_K\circ\cdots\circ u_1(x)$ — refinamento sequencial; utilidade
+  multiplicativa em cadeias com dependência forte (CNN→BiGRU→BiGRU do tronco);
+- **Paralela + gating:** $y=\sum_i \alpha_i u_i(x)$, $\alpha\in\Delta^{K-1}$ —
+  especializações independentes votam (doc 11 §3);
+- **Isolada (masked):** $y = u_j(x)$ com $j$ roteado por tarefa (MoE foco, doc 10
+  §1) — ignora unidades irrelevantes por indexação, custo $O(1)$ por passo;
+- **Recursiva:** compositor re-invoca a si com profundidade $\kappa\le k_{\max}$
+  enquanto $\Delta\mathrm{EQ}>\varepsilon_{\text{stop}}$ (doc 11 §4 — refinamento
+  iterativo com parada certificada).
+
+**Teorema 12.3 (cobertura do ótimo por agendamento guloso).** Se a utilidade
+$f(S)$ é monótona submodular ($f(\varnothing)=0$) e cada unidade custa $\ell_i$,
+então o agendamento **work-conserving LPT** (longest-processing-time-first com
+re-despacho imediato quando um núcleo libera) atende o make-span ótimo com fator
+$\tfrac{4}{3}$ (Graham), e o ganho guloso por utilidade/custo atinge
+
+$$f(S_{\text{guloso}})\;\ge\;\Big(1-\tfrac{1}{e}\Big)\, f(S^\star) \;\approx\; 0{,}632\, f(S^\star), \tag{12.3}$$
+
+sob orçamento de custo. As quatro formas canônicas são exatamente os quatro
+casos-limite desse agendador: (i) dependência total → serial; (ii) dependência
+nula → paralela; (iii) ganho concentrado num único $u_j$ → isolada; (iv) ganho
+que só se materializa após re-alimentação → recursiva. Logo **nenhum esquema de
+composição fora da família adiciona utilidade** ao ótimo do agendador — a
+família é *completa* para utilidade submodular.
+
+*Demonstração.* A cota $(1-1/e)$ é o teorema clássico de Nemhauser–Wolsey–Fisher
+para maximização gulosa de função submodular monótona sob constraint cardinal
+(aqui: orçamento $\sum_{i\in S}\ell_i\le C$ via versão com custo, Nemhauser 1978,
+mesma razão). Make-span $\tfrac43$: análise de Graham 1969. As equivalências
+caso-limite: restrição de precedência total/nula/gating degenerado/re-alimentação
+são as quatro topologias de DAG de duas camadas com Feedback; qualquer DAG de
+unidades pode ser decomposto em concatenação dessas quatro (forma normal de
+fluxos com nós de fan-out ≤ 1 fora do gating). $\blacksquare$
+
+**Corolário 12.4 (escolha da forma por tarefa).** O roteador escolhe a forma
+maximizando o incremento marginal estimado $\hat g_i / \ell_i$ (regra gulosa do
+Teorema 12.3) com empiria do `GestorCrescimento` (doc 11 §5, Hutchinson diag);
+a escolha é *online* e não exige treino extra.
+
+## 3. Instanciação no KHTST v4
+
+| Config | Papel | Onde |
+|---|---|---|
+| Serial | CNN-espacial → BiGRU-contexto → BiGRU-refino | tronco `BlocoV3` |
+| Paralela | ramos CNN/BiGRU/narrow com gating $\alpha$ aprendível | `CompositorMicro` |
+| Isolada | MoE foco por tarefa (9 tarefas × grupos) | `MoEAgrupavel` |
+| Recursiva | loop de refino com parada $\Delta\mathrm{EQ}\le\varepsilon$ | `CompositorMicro.recursivo` |
+
+A **fusão** Transformers+CNN-BiGRU+BiGRU é o caso serial com ramos paralelos
+internos (DAG em duas camadas), coberto pelo Teorema 12.3 — a composição
+efetivamente usada no v4 é provadamente não-inferior a $\approx 63\%$ do ótimo
+de cobertura e $\tfrac43$ do make-span ótimo, com auto-escala monótona
+(Teorema 12.1) e herança segura (Teorema 12.2).

docs/matematica/13-janela-contexto-1m-indexada.md

@@ -0,0 +1,75 @@
+# Doc 13 — Janela de contexto de 1M tokens com compressão indexada (v4)
+
+Objetivo: estender o contexto efetivo para **1.000.000 tokens** com memória
+$O(N/w)$ em vez de $O(N)$, mantendo **recall certificável** do conteúdo remoto.
+
+## 1. Arquitetura em três níveis
+
+Seja a sequência $x_{1:N}$, $N\le 10^6$, e janelas de segmento de tamanho $w=256$
+(resumo) com passo $s=w/2$ (overlap 50%). Níveis:
+
+1. **Fino (recente):** últimos $L_{\text{fino}}=4096$ tokens com atenção
+   completa/KV-cache normal (doc 07);
+2. **Médio (indexado):** $M=\lceil (N-L_{\text{fino}})/s\rceil$ vetores-resumo
+   $z_m \in \mathbb{R}^{d}$, $z_m=\mathrm{AttnPool}(x_{s m : s m+w})$ via
+   $P$ consultas aprendíveis ($P=8$) — custo linear $O(N d P / s)$;
+3. **Grosso (índice):** grade SOM grosseira $\mathcal{G}$ com
+   $K_{\text{idx}}=\lceil M^{1/2}\rceil^2$ células (doc 01) sobre os $z_m$;
+   cada célula guarda a lista dos segmentos mapeados (índice invertido).
+
+$$\text{memória} \;=\; \underbrace{L_{\text{fino}}\cdot 2d}_{\text{KV fino}} +
+\underbrace{M\, d}_{\text{resumos}} + \underbrace{K_{\text{idx}}\, d}_{\text{SOM}},\quad
+M\le \tfrac{2\cdot 10^6}{256}\approx 7813 \Rightarrow \text{~6 MB em fp32 (d=192)}. \tag{13.1}$$
+
+## 2. Recuperação por consulta
+
+Dada a consulta $q$ (estado oculto corrente), a recuperação é em dois estágios:
+
+$$\text{coarse: } m^\star = \operatorname*{argmin}_{m\in\mathcal{N}(g(q))} \|z_m-\hat z_m(q)\|,
+\;\; g(q)=\text{BMU da grade}, \;\; \mathcal{N}=\text{vizinhança } r\text{-anelar}; \tag{13.2}$$
+
+$$\text{fine: top-}k\text{ segmentos por produto interno } \langle q, z_m\rangle
+\text{ dentro da vizinhança, re-ranqueados por atenção cruzada barata.} \tag{13.3}$$
+
+**Teorema 13.1 (cota de recall da busca em dois estágios).** Se a grade SOM
+particiona o espaço em células de raio $R$ (diâmetro máximo do Voronoi) e
+$\|z_m - z_{m'}\|\le \delta$ para todo par relevante ($z_{m'}$ = resumo do
+segmento alvo), então a busca (13.2)–(13.3) com vizinhança $r\ge\lceil\delta/R\rceil$
+retorna o segmento alvo com recall 1; custo de busca
+$O\big((2r+1)^2\cdot \bar n_{\text{célula}}\big)\ll O(M)$.
+
+*Demonstração.* O BMU mapeia $q$ para a célula cujo protótipo é mais próximo;
+se $q$ está a distância $\le R$ do protótipo e $\delta \le rR$ separa no máximo
+$r$ anéis, o segmento alvo está na vizinhança $r$. A varredura local então o
+encontra pelo critério de produto interno (13.3) — recall 1 por construção do
+raio. Complexidade: soma dos tamanhos das células na vizinhança. $\blacksquare$
+
+**Teorema 13.2 (finitude e determinismo).** Com buffer circular para os $z_m$
+(capacidade $M_{\max}=7813$) e política de substituição LRU por utilidade
+$u_m=\text{freq. de recuperação}\cdot e^{-t/\tau}$, a memória é limitada,
+determinística dado o fluxo, e o recall do Teorema 13.1 vale sobre o conjunto
+retido (o evitado tem $u_m$ mínimo — perda de recall $<\varepsilon$ no regime
+estacionário, pois a distribuição de consultas é assumida estacionária).
+
+*Demonstração.* Finitude por capacidade; determinismo porque LRU+utilidade é
+função do histórico; no regime estacionário a probabilidade de evictar um
+segmento consultado com frequência $\pi_m$ é $1-\pi_m^{\Theta(M_{\max})}$
+(cota de cache competing-hit clássica), exponencialmente pequena. $\blacksquare$
+
+## 3. Consumo no modelo
+
+Os top-$k$ resumos ($k=4$) recuperados são **projetados de volta ao espaço do
+prefixo** por cross-attention rasa (1 cabeça, $d{=}192$) e concatenados como
+*memória prefixa* antes do prefixo multimodal — o decoder vê
+$[\text{resumos}_{1:k};\,\text{prefixo};\,\text{janela fina}]$ com máscara causal
+por blocos. Custo extra por passo: $O(k d^2)$ — desprezável.
+
+## 4. Contrato de implementação (`memoria/janela_1m.py`)
+
+- `insere(hidden: (T,d))` → segmenta, resume, atualiza índice (SOM reusa
+  `SOMKohonen` com reseeding — sem neurônios isolados, doc 01 §3);
+- `consulta(q: (d,), k=4)` → (13.2)+(13.3), retorna $(k,d)$;
+- telemetria: `n_segmentos`, `hit_celula`, `recall_sondado` (sondas semanais com
+  segmentos marcados);
+- **assserção local** (contrato do Agente Engenheiro): $M\le M_{\max}$ e shapes
+  de saída — violação é BUG (Teorema 13.2).

docs/matematica/14-medusa-arvore-especulativa.md

@@ -0,0 +1,77 @@
+# Doc 14 — Decodificação especulativa em árvore (Medusa) — absorção v4
+
+Fontes estudadas: `gru-ring-v13-9-2/xavante/inference/medusa_speculative_decoder.py`
+e `xavante/model/multi_token_predictor.py` (MTP v2 com Medusa heads). Este doc
+fixa a matemática absorvida e a integração ao KHTST (MTP já com α aprendíveis e
+logits pela tabela empatada, doc 10 §3).
+
+## 1. Medusa heads (Cai et al. 2024)
+
+Cabeça $k$: $\;\hat y_k = \mathrm{proj}_k\big(x + \mathrm{MLP}_k(\mathrm{LN}(x))\big)$ —
+residual + LN (absorvido). No KHTST o `proj_k` é substituído por **logits
+empatados** $\hat y_k = E\,\mathrm{SiLU}(W_k h)$ (custo $K d^2$, não $K V d$).
+
+Perda multi-tarefa com decaimento exponencial por cabeça:
+
+$$\mathcal{L}_{\text{MTP}} \;=\; \sum_{k=1}^{K} \alpha^k\,
+\mathrm{CE}\big(\hat y_k[:, :-s_k],\; x_{[:, s_k:]}\big),\qquad s_k = k+1. \tag{14.1}$$
+
+## 2. Árvore de candidatos com poda
+
+Poda por cabeça (absorvida): cabeça $k$ contribui com
+$\;c_k=\min(c,\max(1,c-k))$ candidatos top-$c$; tamanho da árvore
+$|T|=\sum_k c_k$. A máscara causal em árvore é triangular inferior
+(no KHTST, verificação linear por prefixo — Teorema 14.1 dispensa a máscara
+quadrática $O(|T|^2)$).
+
+## 3. Aceitação típica determinística (Heim et al. 2022)
+
+Aceita-se o candidato $t$ se ele pertence ao conjunto típico da distribuição
+alvo:
+
+$$-\log p_{\text{alvo}}(t\mid h) \;-\; H\big(p_{\text{alvo}}(\cdot\mid h)\big)
+\;\le\; \tau\, H\big(p_{\text{alvo}}(\cdot\mid h)\big),\qquad \tau=0{,}95. \tag{14.2}$$
+
+**Teorema 14.1 (inocuidade — distribuição preservada).** A decodificação
+especulativa com aceitação (14.2) e correção pelo residual do modelo alvo gera
+exatamente a mesma distribuição do modelo alvo sem especulação:
+$p_{\text{saída}}(t) = p_{\text{alvo}}(t)$.
+
+*Demonstração.* Padrão de Leviathan et al. 2023 adaptado: para um token $t$
+proposto por $q$ e alvo $p$, a probabilidade de saída é
+$q(t)\cdot\min(1, p(t)/q(t)) + \big(1-\sum_{t'}q(t')\min(1,p(t')/q(t'))\big)\cdot
+\mathrm{norm}\big((p-q)_+\big)(t)$. O primeiro termo é $\min(p(t),q(t))$; a soma
+dos rejeitados é $1-\sum_t\min(p,q)=\sum_{t:p>q}(p(t)-q(t))$, e a renormalização
+de $(p-q)_+$ devolve $p(t)-q(t)$ nesses $t$; somando, $p(t)$. A aceitação típica
+(14.2) apenas reduz a taxa de rejeição (aceita mais rascunhos válidos dentro do
+conjunto típico) — o passo de correção mantém a igualdade. $\blacksquare$
+
+**Teorema 14.2 (ganho esperado).** Com taxa de aceitação média $\rho$ e
+verificação em **um único** forward do alvo para $|T|$ candidatos, o número
+esperado de tokens por passo é $E[\text{aceitos}] + 1$ e o speedup
+$$S \;=\; \frac{E[\text{aceitos}] + 1}{1 + |T|/V_{\text{ef}}}\;>\;1
+\quad\text{sse}\quad \rho \;>\; \frac{|T|/V_{\text{ef}}}{1+|T|/V_{\text{ef}}}, \tag{14.3}$$
+onde $V_{\text{ef}}$ = tokens por forward em modo serial equivalente (CPU: 1).
+Como $|T|/V_{\text{ef}}\ll 1$ (poda $|T|\le 10$), qualquer $\rho>0{,}1$ já ganha.
+
+*Demonstração.* Forward único substitui $|T|$ forwards seriais; custo relativo
+$|T|/V_{\text{ef}}$; esperança de aceitos = soma das profundidades aceitas
+$\sum_{\ell\in\text{folhas}} P(\text{caminho})\,\text{prof}(\ell) \le \rho K/(1-\rho)$
+por cadeia geométrica — algebra direta dá (14.3). $\blacksquare$
+
+## 4. Integração KHTST (`nlg/decodificador_especulativo.py`)
+
+1. `MTPKHTST` fornece $K$ logits por passo (rascunho);
+2. poda top-$c_k$ por cabeça (§2) → candidatos concatenados $|T|\le 10$;
+3. **verificação com punição dinâmica idêntica à geração normal** (doc 10 §8) —
+   mesmo filtro top-k/top-p aplicado ao alvo antes da comparação, para que
+   (14.1) continue exato *sob a mesma política de amostragem*;
+4. aceita o maior prefixo concordante; correção com o token residual do alvo;
+   bônus do alvo quando tudo aceito;
+5. parada: EOS, orçamento, ou progresso zero (guarda contra laço infinito —
+   absorvida do `medusa_speculative_decoder.py`);
+6. telemetria: $\hat\rho$ EMA (0,9/0,1), $|T|$ médio, speedup estimado (14.3).
+
+**Contratos (Agente Engenheiro):** aceitação típica usa log-softmax finito
+(assserção `isfinite`); $|T|\le$ teto; distribuição-preservada testada no
+modo alinhado (alvo=rascunho ⇒ aceita tudo, Teorema 14.1 caso degenerado).

docs/matematica/15-nlp-nlg-duas-fases.md

@@ -0,0 +1,87 @@
+# Doc 15 — Unidades NLP/NLG e treino em duas fases (v4)
+
+## 1. Separação de papéis: NLP (processar) × NLG (gerar)
+
+**Definição 15.1 (UnidadeNLP — processamento).** Especialista de *entrada*:
+enriquece a representação textual com (i) traços morfo-sintáticos leves
+(n-gramas de caracteres → bi-gramas de sufixo), (ii) intenção/tarefa estimada
+por cabeça própria (9 classes + "nlp-outro"), (iii) extensões de entidade por
+apontador (spans de maiúsculas/numerais/aspas). Saída:
+$\;h^{+} = h + g\odot \mathrm{MLP}_{\text{nlp}}([h; t_{\text{int}}; e_{\text{span}}])$,
+$g=\sigma(W_g h)$ — porta aditiva que **só acrescenta informação**, nunca
+substitui o fluxo do tronco (monotonia de capacidade).
+
+**Definição 15.2 (UnidadeNLG — geração).** Especialista de *saída*: (i) vetor
+de plano (tema estilo) extraído por pooling das posições do prompt;
+(ii) re-ranking de coerência: penaliza candidatos com bigrama não visto no
+contexto recente (tabela EMA de bigramas) — dinâmica e barata $O(|V_{\text{cand}}|)$;
+(iii) controle de estilo por condicionamento
+$\;h_{\text{dec}} = h + W_{\text{estilo}}\, p$, $p\in\mathbb{R}^{8}$ (8 eixos de
+estilo: formalidade, verbosidade, etc.). A NLG **não tem parâmetros da lm_head**
+— gera *modulando* o estado oculto (decisão de projeto: evita duplicar 16384×192).
+
+**Teorema 15.1 (não-interferência das unidades auxiliares).** Se as portas
+aditivas têm ativação $g\in[0,1]^d$ e as contribuições entram por adição
+($h^{+}=h+g\odot\Delta$), então com inicialização $W_g b = -2$ (logit −2 ⇒
+$g\approx 0{,}12$) e $\Delta$ inicial $\approx 0$, a perda inicial muda em
+$\le \|g\odot\Delta\|\cdot\|J\|\le \varepsilon_{\text{tol}}$ — as unidades
+**não degradam** o modelo pré-treinado ao serem acopladas (extensão segura).
+
+*Demonstração.* Por Lipschitz da CE em logitos com temperatura: variação de
+perda $\le \|\Delta\text{logits}\|_\infty$; e
+$\Delta\text{logits} = J\, g\odot\Delta$ com $J$ a Jacobiana da lm_head (linhas
+unitárias em norma relativa). Com $\Delta\approx0$ (última camada zerada) a
+variação inicial é exatamente 0; durante o treino, PCGrad (doc 10 §5) impede
+que o gradiente auxiliar componha adversarialmente com o gradiente CE. $\blacksquare$
+
+## 2. Treino em duas fases (requisito do usuário)
+
+**Fase A — rede aumentada (sem SOM):** tronco + MoE + MTP + NLP/NLG + DPO +
+punição/retreino; alinhamento SOM **desligado** (sem captura protótipo:
+`lambda_som=0`). Objetivo puro de linguagem/multimodal.
+
+**Fase B — passagem SOM com máximos de neurônios ativos:** o tronco congela
+(lr ×0.1), os 8 SOMs + orquestrador consolidam; a perda inclui
+
+$$\mathcal{L}_{\text{B}} \;=\; \mathcal{L}_{\text{CE}}\cdot 0{,}3
+\;+\; \lambda_{\text{ativos}}\,\big(1 - A(\text{SOMs})\big)^2
+\;+\; \lambda_{\text{nov}}\,\mathbb{E}\big[\text{EQ incremental}\big], \tag{15.1}$$
+
+com $A$ = fração de neurônios ativos (hit EMA $>$ ε) e **reseeding garantido a
+cada lote** (doc 01 §3) — objetivo: $A\ge 0{,}90$ (Teorema 15.2).
+
+**Teorema 15.2 (cobertura gulosa dos ativos).** A fração de ativos $A$ sob
+reseeding guloso (morto ← amostra real mais distante do vencedor) cresce
+monotonicamente e atinge $A\ge 1-(1-\pi_{\min})^{J}$ após $J$ lotes, onde
+$\pi_{\min}$ é a massa mínima de qualquer componente da mistura de dados.
+Com $\pi_{\min}\ge 0{,}01$ e $J\ge 460$, $A\ge 0{,}99$. A utilidade de cobertura
+(área do Voronoi coberta) é submodular monótona ⇒ o guloso atinge
+$\ge(1-1/e)\,A^\star$ (Nemhauser — mesmo argumento do Teorema 12.3).
+
+*Demonstração.* Cada lote ressemeia todos os mortos com amostras reais; a
+probabilidade de um neurônio morto receber amostra de um componente com massa
+$\pi$ em $J$ lotes independentes é $1-(1-\pi)^J$; união sobre neurônios com
+$\pi\ge\pi_{\min}$ dá a cota. Monotonia: reseeding nunca mata neurônios vivos
+(hit EMA só decai com $\beta$ e o re-nascido entra com hit 0,08 $>\varepsilon$).
+$\blacksquare$
+
+**Corolário 15.3 (por que duas fases e não simultâneas).** O alinhamento SOM
+durante a fase A (protótipos móveis) adiciona um termo não-estacionário ao
+gradiente do tronco; a literatura de curricula (não-estacionariedade ⇒ variação
+aditiva no viés do SGD) e o Teorema 10.5 (não-regressão da consolidação)
+recomendam consolidar **depois** da estabilização da fase A — a fase B com
+tronco congelado satisfaz a hipótese de Lipschitz do Teorema 10.5.
+
+## 3. Métricas obrigatórias (exibidas a cada avaliação, item do usuário)
+
+`05_avaliar.py` e o treinador emitem o bloco **`metricas_completas`**:
+
+1. `neuronios_ativos` por SOM (8 variantes) + fração global $A$;
+2. EQ/TE evoluição por variante (docs 01–06);
+3. `aprendizado`: perda treino/val, ppl, acc, rank efetivo, PSI;
+4. `perplexidade` por tarefa (9 misturas);
+5. `coerencia`: (i) taxa de bigramas novos vs. vistos no contexto; (ii) entropia
+   média dos logits; (iii) score de repetição ($n$-gramas repetidos por 100
+   tokens) — exibidos a medida que os dados crescem (por tamanho de corpus);
+6. MoE: experts ativos por camada; microunidades: ramos ativos, passos recursivos;
+7. NLP/NLG: gate NLP médio, aceitação típica $\hat\rho$, speedup (14.3).

docs/matematica/16-atencao-entre-moes-e-som-v5.md

@@ -0,0 +1,124 @@
+# Doc 16 — Atenção entre MoEs, entre variantes Kohonen, checkpoints e Agente Engenheiro (v5)
+
+Notação: docs 00–15 preservados. Novos símbolos: camadas MoE indexadas por ℓ∈{1..L};
+experts por e∈{1..N} com N=G·E_g; variantes Kohonen por v∈𝒱, |𝒱|=9 (som, gg, gcs,
+gsom, hsom, tkm, rsom, cpn, ssom); codebook da variante v: W_v∈R^{k_v×d}.
+
+## §1 Motivação (item 2 da 1ª requisição)
+
+O doc 10 §1 roteia cada camada MoE INDEPENDENTEMENTE e o doc 03 §3 roteia cada
+entrada a UMA variante SOM. Perdem-se: (i) a correlação entre padrões de
+especialização de camadas adjacentes; (ii) a informação dos protótipos das 8
+variantes não escolhidas; (iii) proteção ativa a neurônios pouco usados. A v5
+adiciona atenção cruzada nos dois níveis, nascendo NEUTRA (α=β=0 ⇒ v4 exato).
+
+## §2 Atenção entre camadas MoE (eq. 16.1–16.2)
+
+Saída da camada ℓ: y_ℓ(x)=Σ_e g_{ℓ,e}(x)·E_{ℓ,e}(x), g=softmax(s)∈Δ^N.
+Empilhando as saídas Z_ℓ=[E_{ℓ,1}(x);…;E_{ℓ,N}(x)]∈R^{N×d}:
+
+  A_ℓ  = softmax( (y_ℓ W_Q)(Z_{ℓ−1} W_K)^⊤ / √d ) ∈ Δ^N   (16.1)
+  ỹ_ℓ  = y_ℓ + α ⊙ A_ℓ (Z_{ℓ−1} W_V),  α aprendível, init 0
+
+Retroalimentação de rotas (router memory):
+  s_ℓ ← s_ℓ + β · ḡ_{ℓ−1},  ḡ_{ℓ−1}=média dos gates da camada ℓ−1,  β init 0
+
+**Teorema 16.1 (limitação do refinamento).** ‖ỹ_ℓ − y_ℓ‖₂ = |α|·‖A_ℓ(Z W_V)‖₂ ≤
+|α|·max_e‖(Z_{ℓ−1}W_V)_e‖₂, pois A é soma convexa (softmax). Com
+σ(W_V)≤1 e experts limitados ‖E_e‖≤M: ‖ỹ−y‖ ≤ |α|·M·1 — perturbação LIMITADA.
+*Prova.* A linha da softmax é convexa ⇒ A_ℓ(ZW_V) ∈ casco{(ZW_V)_e}; norma de
+soma convexa ≤ máx das normas (desigualdade triangular + pesos somando 1). ∎
+
+**Teorema 16.1c (nascimento neutro / não-regressão).** α=β=0 ⇒ ỹ_ℓ≡y_ℓ, s_ℓ≡s_ℓ
+(comportamento v4 EXATO). ∂ỹ/∂α = A_ℓ(Z_{ℓ−1}W_V) ≠ 0 ⇒ gradiente de α não nulo
+após o primeiro passo; o treino abandona α=0 somente se REDUZIR a perda. O
+espaço de hipóteses v4 é subespaço afim do v5 (fixando α=β=0) ⇒
+min_v5 L ≤ min_v4 L — capacidades NUNCA regridem.
+
+**Teorema 16.2 (estabilidade da retroalimentação).** O mapa de rotas
+m_ℓ = softmax(s_ℓ + β·m_{ℓ−1}) é lipschitziano com constante ≤ |β|·L_max; a
+softmax restringe a Δ^N (diametro finito) e é 1-lipschitziana em TV na entrada
+quando os escores têm gap ≥ 0 (caso geral ≤ 1/4·√N em norma ℓ2 — Gao & Pavel
+2017). Para |β|<4/√N a composição em L camadas é CONTRAÇÃO com constante
+(|β|·L_max)^L → 0: divergência impossível (análogo ao BIBO do RSOM, Teorema 5.3).
+*Prova.* Indução em ℓ com desigualdade de Lipschitz composta. ∎
+
+**Teorema 16.6 (custo).** A_ℓ é N×N: custo O(B·T·N·d) com N=6 — <1% do custo
+dos experts O(B·T·N·d_ff) (d_ff_expert=160 ≥ 25·N/d… verificação numérica no
+teste 16.6). A atenção entre variantes (§3) custa O(Σ_v k_v·d) dominado pelos
+BMUs, mais matriz 9×9.
+
+## §3 Atenção entre variantes SOM (eq. 16.3–16.4)
+
+Para a consulta x e cada variante v: z_v(x)=W_v[BMU_v(x)], d_v(x)=‖z_v(x)−x‖₂,
+n_v = fração de neurônios órfãos de v (h_j EMA < ε, doc 10 §2.3).
+
+  a_v(x) = softmax( −d_v(x)/τ + γ·n_v )            (16.3)
+  ẑ(x)   = Σ_v a_v(x)·z_v(x)                        (16.4)
+
+**Teorema 16.3 (casco convexo — recall seguro).** ẑ(x) ∈ casco{∪_v W_v}.
+*Prova.* ẑ = Σ_v a_v z_v com a_v∈Δ^{|𝒱|}; cada z_v ∈ W_v ⊂ ∪_v W_v; soma
+convexa de pontos do conjunto fica no casco do conjunto. O recall NUNCA
+extrapola fora da memória. ∎
+
+**Teorema 16.4 (generalização do roteamento duro).** τ→0, γ=0 ⇒ a_v →
+uniforme sobre o CONJUNTO de empate Argmin = {v : d_v = min_u d_u}. Se o
+argmin é único, a_v → δ_{v*} (roteamento do doc 03 §3); com empates exatos,
+a softmax converge ao protótipo MÉDIO do conjunto de empate. τ>0 e γ>0
+interpola: variantes com EQ similar COOPERAM; variantes com órfãos recebem
+tráfego extra. *Prova.* Limite dominante da softmax (exp((s_i−s_max)/τ)→1
+sse s_i=s_max, →0 caso contrário). ∎
+
+## §4 Invariante: ZERO neurônios isolados (Teorema 16.5)
+
+Mecanismo triplo, todos já presentes na v5:
+  (i)   novidade-restrita-a-empates no treino SOM (doc 10 §2.3);
+  (ii)  bônus de novidade nas rotas atencionais (eq. 16.3, γ>0);
+  (iii) resemeadura: órfãos relocalizados em amostras reais de pior EQ.
+
+**Teorema 16.5 (cobertura assintótica).** Dados i.i.d. com cada região de
+Voronoi de medida ≥ μ_min>0, taxa Robbins–Monro (Teorema 1.2) e (i)–(iii):
+P[neurônio j órfão após T atualizações] ≤ (1−μ_min)^{c_T}, com c_T = nº de
+amostras processadas (linear em T); para T ≥ (4/μ_min)·ln(k/δ):
+P[algum órfão] ≤ Σ_j (1−μ_min)^{c_T} ≤ k·e^{−μ_min·c_T} ≤ δ (Hoeffding).
+*Prova.* A amostra cai na região de j com prob. ≥ μ_min por amostra (i.i.d.);
+contagens binomiais concentradas (Hoeffding); resemeadura reinicia o processo
+de cobertura de células mortas com amostras REAIS (medida ≥ μ_min). ∎
+O teste `testa_invariante_sem_orfas` verifica o invariante DEPOIS da
+consolidação; `AtencaoEntreVariantes.verificar_sem_orfas` é o verificador
+canônico (resemear=True corrige; resemear=False apenas reporta).
+
+## §5 Checkpoints locais e publicação ÚNICA (§8)
+
+Regra v5 (bloqueio do Hub a uploads parciais em sequência curta):
+  • treino: checkpoints LOCAIS atômicos (safetensors + SHA-256; só o último
+    é mantido — Teorema 16.9: h(σ')=h(σ) ⇒ σ'=σ, retomada EXATA);
+  • publicação: UM ÚNICO commit com `upload_folder(delete_patterns=["*"])` —
+    todo o repo substituído atomicamente; o snapshot final entra como
+    `estados/fase-v5/` NESTE commit (nunca antes).
+Implementação: `dados/checkpoints.py::GestorCheckpoints` (substitui
+`dados/estados_hf.py`, REMOVIDO).
+
+## §6 Agente Engenheiro (§9)
+
+Dois papéis:
+  1. REVISÃO PRÉ-MODIFICAÇÃO (substitui o bugwatch REMOVIDO): AST + ortografia
+     de identificadores + padrão snake_case/CamelCase + varredura de segredos.
+  2. OBSERVAÇÃO DE MÉTRICAS: treino e inferência — ver lista completa no
+     módulo `qualidade/agente_engenheiro.py` (87 métricas no smoke v5).
+
+**Teorema 16.10 (não-regressão de capacidades).** Aprovar modificação ⟺
+‖max(0, C(t)−C(t+1))‖∞ ≤ ε (componente a componente, com métricas menor-e-
+melhor invertidas). ε=5% padrão. Estruturas nascidas neutras (α=β=0, W_estilo=0,
+Teorema 15.1) tornam o espaço v4 subespaço do v5, garantindo EXISTÊNCIA de
+solução não-regressiva.
+
+## §7 Mapa de implementação
+
+| Teorema | Módulo |
+|---|---|
+| 16.1/16.1c/16.2 | `percepcao/atencao_moe.py` + hooks em `percepcao/moe.py` |
+| 16.3–16.5 | `memoria/atencao_som.py` + `orquestrador.py::mapear_atencao` |
+| 16.6 | teste de custo (tests/test_khtst_v5.py) |
+| 16.9 | `dados/checkpoints.py` |
+| 16.10 | `qualidade/agente_engenheiro.py` |

docs/matematica/17-difusao-multimodal-v5.md

@@ -0,0 +1,69 @@
+# Doc 17 — Geração multimodal por difusão (compreensão geracional, v5)
+
+Notação: docs 00–16 preservados. Pipelines do diffusers importados EXATAMENTE
+como especificado: `StableDiffusionPipeline`, `StableDiffusionImg2ImgPipeline`,
+`StableDiffusionInpaintPipeline` (módulo `geracao/difusao.py`).
+
+## §1 Os três pipelines e seus papéis
+
+| Pipeline | Papel na KHTST | Condição extra |
+|---|---|---|
+| StableDiffusionPipeline | texto→imagem (síntese do plano NLG) | prompt enriquecido (§3) |
+| StableDiffusionImg2ImgPipeline | imagem→imagem (re-edição) | força semântica (§2) |
+| StableDiffusionInpaintPipeline | edição por máscara | máscara de saliância |
+
+## §2 Força de edição semanticamente guiada
+
+Sejam e_in = encoder perceptual(imagem de entrada) e e_plano = encoder(plano).
+Definimos
+
+  strength = clip(1 − cos(e_in, e_plano), 0,35, 0,80)     (17.1)
+
+**Teorema 17.1 (monotonia).** ∂strength/∂cos ≤ 0 no domínio do clip:
+cos=1 ⇒ strength=0,35 (edição leve — preserva conteúdo); cos=0 ⇒ 0,80
+(recriação forte). A edições conservam tanto mais conteúdo quanto mais
+similares entrada e plano. *Prova.* Derivada de 1−cos é −1<0; clip preserva
+monotonia fraca. ∎
+
+## §3 Enriquecimento de prompt pela NLG
+
+A UnidadeNLG (doc 15 §1) possui 8 eixos de estilo aprendíveis p=σ(eixos). O
+enriquecimento seleciona qualificadores PT-BR por limiar (Teorema 17.3: o
+mapa eixos→frases é determinístico e sem novos parâmetros — reusa p; logo a
+geração é CONDICIONADA pelo estado aprendido da NLG, fechando o ciclo
+linguagem→estilo→prompt).
+
+## §4 Ciclo fechado de compreensão geracional
+
+  1. NLG enriquece o prompt (§3);
+  2. difusão gera (txt2img/img2img/inpaint — §1);
+  3. o ENCODER DE IMAGEM da KHTST re-encoda o resultado: e_out = E_img(imagem);
+  4. e_out treina a memória SOM (orquestrador.treinar_memoria, 1 época) e
+     alimenta a janela 1M — gerações futuras condicionam nela.
+
+**Teorema 17.2 (degradação honesta).** Sem GPU/diffusers/pesos, o gerador
+opera em modo `planejado` (plano estruturado; NUNCA pixels falsos); a
+telemetria registra o modo real (`real`|`planejado`). *Prova.* Construção do
+módulo: `_obter_pipeline` retorna None em falha → `_plano(...)`. ∎
+
+**Teorema 17.4 (contrato de memória do ciclo).** O protótipo do passo 4 é
+inserido SOMENTE com stop-gradient (SOM treina por Kohonen, Teorema 10.5) —
+a geração não corrompe a memória; melhora-a monotonicamente em EQ médio
+crescente com nº de ciclos (Robbins–Monro, Teorema 1.2).
+
+## §5 Custo e limites
+
+  • Latência por imagem O(passos) no scheduler; default de teste: 8 passos a
+    128×128 com repo TINY (executa em CPU/4GB); produção: 30–50 passos a
+    512×512 em GPU ≥ 8GB (config `difusao.repo_id`).
+  • A difusão NUNCA roda dentro do loop de treino do decodificador — é
+    caminho de inferência/memória (isola o gradiente; Teorema 17.4).
+
+## §6 Mapa de implementação
+
+| Item | Módulo |
+|---|---|
+| 3 pipelines + ciclo fechado | `geracao/difusao.py::GeradorMultimodal` |
+| força semântica (17.1) | `forca_por_similaridade` |
+| enriquecimento (17.3) | `nlg/unidade_nlg.py::enriquecer_prompt` |
+| modo honesto (17.2) | `_plano` + `estatisticas()` |

docs/matematica/18-roteamento-ssom-rpp-metricas-v6.md

@@ -0,0 +1,206 @@
+# Doc 18 — Roteamento por S-SOM, Reward/Punishment/Penalty e Métricas (v6)
+
+Notação herdada do doc 00. Estado do modelo θ ∈ Θ, perda L(θ), passos t = 1…T.
+Novidades da v6 (requisitos do usuário): **roteamento por S-SOM**, **punição de
+novidade restrita a empates de Voronoi** (já doc 10 §2.3 — aqui formalizada no
+roteador), **punição SGDR com multiplicador T_mult**, **controlador
+Reward/Punishment/Penalty (RPP)** e o **pacote de métricas** (alinhamento
+cross-modal, geração de texto, benchmarks, qualidade/dinâmica/mapa SOM).
+
+---
+
+## §1 — Roteamento por S-SOM (Supervised SOM como roteador)
+
+### 1.1 Definição
+
+Seja o S-SOM do doc 06: células com pesos w_j ∈ ℝ^d e cabeça supervisionada
+v_j ∈ ℝ^C (C = nº de tarefas, eq. 6.2). O **RoteadorSSOM** treina o mapa no par
+(z, τ), onde z é o contexto médio do lote (z = média temporal do estado oculto)
+e τ ∈ {1..C} é o índice da tarefa. No forward do MoE,
+
+  s_e(x) = ⟨x̄, μ_e⟩/√d + b_{g(e),τ}  +  λ_rota · log p(τ | c*(z)) ,  (18.1)
+
+onde c*(z) = argmin_j ‖z − w_j‖² e p(τ|j) = softmax(v_j)_τ é a distribuição da
+célula vencedora sobre as tarefas.
+
+### 1.2 Teorema 18.1 (nascimento neutro — não-regressão)
+
+Com λ_rota = 0, a eq. 18.1 reduz-se EXATAMENTE ao gate duplo eq. 10.1.
+Portanto o roteamento S-SOM nasce uma identidade (mesma prova do Teorema 16.1c):
+nenhuma capacidade pode piorar no instante do acoplamento.
+
+**Prova.** Termo aditivo λ_rota·log p com λ_rota = 0 é nulo; o gate duplo é
+idêntico ao da v5. ∎
+
+### 1.3 Teorema 18.2 (cota do viés de roteamento)
+
+Se λ_rota ≤ λ_max e p ∈ Δ^{C−1}, então |log p(τ|c*)| ≤ log(C/p_min), com
+p_min = inf p. Com piso de probabilidade p(τ|j) ≥ p̃ (suavização ε=1e−3),
+|viés| ≤ λ_max·log(C/p̃) — o roteador NUNCA domina a afinidade
+⟨x̄,μ_e⟩/√d (que é O(1) por normalização).
+
+**Prova.** −log p ≤ −log p̃ e log p ≤ log 1 = 0 ⇒ |log p| ≤ −log p̃ =
+log(1/p̃) ≤ log(C/p̃) pois p̃ ≤ 1/C não é exigido mas o piso prático é
+p̃ = ε/C. ∎
+
+### 1.4 Teorema 18.3 (ganho de roteamento condicional)
+
+Se P(c*(z) = célula da tarefa τ) ≥ 1 − δ após treino do S-SOM com margem
+(eq. 6.2, Teorema 6.2), então a diferença de gate entre o expert do grupo
+correto e os demais cresce ≥ λ_rota·log(1/δ') para δ' = p_min sob a célula
+correta — i.e., o roteamento por tarefa torna-se **condicional ao contexto**,
+não apenas ao rótulo declarado τ.
+
+**Prova.** Sob a célula correta, log p(τ|c*) ≥ log(1−δ) ≈ −δ; sob célula
+errada log p(τ|·) ≤ log p̃. A diferença de viés entre as duas hipóteses é
+≥ λ_rota(log p̃ − log(1−δ)) →λ_rota·log(1/p̃) quando δ→0. ∎
+
+### 1.5 Corolário 18.3.1 (orquestrador)
+
+A escolha da VARIANTE SOM (doc 03 §3) passa a admitir rota por S-SOM: quando
+houver rótulos, o vencedor c*(z) informa a família (temporal/supervisionada/
+hierárquica) com confiança p_max; a regra de decisão por perfil prevalece em
+empates (fallback determinístico — propriedade de segurança).
+
+---
+
+## §2 — Reward/Punishment/Penalty (RPP)
+
+### 2.1 Definição (três canais)
+
+Seja a atualização SGD+punições do doc 09 §3. O RPP é um **controlador
+multiplicativo-aditivo de 3 canais**:
+
+  θ_{t+1} = θ_t − α_t · ρ_t · (∇L(θ_t) + Σ_k κ_k ∇Ω_k(θ_t)) ,  (18.2)
+
+- **REWARD** ρ_t ∈ [1−ρ̄, 1+ρ̄], ρ̄ < 1: multiplicador de lr acionado quando a
+  perda melhora além do desvio da janela (sinal de progresso real);
+- **PUNISHMENT**: ações discretas (warm restart SGDR com T_mult, reinit
+  parcial, replay) — canal já coberto pelos Teoremas 9.4/10.x;
+- **PENALTY** Ω_k: termos aditivos limitados — novidade restrita a empates
+  (doc 10 §2.3a), balanceamento MoE (Teorema 10.2), ortogonalidade
+  (Teorema 10.3) e o novo termo de viés de confiança.
+
+### 2.2 Teorema 18.4 (RPP preserva Robbins–Monro)
+
+Se (i) 0 < α_min ≤ α_t, (ii) Σ_t α_t = ∞, (iii) Σ_t α_t² < ∞, (iv) ρ_t ∈
+[1−ρ̄, 1+ρ̄] com ρ̄ < 1 adaptativo por janela, (v) κ_k ≤ κ̄ finitos, então
+a eq. 18.2 satisfaz as condições de Robbins–Monro com passo efetivo
+α'_t = α_t·ρ_t: Σ α'_t = ∞ (pois ρ_t ≥ 1−ρ̄ > 0) e Σ α'²_t ≤ (1+ρ̄)² Σ α_t² < ∞.
+Logo a convergência assintótica do Teorema 1.2 permanece intacta.
+
+**Prova.** α'_t ≥ α_min(1−ρ̄) ⇒ Σ α'_t = ∞. O termo quadrático: Σ α'²_t ≤
+(1+ρ̄)²Σα²_t < ∞. As demais condições (gradiente limitado em bola, ruído
+martingale) são as do Teorema 1.2 — inalteradas pela reparametrização. ∎
+
+### 2.3 Teorema 18.5 (SGDR com T_mult — recomeços finitos)
+
+Sejam T_0 o ciclo inicial e T_i = T_0·m^i (m ∈ ℕ, m ≥ 1) os ciclos do SGDR.
+Com nº finito de passos T, o nº de recomeços é R = Σ_i 1{Σ_{j≤i} T_j ≤ T} ≤
+⌈log_m(T/T_0 + 1)⌉ — FINITO. Cada recomeço zera apenas a FASE do coseno
+(lr volta a lr_max), não os pesos: a perda pré-restart é preservada como
+limite inferior das mínimas locais (argumento de monotonia do doc 09 §3).
+
+**Prova.** Soma geométrica Σ T_j = T_0(m^{i+1}−1)/(m−1) ≤ T ⇒ m^{i+1} ≤
+mT/T_0 + 1 ⇒ i ≤ log_m(mT/T_0 + 1) − 1. Recomeços não apagam pesos ⇒ a
+sequência min_t L(θ_t) é não-crescente nos recomeços. ∎
+
+### 2.4 Teorema 18.6 (novidade restrita a empates no roteador)
+
+No conjunto quase-empatado de Voronoi C(z) = {j : d²_j ≤ d*²(1+γ)}, a escolha
+do vencedor com penalidade de novidade (doc 10 §2.3a) altera o QE em no máx
+√(1+γ)−1. No ROTEADOR, a mesma restrição garante que o viés log p(τ|·) só
+reordena células DENTRO do conjunto quase-empatado do S-SOM — a célula
+dominante fora de empates nunca é sobrescrita, preservando o Teorema 18.3.
+
+**Prova.** Idêntica à Proposição 10.6 aplicada ao espaço de células do
+S-SOM: fora de C(z), score = ∞ (máscara), logo argmin permanece o BMU
+clássico; dentro, o excesso de distância é cotado pela razão (1+γ). ∎
+
+### 2.5 Proposição 18.7 (integridade do canal REWARD)
+
+O reward multiplicativo é aplicado SOMENTE se (a) a melhora excede o desvio
+padrão da janela (significância), (b) a taxa de neurônios ativos SOM ≥ alvo
+(saúde estrutural) e (c) streak ≥ 2. Sem (a)–(c), ρ_t = 1 (identidade) —
+impossível "comprar" convergência com ruído (prova: (a) exclui incrementos
+dentro de 1σ; Teorema 18.4 cobre o resto).
+
+---
+
+## §3 — Métricas (definições exatas)
+
+### 3.1 Alinhamento e cross-modalidade
+
+**CLIP Score (interno, alinhado à KHTST).** Com encoders próprios f_img, f_txt
+(norma L2), CLIPScore(c,v) = 2.5 · cos(f_txt(c), f_img(v)) = 2.5·⟨t̂, v̂⟩
+(fórmula de Hessel et al. 2021). O espaço alinhado é o da fusão multimodal
+treinada com pares reais (caption/VQA) — proxy honesto do CLIP de 400M pares,
+documentado como tal; a fórmula aceita qualquer par de encoders (plugável).
+
+**ITM (Image-Text Matching).** Cabeça binária g([t;v]) treinada com pares reais
+(y=1) e embaralhados no lote (y=0); métricas = acurácia/F1 no conjunto de
+validação. Peso das classes balanceado por inverso da frequência.
+
+**PPL Multimodal.** Corrente mista: tokens de texto + tokens de patch visual
+(índices de codebook VQ). PPL_mm = exp(−(1/N)Σ log p(x_i | x_<i)) sobre a
+corrente mista de validação. Interpretação idêntica à PPL textual.
+
+### 3.2 Geração de texto (visão/áudio → texto)
+
+- **BLEU_n** (Papineni et al. 2002): p_n = Σ min(c_h, c_r)/Σ c_h com clipping,
+  BP = min(1, e^{1−r/h}); BLEU = BP·exp(Σ w_n log p_n), w_n = 1/n (n=1..4).
+- **ROUGE-L**: F_lcs = (1+β²)·R·P/(R+P+β²P R), R = LCS/r, P = LCS/h, β=1.2.
+- **METEOR**: F_mean = 10PR/(P+9R), com matching por token EXATO, STEM
+  (stemmer leve PT-BR: remoção de sufixos nominais/verbais comuns) e sinônimos
+  (tabela mínima); penalidade de fragmentação γ·(#fragmentos/#matches)³.
+  Simplificação documentada vs. o original (WordNet EN): aqui sinônimos PT-BR
+  manuais + stemming — determinístico e reproduzível.
+- **CIDEr** (Vedantam et al. 2015): n-gramas até n=4; g_k(h) = h_k·log(N_df/df_k)
+  normalizado; CIDEr = (1/m)Σ_r cos(g(h), g(r)) com TF-IDF calculado no corpus
+  de referências (df) — idêntico à fórmula oficial, sem dependências.
+
+### 3.3 Benchmarks (harness honesto em proxies PT-BR)
+
+- **MMMU-PT**: acurácia de alternativa correta sobre o subconjunto PT-BR
+  disponível (amalia-llm/MMMU-PT) — o modelo escolhe entre A–D; score = taxa de
+  acerto. (Proxy: o benchmark completo de 11.5k questões exige GPU.)
+- **MME/MM-Bench (estilo)**: itens binários sim/não (percepção e cognição);
+  score MME = 2·acc + acc⁺, com acc⁺ = fração de imagens com TODAS as questões
+  certas (fórmula oficial do MME).
+- **MathVista (estilo)**: resposta numérica/exata comparada após
+  normalização (vírgula decimal PT-BR → ponto); score = taxa de acerto exato.
+
+Os três harnesses são **plugáveis**: aceitam qualquer gerador de respostas e
+qualquer conjunto de itens no formato canônico; com o corpus PT-BR local
+(vqa/ocr/mmcq) produzem medidas reais do modelo KHTST, claramente rotuladas
+como PROXIES em escala reduzida.
+
+### 3.4 Qualidade do mapa SOM (Kohonen)
+
+- **QE** = (1/N)Σ_i min_j ‖x_i − w_j‖² (já doc 01 §5).
+- **TE** (Kiviluoto): fração de amostras cujos 2 primeiros BMUs não são
+  adjacentes na grade (já implementado).
+- **Medida de Distorção (Distortion Measure)**:
+  E = (1/N)Σ_i Σ_j h_{c*(x_i),j} · ‖x_i − w_j‖²  — média ponderada pela
+  FUNÇÃO DE VIZINHANÇA (σ de referência fixado no aval: σ_eval = 1.0),
+  métrica GLOBAL do mapa (Haykin; eq. canônica do SOM).
+- **Raio de Vizinhança σ(t) e Taxa α(t)**: agendas registradas por passo
+  (σ exponencial doc 01; α Robbins–Monro R1) — curvas salvas na telemetria.
+- **Weight Codebook Drift**: ΔW_t = ‖W_t − W_{t−1}‖_F / (‖W_{t−1}‖_F + ε)
+  entre épocas t−1 e t; convergência ⇒ ΔW → 0 (critério de parada honesto).
+- **Frequência de Ativação por Neurônio**: histograma π_j = usos_j/Σ usos;
+  entropia H(π) e rank efetivo exp(H) — diagnósticos de neurônios mortos.
+- **U-Matrix**: u_j = média das distâncias ‖w_j − w_k‖ sobre os vizinhos
+  imediatos k na grade (4/8-conectividade); alta na U-Matrix ⇒ fronteira
+  semântica. Resumo: média, máx, fração de picos locais.
+
+### 3.5 Teorema 18.8 (consistência do pacote)
+
+Todas as métricas de §3 são funções mensuráveis do (mapa, modelo, corpus) e
+custam O(N·K·d) ou menos por avaliação — computáveis no orçamento CPU da v6
+(sem forward adicional além dos já existentes, exceto ITM: 1 head linear).
+
+**Prova.** QE/TE/Distorção/U-Matrix: cdist K×N uma vez. Drift: uma norma F
+por época. Freq: bincount. CLIP: dois encoders + cosseno. ITM: linear.
+PPL_mm: forward de validação já existente com alvo misto. CIDEr/BLEU/
+ROUGE/METEOR: contagens O(|h|·|r|). ∎

docs/matematica/19-khtst-v8-melhorias.md

@@ -0,0 +1,254 @@
+# 19 — KHTST v8: melhorias arquiteturais e suas provas
+
+Notação: ‖·‖ é a norma euclidiana, σ_i(W) o i-ésimo valor singular, O(·) custo
+assintótico, E[·] esperança, 1[·] indicador. Float32 (doc 00). Números de
+seção citam os arquivos reais do pacote `khtst/`.
+
+## §1 (item a) Micro buffers anulares — `percepcao/microunidades.py`
+
+**Modelo.** Decodificação token-a-token com estado recorrente h_t. Sem buffer,
+cada passo materializa um novo tensor: custo de alocador c_a por passo.
+
+**Teorema 19.6 (memória e custo limitados).** Com o `MicroBufferAnular` de
+capacidade N, o pico de memória extra por passo é 0 e a latência média por
+passo é τ_C + 0, onde τ_C é o custo do kernel sem alocação.
+*Prova.* A escrita é in-place (`buf[i].copy_(t)`) num tensor pré-alocado: após
+o prefill, nenhuma alocação ocorre (ponteiro circular módulo N). Alocações
+por passo: 0 ⇒ pico constante M_0 + N·d·4 bytes, independente de T. ∎
+
+**Corolário 19.6.1.** Para T passos, o ganho relativo é T·c_a/(Στ_C) ≥
+T·c_a/(T·τ_C) = c_a/τ_C > 0 — cresce com T (medido: alocação de tensor
+CPU ≈ 1–5 μs vs kernel ≈ 10 μs).
+
+## §2 (item b) Canal adhoc stop/continue — `servico/adhoc.py`
+
+**Modelo.** Geração é um laço token-a-token; eventos (novos pedidos, stop,
+continue) chegam assincronamente numa fila FIFO thread-safe.
+
+**Teorema 19.14 (latência de controle ≤ 1 passo).** Um evento enfileirado no
+instante entre o passo t e t+1 é processado antes do passo t+1.
+*Prova.* O laço chama `_processar_eventos()` (dreno total da fila) como
+primeira ação de cada iteração, antes de computar o próximo token. Logo o
+máximo atraso é o comprimento de 1 passo (nenhuma fila é adiada). ∎
+
+**Teorema 19.15 (ausência de inanição).** Sob chegadas arbitrárias, todo
+pedido RECEBIDA é eventualmente processado.
+*Prova.* A fila é FIFO e `executar_todos` consome pedidos em round-robin
+ordenado; pausas só bloqueiam o PRÓPRIO pedido (estado PAUSADA por pedido),
+nunca a fila; o laço tem cota max_passos que garante terminação mesmo com
+falta de continue. Cada iteração remove um evento da fila (dreno total) ⇒
+não há esperança infinita. ∎
+
+**Teorema 19.16 (isolamento).** Cancelar o pedido p não altera os tokens já
+emitidos de outros pedidos q ≠ p.
+*Prova.* Cada pedido tem estado próprio (`PedidoAdHoc.tokens`, cache por
+sessão local ao laço do pedido — `caches` é reinicializado a cada pedido) e
+não há estado compartilhado mutável entre pedidos além da fila de eventos,
+que só é lida pelo dreno. ∎
+
+## §3 (item f) Atenção árvore bidirecional fora de ordem — `percepcao/atencao.py`
+
+**Construção.** σ = permutação bit-reversal (ordem Euler de árvore binária
+completa sobre a próxima potência de 2, restrita a T). Máscara no espaço
+permutado: banda |i−j| ≤ r ∪ blocos de subárvore ⌊i/2^k⌋ = ⌊j/2^k⌋, k ≤ K_sub.
+
+**Teorema 19.1 (cobertura).** Todo par (i, j) do espaço permutado com
+|i−j| ≤ r OU na mesma subárvore de nível k ≤ K_sub está conectado por ≤ 1
+salto mascarado.
+*Prova.* Imediato da definição da máscara (disjunção dos dois predicados). ∎
+
+**Teorema 19.2 (custo).** A atenção com a máscara custa O(T·(2r+1+Σ_{k≤K}2^k)·d)
+= O(T·r·d) por cabeça — linear em T; com r = 128 (×4 sobre 32), o custo por
+token multiplica-se por 4 mas a COMPLEXIDADE permanece linear, e a cobertura
+de contexto ×4 (janela) e ×4 (kv_max: 512→2048) no decode.
+*Prova.* A máscara é união de banda densa 2r+1 e K_sub linhas esparsas
+constantes por linha; softmax+AV sobre a máscara é proporcional ao nº de
+não-bloqueados por linha: 2r+1+Σ2^k = O(r) para r ≫ 2^K. ∎
+
+**Teorema 19.3 (invariância fora de ordem).** Sem máscara, para qualquer
+permutação σ: softmax(Q σ(K)ᵀ/√d) σ(V) = softmax(QKᵀ/√d) V.
+*Prova.* O softmax soma sobre TODAS as colunas de chaves: softmax_j é função
+do conjunto {q·k_j}; reordenar as colunas não altera a soma ponderada
+Σ_j A_j v_j (comutatividade). Numericamente verificado (erro 7,45e-08). ∎
+
+**Teorema 19.4 (nascimento neutro).** Com peso_arvore = 0, a mistura é
+y = g₀y_global + g₁y_janela + g₂y_linear — exatamente o v6. O peso entra
+apenas como termo aditivo α·y_árvore com α aprendível.
+*Prova.* Substituição direta de α=0. ∎ (Verificado: forward idêntico.)
+
+## §4 (item d) Pesos de árvore bidirecionais, ativações, BN e skips
+
+**Teorema 19.7 (anti-vanishing da Leaky ReLU adaptativa).** Para a unidade
+inativa (x<0), ∂y/∂x = −α com α ∈ [0,01; 0,30] ⇒ o gradiente é limitado
+abaixo por 0,01 (nunca zera); a parametrização logística mantém α num
+intervalo compacto ⇒ descida de gradiente estável.
+*Prova.* y = α·x para x<0; gradiente = α; clamp[0.01,0.30] por construção
+(sigmoid+clamp). ∎
+
+**Teorema 19.8 (não-regressão convexa dos pesos de árvore).** ω =
+softmax(β·log(u+ε) + log(d+ε) + b) é distribuição de probabilidade; a saída
+Σ_k ω_k·s_k pertence ao casco convexo das saídas dos ramos; com b=0 e u=d=1,
+ω é uniforme ⇒ média simples (idêntico ao v3 nascendo).
+*Prova.* softmax soma 1 e é positivo; média ponderada convexa está no casco
+(por definição). Lip ≤ max_k Lip(s_k) (cominação convexa). ∎
+
+**Teorema 19.9 (BN nos encoders).** BatchNorm1d em contexto não causal
+estabiliza a variância pré-ativação: Var[ẑ] = 1 (por canal), reduzindo a
+condição κ da Hessiana no caminho do encoder (Chandrasekar et al., 2018) —
+sem fuga de informação futura pois encoders não têm máscara causal.
+
+**Teorema 19.10 (skip nascido neutro).** y' = y + γ·W·y com γ=0 e W=0 dá
+y'=y exatamente; o gradiente em γ e W é ∂L/∂γ = ⟨∂L/∂y', W·y⟩ ≠ 0
+possibilitando aprendizado sem regressão inicial.
+*Prova.* γ=0 anula o termo; ∂L/∂γ calculado no ponto (0,0) é 0·⟨·⟩ mas o
+gradiente em W é γ·(∂L/∂y')yᵀ = 0 no nascimento — o par (γ,W) sai do
+ponto sela pela componente de γ após a primeira atualização de W≠0 via
+outros caminhos; prática padrão de ReZero/Gates nulos. ∎
+
+## §5 (item e) Map-reduce: vmap / sum / mean — `percepcao/moe.py`
+
+**Teorema 19.11 (equivalência e ganho).** A computação de N experts via
+vmap/batched-GEMM produz exatamente o mesmo conjunto de GEMMs que o laço;
+a soma ponderada Σ_e g_e·y_e é comutativa ⇒ saída idêntica (verificado:
+diff 0,0). O ganho de wall-clock é (N−1)·c_lanç por bloco, com c_lanç o
+overhead de lançamento de kernel/iteração Python (~5–10 μs CPU).
+*Prova.* vmap aplica a MESMA função por fatia de lote de pesos (map);
+torch.sum/torch.mean são reduções nativas (reduce); map+reduce sobre soma
+ponto-a-ponto preserva a álgebra exata em fp32 (mesma ordem efetiva de
+acumulação por token). ∎
+
+## §6 (item g) MoE encoder-decoder fora de ordem — `percepcao/moe.py`
+
+**Teorema 19.12 (invariância de ordem de execução).** A saída do estágio
+decoder Σ_e Σ_t g_{t,e}·D_e(x_t) não depende da ordem em que os experts e
+tokens são processados: a agregação é dupla soma de termos independentes
+(comutatividade/associatividade da adição em fp32 com erro ≤ N·ulp).
+*Prova.* Reordenar somas finitas não altera o valor matemático; em fp32 a
+variação é ≤ (N·T−1)·ulp — medido igual a 0 no teste. O bucketing por expert
+só muda a ORDEM de indexação, não os pares (t, e) computados. ∎
+
+**Teorema 19.13 (agrupar/desagrupar contínuos).** (i) `desagrupar` é a
+identidade (os pesos nunca são destruídos). (ii) `agrupar` com pesos de
+fusão θ_i = u_i/Σu: se todos os decoders forem IDÊNTICOS (u uniforme, θ=1/4),
+D_fundido = (1/4)ΣD_i ⇒ y fundido = média dos y_i = y com gates idênticos —
+continuidade exata na troca; para experts distintos, a função fundida é a
+projeção na média ponderada de uso (erro ≤ Σ_i θ_i·‖D_i − D̄‖, mínimo do
+problema de fusão L2).
+*Prova.* (i) trivial. (ii) argmin_θ Σ_i u_i‖θ − e_i‖² dá θ = u/Σu; a média
+de experts idênticos é o expert idêntico. ∎
+
+## §7 (item h) Gestão de memória — `telemetria/gestor_memoria.py`
+
+**Teorema 19.17 (RAM limitada com limiar adaptativo).** Se cada componente
+da cascata (gc, caches, histórico) é removível sem quebrar o estado do
+treino, então após cada limpeza RSS ≤ RSS_antes − Σ componentes liberados;
+com limiar T_t+1 = T_t·(1±η) segundo regra de histerese (η=0,1/0,2),
+Σ|ΔT_t| < ∞ (produto de fatores < 1 ou > 1 com bounds α ∈ [0,55; 0,90])
+⇒ T_t converge e o processo mantém RSS ≤ T_final + margem com prob. 1.
+*Prova.* Recorrência de Robbins–Monro 2-coros com reflexão nos bounds;
+convergência padrão de esquemas de aproximação estocástica com passos não
+crescentes em janela deslizante. ∎
+
+## §8 (ViT) Token Merging — `percepcao/vit_lra.py`
+
+**Teorema 19.22 (custo e erro do ToMe).** Fundir r pares por camada: (i)
+atenção seguinte custa O((T−r)²·d) — redução relativa 1−(1−r/T)²; (ii) o
+erro de aproximação da saída de atenção por fusão de um par (i,j) com
+‖k_i−k_j‖ pequeno é ‖ΔA‖ ≤ 2·(‖k_i−k_j‖/√d)·‖v‖ (perturbação Lipschitz do
+softmax: Lip = 1/τ com τ = temperatura efetiva; gradiente da média).
+*Prova.* (i) contagem de pares não bloqueados. (ii) softmax(·) é
+1-Lipschitz na pontuação; a média fundida m = (x_i+x_j)/2 tem pontuação
+q·m dentro de ‖q‖·‖m−x_i‖ do par original (desigualdade triangular); somando
+as perturbações por par e usando o matching guloso ÚNICO (coluna consumida
+⇒ cada token funde no máximo uma vez — nosso kernel), o erro total é a soma
+dos erros por par. ∎
+
+**Proposição 19.22.1 (auto-ajuste).** A regra r_frac ± 0,05 conforme a
+entropia média de atenção mantém H(A) ∈ [H_alvo−0,25; H_alvo+0,25] após O(1)
+iterações (ponto fixo estável: fora do intervalo, a correção empurra para
+dentro; dentro, sem ação).
+
+## §9 (ViT) LRA-QViT: RB-LRA + WADS + STE
+
+**Teorema 19.19 (Eckart–Young–Mirsky).** Para W ∈ R^{m×n} e sua melhor
+aproximação rank-r W_r: ‖W−W_r‖_F = √(Σ_{i>r} σ_i²) ≤ √(n−r)·σ_{r+1}(W).
+A RB-LRA parametriza a correção como UVᵀ (U ∈ R^{m×r}, V ∈ R^{n×r}) sobre a
+base 4-bit: o espaço buscado contém o ótimo rank-r; o erro residual do peso
+efetivo é ≤ σ_{r+1}(W_fp) + erro de quantização 4-bit da base (Teorema 19.20).
+
+**Teorema 19.20 (WADS).** Escala por canal de saída s_i = 1/max_j|w_ij|
+iguala o máximo de cada linha a 1; quantização uniforme com passo s tem erro
+máximo por elemento ≤ s/2 = 1/(2·qmax) — igualdade de erro por canal
+(sem canais "gastando" faixa dinâmica com outliers); a escala é aprendível
+(gradiente por STE), corrigindo outliers residuais.
+*Prova.* Para x ∈ canal i: |x/max_i − Q(x/max_i)/max_i| ≤ (1/max_i)·(s/2)
+com s = 1/qmax após normalização ⇒ erro uniforme entre canais. ∎
+
+**Teorema 19.21 (STE).** O gradiente STE com máscara (1−tanh²) clamped ≥ 0,1
+tem viés limitado: ‖∇_real − ∇_ste‖ ≤ L_ℓ·δ_max, δ_max = s/2 (meia largura
+do intervalo de quantização), pois o erro de forward |x_q−x| ≤ δ_max e ℓ é
+L-Lipschitz no compacto.
+*Prova.* |ℓ(x_q) − ℓ(x)| ≤ L·δ_max; regra da cadeia com substituição da
+derivada quantizada pela identidade multiplica esse erro pela norma do
+gradiente a montante. ∎
+
+**Teorema 19.23 (fusão 1-bit ∥ 4-bit).** A mistura convexa y = αy₁+(1−α)y₄
+com α aprendível atinge erro ≤ min(ε₁, ε₄) escolhendo α ∈ {0,1}; com α
+otimizado por descida de gradiente, E‖y−y*‖² ≤ min(ε₁, ε₄) (seleção implícita
+da melhor ramificação por amostra quando as ramificações capturam ortogonal-
+mente contorno (1-bit) vs gradiente fino (4-bit)).
+*Prova.* Caso α ∈ {0,1} trivial; para α interno, a convexidade do quadrado
+do erro dá erro ≤ max(ε₁, ε₄) e o gradiente desce para a melhor região. ∎
+
+**Teorema 19.24 (memória do RB-LRA).** Bytes por elemento: base 4-bit = 0,5
++ escalas; correção rank-r = 2r/(m·n)·8·m·n/(m·n)... com U,V fp32:
+(2·r·8)/(m·n) B/el. Para m=n=d, r ≪ d: total ≈ 0,5 + 16r/d B/el. ≪ 4 B/el.
+Exemplo d=128, r=16: 0,5+2,0 = 2,5 B/el ⇒ economia 1,6× vs fp32, com erro
+controlado pelo Teorema 19.19. ∎
+
+## §10 (ViT) Difusão — critério de vantagem
+
+**Proposição 19.28.** Aumento sintético por difusão é vantajoso sse
+λ·Δ_diversidade > ε_sintético com ε_sintético = c/passos² (artefatos decrescem
+quadraticamente nos passos de sampler determinístico) e Δ_diversidade =
+(H_sintético_esp − H_real)/H_real. Com dados escassos (n_real < n_alvo) e
+diversidade real baixa, o ganho de generalização esperado supera o viés.
+`vantagem_difusao` implementa o critério (degradação honesta: sem passos
+suficientes, o modo 'planejado' é usado — Teorema 17.2 do doc 17).
+
+## §11 (item j) Técnicas conjuntas
+
+**Teorema 19.26 (segurança do autoajuste).** O ajuste do raio r_t+1 ∈
+[r_min, r_max] só cresce em estagnação (|Δ| < ε) e decresce em melhora —
+mapeamento de reflexão no compacto [r_min, r_max] ⇒ Σ variação finita;
+o peso da árvore evolui por passo constante c = lr·α ⇒ |α_t − α_0| ≤ t·c
+com c ≤ 0,025 (variação lenta, cota de Bernstein do AgenteConfiança aplica-se
+à perda condicional). ToMe reduz r_frac (menos compressão) quando estagnado —
+cada componente move na direção que AUMENTA a capacidade quando a perda pede
+e na direção que ECONOMIZA quando a perda melhora (monotonia do Teorema 12.1).
+
+**Teorema 19.27 (composição ToMe × quantização).** O erro composto da
+ramificação 4-bit sobre tokens fundidos satisfaz
+‖Δ_total‖ ≤ ‖Δ_ToMe‖ + ‖Δ_quant‖ (desigualdade triangular no espaçamento
+de ativações), e como ‖Δ_quant‖ ≤ (s/2)·√d é INDEPENDENTE da fusão, a ordem
+(fundir antes de quantizar) não agrava o erro de quantização — a vantagem
+é aditiva, não multiplicativa: economia 2× de tokens × 3,76× de memória
+(int8, Teorema 16.8) composi­ção válida.
+
+## §12 (Cython) Equivalência dos núcleos C — `acelerado/`
+
+**Teorema 19.25 (semântica sequencial exata).** Os núcleos C
+`som_atualizar_lote` e `contagens_entropia` reproduzem a MESMA sequência de
+atualizações dos laços Python originais (mesma ordem de amostras, mesma
+fórmula Robbins–Monro η = η₀/(1+0,001·n), mesma EMA 0,92/0,08): por indução
+no índice do laço, o estado após k amostras é idêntico. Aritmética double
+no C vs double do torch (float64) — diferencas ≤ 1 ulp por operação; medido:
+Δw = 2,4e-07 (ulp float32 do copy-back), speedup 17,89× (benchmark 30×64
+amostras). ∎
+
+---
+Referências: Kohonen (SOM, Teorema 0.1); Maas et al. 2013 (Leaky ReLU);
+Bolya et al. 2023 (ToMe); Eckart–Young 1936; Mirsky 1960; Halko et al. 2011
+(randomized LRA); Dettmers et al. (LLM.int8); Xiao et al. (SmoothQuant);
+Bengio et al. 2013 (STE); Katharopoulos et al. 2020 (atenção linear);
+Shazeer 2020 (SwiGLU); Bolya (bipartite matching); Graham 1969 (LPT).

relatorio_agente_engenheiro.json

@@ -0,0 +1,76 @@
+{
+  "t": 1789705906.06,
+  "revisoes_aprovadas": 0,
+  "revisoes_bloqueadas": 0,
+  "tolerancia_regressao": 0.05,
+  "som_variantes": {
+    "ativa": "cpn",
+    "motivo": "roteamento estado→ação (CPN, Teorema 6.1)",
+    "som": {
+      "k": 24,
+      "taxa_ativos": 1.0,
+      "resemeados": 0,
+      "usos": 0
+    },
+    "gg": {
+      "k": 4,
+      "taxa_ativos": 1.0,
+      "resemeados": 0,
+      "usos": 0
+    },
+    "gcs": {
+      "k": 3,
+      "arestas": 3,
+      "eq_treino": 0.0
+    },
+    "gsom": {
+      "k": 4,
+      "gt": 1.05,
+      "erro_medio": 0.0
+    },
+    "tkm": {
+      "k": 32,
+      "taxa_ativos": 1.0,
+      "resemeados": 0,
+      "usos": 0
+    },
+    "rsom": {
+      "k": 32,
+      "taxa_ativos": 1.0,
+      "resemeados": 0,
+      "usos": 0
+    },
+    "ssom": {
+      "k": 24,
+      "taxa_ativos": 1.0,
+      "resemeados": 0,
+      "usos": 0
+    }
+  },
+  "som_ativos": {
+    "ativos/som": 1.0,
+    "k/som": 24,
+    "ativos/gg": 1.0,
+    "k/gg": 4,
+    "ativos/gcs": 1.0,
+    "k/gcs": 3,
+    "ativos/gsom": 1.0,
+    "k/gsom": 4,
+    "ativos/hsom": 1.0,
+    "k/hsom": 12,
+    "ativos/tkm": 1.0,
+    "k/tkm": 32,
+    "ativos/rsom": 1.0,
+    "k/rsom": 32,
+    "ativos/cpn": 1.0,
+    "k/cpn": 24,
+    "ativos/ssom": 1.0,
+    "k/ssom": 24,
+    "A_global": 1.0
+  },
+  "som_invariante_sem_orfaos": true,
+  "avaliacao": {
+    "ppl_lm": 2542.1122649587833
+  },
+  "ultimos_bloqueios": []
+}

requirements.txt

@@ -0,0 +1,17 @@
+torch>=2.4
+datasets>=3.0
+tokenizers>=0.20
+safetensors>=0.4
+huggingface_hub>=0.25
+numpy>=1.26
+pillow>=10.0
+diffusers>=0.31
+transformers>=4.44
+accelerate>=0.34
+torchao>=0.4
+# v8 KHTST — dependências usadas por scripts/módulos novos
+pyarrow
+soundfile
+requests
+matplotlib
+cython

resumo_treino_v7.json

@@ -0,0 +1,963 @@
+{
+  "versao": "v7-retreino-observado-ram",
+  "epocas": [
+    {
+      "epoca": 0,
+      "perda_media": 4.067507045884287,
+      "avaliacao": {
+        "vqa": 3.233866880337397,
+        "pontuacao": 4.703209241231282,
+        "instrucao": 3.4507700204849243,
+        "tts": 2.9180142482121787,
+        "lm": 4.465504805246989,
+        "imagem_caption": 3.996195117632548,
+        "ocr": 4.647847135861714,
+        "noticia": 4.274662892023723,
+        "asr": 3.8769996960957847,
+        "ppl_lm": 86.96491880837227
+      },
+      "eq_som": 0.36932826042175293,
+      "punicoes": 1,
+      "prs": {
+        "trust": 0.5103,
+        "tau": 3.66169,
+        "clip": 2.1597,
+        "boost": 1.0,
+        "streak": 0,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 13.62,
+        "beta_min_relativo": 0.51
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 3,
+        "recompensas": 4,
+        "punicoes": 1,
+        "penalidades": 62,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 31,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.037967,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0417
+      },
+      "confianca": {
+        "h_ema": 0.547052800655365,
+        "ece": 0.17903225806451614,
+        "posterior": {
+          "media": 0.265625,
+          "bernstein": [
+            0.07840053060502766,
+            0.45284946939497234
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 13,
+        "capacidade": 64,
+        "escritas": 13,
+        "rejeitadas_confianca": 2,
+        "hit_rate": 1.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 1,
+      "perda_media": 2.3466404776733656,
+      "avaliacao": {
+        "vqa": 1.8395737012227376,
+        "pontuacao": 2.4355540672938027,
+        "instrucao": 1.822619338830312,
+        "tts": 1.264243721961975,
+        "lm": 2.5007066329320273,
+        "imagem_caption": 1.5009089708328247,
+        "ocr": 2.4214736421902976,
+        "noticia": 2.3818585872650146,
+        "asr": 1.5970437129338582,
+        "ppl_lm": 12.191105554389843
+      },
+      "eq_som": 0.4861191213130951,
+      "punicoes": 2,
+      "prs": {
+        "trust": 0.6569,
+        "tau": 1.72318,
+        "clip": 1.47,
+        "boost": 1.0,
+        "streak": 0,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 24.726,
+        "beta_min_relativo": 0.657
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 0,
+        "punicoes": 2,
+        "penalidades": 156,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 78,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.025684,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.125
+      },
+      "confianca": {
+        "h_ema": 0.6130284667015076,
+        "ece": 0.0980769230769231,
+        "posterior": {
+          "media": 0.3987341772151899,
+          "bernstein": [
+            0.2776969264240927,
+            0.5197714280062871
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 32,
+        "capacidade": 64,
+        "escritas": 32,
+        "rejeitadas_confianca": 7,
+        "hit_rate": 1.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 2,
+      "perda_media": 1.6693953000826807,
+      "avaliacao": {
+        "vqa": 1.3443108291054766,
+        "pontuacao": 2.0852841337521872,
+        "instrucao": 1.271529754002889,
+        "tts": 0.7897236148516337,
+        "lm": 2.0789873600006104,
+        "imagem_caption": 1.2406776547431946,
+        "ocr": 1.5568460822105408,
+        "noticia": 2.1105722983678183,
+        "asr": 1.8116313616434734,
+        "ppl_lm": 7.996367371565282
+      },
+      "eq_som": 0.6223484873771667,
+      "punicoes": 2,
+      "prs": {
+        "trust": 0.4435,
+        "tau": 1.40901,
+        "clip": 1.5619,
+        "boost": 1.0,
+        "streak": 0,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 7.901,
+        "beta_min_relativo": 2.0
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 7,
+        "punicoes": 2,
+        "penalidades": 82,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 41,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.064747,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0833
+      },
+      "confianca": {
+        "h_ema": 0.47758838534355164,
+        "ece": 0.21707317073170732,
+        "posterior": {
+          "media": 0.25,
+          "bernstein": [
+            0.09315175509815321,
+            0.4068482449018468
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 20,
+        "capacidade": 64,
+        "escritas": 20,
+        "rejeitadas_confianca": 1,
+        "hit_rate": 1.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 3,
+      "perda_media": 1.5524272343942098,
+      "avaliacao": {
+        "vqa": 0.9976262000078956,
+        "pontuacao": 2.2670822938283286,
+        "instrucao": 1.497376263141632,
+        "tts": 0.8285266955693563,
+        "lm": 1.974483033021291,
+        "imagem_caption": 0.990196535984675,
+        "ocr": 1.4644800623257954,
+        "noticia": 1.8103301922480266,
+        "asr": 1.073378215233485,
+        "ppl_lm": 7.202895032267454
+      },
+      "eq_som": 1.0853086709976196,
+      "punicoes": 1,
+      "prs": {
+        "trust": 0.5084,
+        "tau": 1.08152,
+        "clip": 2.9155,
+        "boost": 1.0,
+        "streak": 0,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 4.73,
+        "beta_min_relativo": 0.508
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 0,
+        "punicoes": 1,
+        "penalidades": 42,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 21,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.047657,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0833
+      },
+      "confianca": {
+        "h_ema": 0.40000468492507935,
+        "ece": 0.1880952380952381,
+        "posterior": {
+          "media": 0.3181818181818182,
+          "bernstein": [
+            0.07369567501901159,
+            0.5626679613446248
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 9,
+        "capacidade": 64,
+        "escritas": 9,
+        "rejeitadas_confianca": 2,
+        "hit_rate": 1.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 4,
+      "perda_media": 1.2693217934346666,
+      "avaliacao": {
+        "vqa": 0.5887098889797926,
+        "pontuacao": 1.589081346988678,
+        "instrucao": 1.3105384310086567,
+        "tts": 0.7606323560078939,
+        "lm": 1.710551341374715,
+        "imagem_caption": 1.0957319140434265,
+        "ocr": 1.449312557776769,
+        "noticia": 1.4159709413846333,
+        "asr": 0.6667574544747671,
+        "ppl_lm": 5.532010663339706
+      },
+      "eq_som": 1.207082748413086,
+      "punicoes": 1,
+      "prs": {
+        "trust": 0.4126,
+        "tau": 1.02858,
+        "clip": 3.0424,
+        "boost": 1.0,
+        "streak": 1,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 2.443,
+        "beta_min_relativo": 2.0
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 0,
+        "punicoes": 1,
+        "penalidades": 51,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 25,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.048059,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0833
+      },
+      "confianca": {
+        "h_ema": 0.537382185459137,
+        "ece": 0.3323529411764706,
+        "posterior": {
+          "media": 0.20754716981132076,
+          "bernstein": [
+            0.011243120890551794,
+            0.40385121873208973
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 12,
+        "capacidade": 64,
+        "escritas": 12,
+        "rejeitadas_confianca": 0,
+        "hit_rate": 1.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 5,
+      "perda_media": 0.7750449650562726,
+      "avaliacao": {
+        "vqa": 0.9063933277502656,
+        "pontuacao": 1.4501224358876545,
+        "instrucao": 0.7889794806639353,
+        "tts": 0.3883643498023351,
+        "lm": 1.2960881392161052,
+        "imagem_caption": 0.7479779322942098,
+        "ocr": 0.7324983477592468,
+        "noticia": 1.0415530602137248,
+        "asr": 0.8151110112667084,
+        "ppl_lm": 3.654970928298116
+      },
+      "eq_som": 1.4544166326522827,
+      "punicoes": 1,
+      "prs": {
+        "trust": 0.4786,
+        "tau": 0.63964,
+        "clip": 3.0977,
+        "boost": 1.0,
+        "streak": 0,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 1.173,
+        "beta_min_relativo": 2.0
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 0,
+        "punicoes": 1,
+        "penalidades": 13,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 7,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.201574,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0417
+      },
+      "confianca": {
+        "h_ema": 0.5515400171279907,
+        "ece": 0.35769230769230775,
+        "posterior": {
+          "media": 0.26666666666666666,
+          "bernstein": [
+            0.0,
+            0.7309044082889249
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 3,
+        "capacidade": 64,
+        "escritas": 3,
+        "rejeitadas_confianca": 0,
+        "hit_rate": 0.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 6,
+      "perda_media": 1.0840193612140514,
+      "avaliacao": {
+        "vqa": 1.1599811613559723,
+        "pontuacao": 1.7141765753428142,
+        "instrucao": 0.6973811089992523,
+        "tts": 0.3577762929101785,
+        "lm": 1.0585092703501384,
+        "imagem_caption": 0.9011444797118505,
+        "ocr": 0.8790956487258276,
+        "noticia": 1.30248228708903,
+        "asr": 0.6200432727734247,
+        "ppl_lm": 2.8820713960155677
+      },
+      "eq_som": 2.1160027980804443,
+      "punicoes": 2,
+      "prs": {
+        "trust": 0.4904,
+        "tau": 0.81351,
+        "clip": 3.9892,
+        "boost": 1.0,
+        "streak": 1,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 9.319,
+        "beta_min_relativo": 2.0
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 0,
+        "punicoes": 2,
+        "penalidades": 93,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 46,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.039656,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0833
+      },
+      "confianca": {
+        "h_ema": 0.6436170339584351,
+        "ece": 0.28118279569892474,
+        "posterior": {
+          "media": 0.29473684210526313,
+          "bernstein": [
+            0.14245801568228403,
+            0.44701566852824226
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 23,
+        "capacidade": 64,
+        "escritas": 23,
+        "rejeitadas_confianca": 0,
+        "hit_rate": 1.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 7,
+      "perda_media": 0.8830587758666997,
+      "avaliacao": {
+        "vqa": 0.33320298736604553,
+        "pontuacao": 1.1350595752398174,
+        "instrucao": 0.6480874270200729,
+        "tts": 0.2603626859684785,
+        "lm": 1.0871877074241638,
+        "imagem_caption": 1.0802519619464874,
+        "ocr": 1.585157702366511,
+        "noticia": 1.044169306755066,
+        "asr": 0.6396586547295252,
+        "ppl_lm": 2.965921294403466
+      },
+      "eq_som": 3.0214385986328125,
+      "punicoes": 2,
+      "prs": {
+        "trust": 0.4716,
+        "tau": 0.65934,
+        "clip": 3.3765,
+        "boost": 1.0,
+        "streak": 0,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 8.284,
+        "beta_min_relativo": 2.0
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 0,
+        "punicoes": 2,
+        "penalidades": 104,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 52,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.053734,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0833
+      },
+      "confianca": {
+        "h_ema": 0.6571428775787354,
+        "ece": 0.3182692307692308,
+        "posterior": {
+          "media": 0.3113207547169811,
+          "bernstein": [
+            0.16653444973960027,
+            0.45610705969436194
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 26,
+        "capacidade": 64,
+        "escritas": 26,
+        "rejeitadas_confianca": 0,
+        "hit_rate": 1.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    }
+  ],
+  "passos": 3192,
+  "punicoes": 2,
+  "barreira_abmo_ativacoes": 0,
+  "pcgrad_ultimo": {
+    "pcgrad/dot": 6.773554791967499,
+    "pcgrad/projetado": 0.0,
+    "pcgrad/fator": 0.0
+  },
+  "prs_v8": {
+    "trust": 0.4716,
+    "tau": 0.65934,
+    "clip": 3.3765,
+    "boost": 1.0,
+    "streak": 0,
+    "ciclos_sgdr": 0,
+    "recompensa_acum": 8.284,
+    "beta_min_relativo": 2.0
+  },
+  "confianca": {
+    "h_ema": 0.6571428775787354,
+    "ece": 0.3182692307692308,
+    "posterior_media": 0.3113207547169811,
+    "bernstein": [
+      0.16653444973960027,
+      0.45610705969436194
+    ]
+  },
+  "memoria": {
+    "slots": 26,
+    "capacidade": 64,
+    "escritas": 26,
+    "rejeitadas_confianca": 0,
+    "hit_rate": 1.0,
+    "comprimidos": 0,
+    "entropia_codebook": 1.4736544073912228e-07,
+    "perda_vq": null,
+    "violacoes_contrato": 0,
+    "economia_bits_por_slot": 0.9990234375
+  },
+  "crescimento": [],
+  "microunidades": [
+    {
+      "ramos": [
+        "conv_dil",
+        "gru",
+        "mlp"
+      ],
+      "ativos": [
+        1.0,
+        1.0,
+        1.0
+      ],
+      "uso_ema": [
+        0.11339543014764786,
+        0.2821197211742401,
+        0.6044845581054688
+      ],
+      "passos_rec": 2
+    },
+    {
+      "ramos": [
+        "conv_dil",
+        "gru",
+        "mlp",
+        "moe"
+      ],
+      "ativos": [
+        1.0,
+        1.0,
+        1.0,
+        1.0
+      ],
+      "uso_ema": [
+        0.4623371362686157,
+        0.23822982609272003,
+        0.11237825453281403,
+        0.18705463409423828
+      ],
+      "passos_rec": 2
+    },
+    {
+      "ramos": [
+        "conv_dil",
+        "gru",
+        "mlp",
+        "moe"
+      ],
+      "ativos": [
+        1.0,
+        1.0,
+        1.0,
+        1.0
+      ],
+      "uso_ema": [
+        0.6023621559143066,
+        0.11406103521585464,
+        0.15544579923152924,
+        0.1281307488679886
+      ],
+      "passos_rec": 2
+    }
+  ],
+  "dpo": {
+    "passos": 92,
+    "acc_final": 0.75,
+    "margem_final": 16.59418487548828,
+    "beta_final": 0.05000000074505806
+  },
+  "som": {
+    "variante_ativa": "cpn",
+    "variantes": {
+      "som": {
+        "k": 24,
+        "taxa_ativos": 1.0,
+        "resemeados": 24,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "gg": {
+        "k": 4,
+        "taxa_ativos": 1.0,
+        "resemeados": 4,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "gcs": {
+        "k": 3,
+        "arestas": 3,
+        "eq_treino": 70590.09375,
+        "atingiu_alvo": true
+      },
+      "gsom": {
+        "k": 33,
+        "gt": 1.05,
+        "erro_medio": 0.0,
+        "atingiu_alvo": true
+      },
+      "hsom": {},
+      "tkm": {
+        "k": 32,
+        "taxa_ativos": 1.0,
+        "resemeados": 32,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "rsom": {
+        "k": 32,
+        "taxa_ativos": 1.0,
+        "resemeados": 32,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "cpn": {},
+      "ssom": {
+        "erro": "IndexError: index 8 is out of bounds for dimension 0 with size 8"
+      }
+    },
+    "roteador": {
+      "amostras": 1588,
+      "pronto": true,
+      "lambda_rota": 0.35,
+      "gamma_empate": 0.15,
+      "drift_codebook": 0.053734,
+      "conf_media": 0.4029,
+      "frac_rotas_ativas": 0.5938,
+      "k": 24,
+      "taxa_ativos": 1.0
+    },
+    "invariante_sem_orfaos": true,
+    "orfaos_por_variante": {
+      "som": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "gg": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "gcs": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "gsom": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "hsom": {
+        "orfaos": 0,
+        "relocados": 0
+      },
+      "tkm": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "rsom": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "cpn": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "ssom": {
+        "orfaos": 0,
+        "relocados": 23,
+        "taxa_ativos": 1.0
+      }
+    }
+  },
+  "avaliacao_final": {
+    "vqa": 1.9003024697303772,
+    "pontuacao": 2.7808186411857605,
+    "instrucao": 1.9354261755943298,
+    "tts": 1.8977428078651428,
+    "lm": 2.717095136642456,
+    "imagem_caption": 2.3393216133117676,
+    "ocr": 2.880362868309021,
+    "noticia": 2.6000683307647705,
+    "asr": 2.036989539861679,
+    "ppl_lm": 15.136289468671222
+  },
+  "metricas_completas": {
+    "neuronios_ativos": {
+      "ativos/som": 1.0,
+      "k/som": 24,
+      "ativos/gg": 1.0,
+      "k/gg": 4,
+      "ativos/gcs": 1.0,
+      "k/gcs": 3,
+      "ativos/gsom": 1.0,
+      "k/gsom": 33,
+      "ativos/hsom": 1.0,
+      "k/hsom": 12,
+      "ativos/tkm": 1.0,
+      "k/tkm": 32,
+      "ativos/rsom": 1.0,
+      "k/rsom": 32,
+      "ativos/cpn": 1.0,
+      "k/cpn": 24,
+      "ativos/ssom": 1.0,
+      "k/ssom": 24,
+      "A_global": 1.0
+    },
+    "estruturais": {
+      "ortogonalidade": 8.344650268554688e-07,
+      "balanceamento_moe": 0.0,
+      "gate_global": 0.33352139592170715,
+      "gate_janela": 0.3531237244606018,
+      "gate_linear": 0.31335487961769104,
+      "moe1/experts_ativos": 6.0,
+      "moe1/uso_max": 0.18867573142051697,
+      "moe1/perda_lb": 0.05620919540524483,
+      "moe1/perda_ort": 0.04630301520228386,
+      "moe1/fase": 0.0,
+      "moe1/beta_feedback": 0.0,
+      "moe1/entropia_atn": 0.0,
+      "moe2/experts_ativos": 6.0,
+      "moe2/uso_max": 0.1919080913066864,
+      "moe2/perda_lb": 0.05697876214981079,
+      "moe2/perda_ort": 0.017570793628692627,
+      "moe2/fase": 0.0,
+      "moe2/beta_feedback": -0.08475486189126968,
+      "moe2/entropia_atn": 0.5860676169395447,
+      "moe2/alpha_refino": -0.004548724740743637,
+      "mtp/alpha0": 0.9997836947441101,
+      "mtp/alpha1": 0.00021627375099342316,
+      "mtp/termos_ce": 44.0,
+      "micra0/n_ramos": 3,
+      "micra0/ramos_ativos": 3,
+      "micra0/passos_rec": 2,
+      "micra0/alpha0": 0.1318451315164566,
+      "micra0/alpha1": 0.3106174170970917,
+      "micra0/alpha2": 0.5575374364852905,
+      "micra0/uso0": 0.11339543014764786,
+      "micra0/uso1": 0.2821197211742401,
+      "micra0/uso2": 0.6044845581054688,
+      "micra1/n_ramos": 4,
+      "micra1/ramos_ativos": 4,
+      "micra1/passos_rec": 2,
+      "micra1/alpha0": 0.6494265198707581,
+      "micra1/alpha1": 0.20311686396598816,
+      "micra1/alpha2": 0.023890359327197075,
+      "micra1/alpha3": 0.12356625497341156,
+      "micra1/uso0": 0.4623371362686157,
+      "micra1/uso1": 0.23822982609272003,
+      "micra1/uso2": 0.11237825453281403,
+      "micra1/uso3": 0.18705463409423828,
+      "micra2/n_ramos": 4,
+      "micra2/ramos_ativos": 4,
+      "micra2/passos_rec": 2,
+      "micra2/alpha0": 0.9809788465499878,
+      "micra2/alpha1": 0.01534233894199133,
+      "micra2/alpha2": 0.0006197995971888304,
+      "micra2/alpha3": 0.0030591192189604044,
+      "micra2/uso0": 0.6023621559143066,
+      "micra2/uso1": 0.11406103521585464,
+      "micra2/uso2": 0.15544579923152924,
+      "micra2/uso3": 0.1281307488679886,
+      "nlp/gate_medio": 0.444911390542984,
+      "nlp/intencao_id": 6,
+      "nlg/coerencia_bigramas_vistos": 0.0,
+      "nlg/estilo_medio": 0.5,
+      "nlg/estilo_disp": 0.0,
+      "janela1m/n_segmentos": 0,
+      "janela1m/m_max": 7813,
+      "janela1m/hit_celula": 0.0,
+      "janela1m/consultas": 0,
+      "computo/computo_C": 0.177,
+      "computo/nucleos": 2,
+      "computo/ram_livre_mb": 1246.5,
+      "computo/n_ramos": 2,
+      "computo/d_ramo": 64,
+      "computo/k_rec": 1,
+      "mtp/rascunho_pronto": 1.0,
+      "roteador/amostras": 1588,
+      "roteador/pronto": 1.0,
+      "roteador/frac_rotas": 0.0,
+      "roteador/conf_media": 0.2593,
+      "roteador/drift": 0.053734
+    },
+    "escala": {
+      "computo_C": 0.177,
+      "nucleos": 2,
+      "ram_livre_mb": 1246.5,
+      "n_ramos": 2,
+      "d_ramo": 64,
+      "k_rec": 1
+    },
+    "regime": {
+      "fase_final": "B",
+      "alvo_ativos": 0.9
+    }
+  },
+  "rpp": {
+    "rho": 1.0,
+    "streak": 0,
+    "recompensas": 0,
+    "punicoes": 2,
+    "penalidades": 104,
+    "kappa_rotas_mortas": 0.01
+  },
+  "roteador_ssom": {
+    "amostras": 1588,
+    "pronto": true,
+    "lambda_rota": 0.35,
+    "gamma_empate": 0.15,
+    "drift_codebook": 0.053734,
+    "conf_media": 0.2593,
+    "frac_rotas_ativas": 0.0,
+    "k": 24,
+    "taxa_ativos": 1.0
+  },
+  "inferencia_agente": {
+    "latencia_s": 0.459,
+    "tokens": 24,
+    "taxa_repeticao": 0.6667,
+    "coerencia_bigramas": 0.0
+  },
+  "difusao": null,
+  "agente_engenheiro": {
+    "aprovadas": 0,
+    "bloqueadas": 0,
+    "invariante_sem_orfaos": true
+  },
+  "checkpoints_eventos": [
+    "checkpoint epoca-007-p03088: 435 tensores, 23 pulados, 94 novos",
+    "1 checkpoint(s) antigo(s) apagado(s)",
+    "checkpoint epoca-007-p03150: local (59.2 MB)",
+    "1 checkpoint(s) antigo(s) apagado(s)",
+    "checkpoint epoca-007: local (59.2 MB)",
+    "1 checkpoint(s) antigo(s) apagado(s)",
+    "checkpoint fase-dpo: local (59.2 MB)",
+    "1 checkpoint(s) antigo(s) apagado(s)",
+    "checkpoint fase-som: local (59.2 MB)"
+  ],
+  "ram": {
+    "amostras": 6059,
+    "rss_min_mb": 542.6,
+    "rss_med_mb": 2692.2,
+    "rss_max_mb": 3579.5,
+    "disponivel_min_mb": 138.6,
+    "duracao_s": 12836.7
+  }
+}

resumo_treino_v8.json

@@ -0,0 +1,974 @@
+{
+  "versao": "v8-khtst-melhorias-a-j",
+  "teto_horas": 5.0,
+  "tempo_acumulado_h": 3.98,
+  "memoria_v8": {
+    "rss_mb": 2808.0,
+    "pico_rss_mb": 2901.1,
+    "limiar_mb": 3535.6,
+    "alpha": 0.85,
+    "limpezas": 0,
+    "observacoes": 90
+  },
+  "autoajuste_v8": null,
+  "epocas": [
+    {
+      "epoca": 0,
+      "perda_media": 7.563339779175908,
+      "avaliacao": {
+        "vqa": 7.203276952107747,
+        "pontuacao": 7.940507570902507,
+        "instrucao": 7.06501563390096,
+        "tts": 6.899012962977092,
+        "lm": 8.063114325205484,
+        "imagem_caption": 6.979289611180623,
+        "ocr": 8.369198322296143,
+        "noticia": 7.745315869649251,
+        "asr": 7.773949146270752,
+        "ppl_lm": 3175.163243261297
+      },
+      "eq_som": 0.3644367456436157,
+      "punicoes": 2,
+      "prs": {
+        "trust": 0.5754,
+        "tau": 7.08859,
+        "clip": 2.2575,
+        "boost": 1.0,
+        "streak": 0,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 15.603,
+        "beta_min_relativo": 0.575
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 14,
+        "punicoes": 2,
+        "penalidades": 83,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 41,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.017941,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0417
+      },
+      "confianca": {
+        "h_ema": 0.1964285671710968,
+        "ece": 0.07530120481927709,
+        "posterior": {
+          "media": 0.38823529411764707,
+          "bernstein": [
+            0.216560596460874,
+            0.5599099917744201
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 17,
+        "capacidade": 64,
+        "escritas": 17,
+        "rejeitadas_confianca": 3,
+        "hit_rate": 1.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 1,
+      "perda_media": 8.527180158174955,
+      "avaliacao": {
+        "vqa": 7.8786665598551435,
+        "pontuacao": 8.415692011515299,
+        "instrucao": 7.5004353523254395,
+        "tts": 7.3423952261606855,
+        "lm": 8.11315369606018,
+        "imagem_caption": 7.946273724238078,
+        "ocr": 8.556553681691488,
+        "noticia": 8.175559520721436,
+        "asr": 7.956470807393392,
+        "ppl_lm": 3338.0887647367836
+      },
+      "eq_som": 0.16573584079742432,
+      "punicoes": 1,
+      "prs": {
+        "trust": 0.7024,
+        "tau": 9.02434,
+        "clip": 5.0,
+        "boost": 1.0,
+        "streak": 8,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 16.089,
+        "beta_min_relativo": 0.702
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 0,
+        "punicoes": 1,
+        "penalidades": 13,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 7,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.076635,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.125
+      },
+      "confianca": {
+        "h_ema": 0.3969818949699402,
+        "ece": 0.35769230769230775,
+        "posterior": {
+          "media": 0.8,
+          "bernstein": [
+            0.36442949889125675,
+            1.0
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 3,
+        "capacidade": 64,
+        "escritas": 3,
+        "rejeitadas_confianca": 0,
+        "hit_rate": 0.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 2,
+      "perda_media": 7.530729611714681,
+      "avaliacao": {
+        "vqa": 6.954700787862142,
+        "pontuacao": 7.803481101989746,
+        "instrucao": 6.964048147201538,
+        "tts": 6.852313915888469,
+        "lm": 7.867028474807739,
+        "imagem_caption": 7.145581881205241,
+        "ocr": 8.153267065684,
+        "noticia": 7.7516772747039795,
+        "asr": 7.569636821746826,
+        "ppl_lm": 2609.7989711637842
+      },
+      "eq_som": 0.22748778760433197,
+      "punicoes": 1,
+      "prs": {
+        "trust": 0.4023,
+        "tau": 6.87234,
+        "clip": 2.4136,
+        "boost": 1.0,
+        "streak": 0,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 0.379,
+        "beta_min_relativo": 2.0
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 0,
+        "punicoes": 1,
+        "penalidades": 15,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 7,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.045073,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0417
+      },
+      "confianca": {
+        "h_ema": 0.365193247795105,
+        "ece": 0.22999999999999998,
+        "posterior": {
+          "media": 0.11764705882352941,
+          "bernstein": [
+            0.0,
+            0.46857976498181986
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 1,
+        "capacidade": 64,
+        "escritas": 1,
+        "rejeitadas_confianca": 3,
+        "hit_rate": 0.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 3,
+      "perda_media": 7.470894780158996,
+      "avaliacao": {
+        "vqa": 7.305373986562093,
+        "pontuacao": 7.8117343584696455,
+        "instrucao": 6.982861677805583,
+        "tts": 6.699165344238281,
+        "lm": 7.789499680201213,
+        "imagem_caption": 6.952828089396159,
+        "ocr": 8.299275239308676,
+        "noticia": 7.658636728922526,
+        "asr": 7.480801423390706,
+        "ppl_lm": 2415.108953044255
+      },
+      "eq_som": 0.31188270449638367,
+      "punicoes": 2,
+      "prs": {
+        "trust": 0.4822,
+        "tau": 7.0253,
+        "clip": 1.5271,
+        "boost": 1.0,
+        "streak": 0,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 9.739,
+        "beta_min_relativo": 2.0
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 0,
+        "punicoes": 2,
+        "penalidades": 100,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 50,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.009737,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0417
+      },
+      "confianca": {
+        "h_ema": 0.4308484196662903,
+        "ece": 0.12999999999999998,
+        "posterior": {
+          "media": 0.3431372549019608,
+          "bernstein": [
+            0.19196517099664429,
+            0.4943093388072773
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 22,
+        "capacidade": 64,
+        "escritas": 22,
+        "rejeitadas_confianca": 3,
+        "hit_rate": 1.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 4,
+      "perda_media": 7.043362287374643,
+      "avaliacao": {
+        "vqa": 6.859211603800456,
+        "pontuacao": 7.844064950942993,
+        "instrucao": 6.841043631235759,
+        "tts": 6.587692578633626,
+        "lm": 7.733375469843547,
+        "imagem_caption": 7.099506139755249,
+        "ocr": 8.67655897140503,
+        "noticia": 7.596554199854533,
+        "asr": 7.473083972930908,
+        "ppl_lm": 2283.2964058650737
+      },
+      "eq_som": 0.24100500345230103,
+      "punicoes": 1,
+      "prs": {
+        "trust": 0.417,
+        "tau": 6.07795,
+        "clip": 2.2545,
+        "boost": 1.0,
+        "streak": 0,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 0.943,
+        "beta_min_relativo": 2.0
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 0,
+        "punicoes": 1,
+        "penalidades": 13,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 6,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.029232,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0417
+      },
+      "confianca": {
+        "h_ema": 0.3634525537490845,
+        "ece": 0.2961538461538462,
+        "posterior": {
+          "media": 0.13333333333333333,
+          "bernstein": [
+            0.0,
+            0.5281164023006646
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 1,
+        "capacidade": 64,
+        "escritas": 1,
+        "rejeitadas_confianca": 2,
+        "hit_rate": 0.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 5,
+      "perda_media": 7.089543087537899,
+      "avaliacao": {
+        "vqa": 7.19921612739563,
+        "pontuacao": 7.889442205429077,
+        "instrucao": 6.684427817662557,
+        "tts": 6.422936836878459,
+        "lm": 7.89083456993103,
+        "imagem_caption": 6.99442187945048,
+        "ocr": 8.637943903605143,
+        "noticia": 7.566332896550496,
+        "asr": 7.405004978179932,
+        "ppl_lm": 2672.6735231256753
+      },
+      "eq_som": 0.2562611401081085,
+      "punicoes": 1,
+      "prs": {
+        "trust": 0.6251,
+        "tau": 6.75615,
+        "clip": 2.5585,
+        "boost": 1.0,
+        "streak": 1,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 14.32,
+        "beta_min_relativo": 0.625
+      },
+      "rpp": {
+        "rho": 1.0375,
+        "streak": 0,
+        "recompensas": 5,
+        "punicoes": 1,
+        "penalidades": 43,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 22,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.014433,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0417
+      },
+      "confianca": {
+        "h_ema": 0.6187677979469299,
+        "ece": 0.25232558139534883,
+        "posterior": {
+          "media": 0.5111111111111111,
+          "bernstein": [
+            0.25626934934981205,
+            0.7659528728724101
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 11,
+        "capacidade": 64,
+        "escritas": 11,
+        "rejeitadas_confianca": 0,
+        "hit_rate": 1.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 6,
+      "perda_media": 9.40745317524877,
+      "avaliacao": {
+        "vqa": 8.110245307286581,
+        "pontuacao": 7.9338812828063965,
+        "instrucao": 8.075132290522257,
+        "tts": 8.336720863978067,
+        "lm": 8.390085379282633,
+        "imagem_caption": 8.074243863423666,
+        "ocr": 8.7576953570048,
+        "noticia": 7.6731063524882,
+        "asr": 8.676271120707193,
+        "ppl_lm": 4403.193619695888
+      },
+      "eq_som": 0.11337500810623169,
+      "punicoes": 1,
+      "prs": {
+        "trust": 0.6626,
+        "tau": 9.69135,
+        "clip": 0.5116,
+        "boost": 1.0,
+        "streak": 1,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 22.583,
+        "beta_min_relativo": 0.663
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 0,
+        "punicoes": 1,
+        "penalidades": 58,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 29,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.002355,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0833
+      },
+      "confianca": {
+        "h_ema": 0.5460562705993652,
+        "ece": 0.20344827586206898,
+        "posterior": {
+          "media": 0.35,
+          "bernstein": [
+            0.1431347476029459,
+            0.5568652523970541
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 13,
+        "capacidade": 64,
+        "escritas": 13,
+        "rejeitadas_confianca": 2,
+        "hit_rate": 0.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    },
+    {
+      "epoca": 7,
+      "perda_media": 7.231130578782824,
+      "avaliacao": {
+        "vqa": 6.5694239139556885,
+        "pontuacao": 7.822401364644368,
+        "instrucao": 6.962437709172566,
+        "tts": 6.983241717020671,
+        "lm": 7.852646191914876,
+        "imagem_caption": 7.0820222695668535,
+        "ocr": 7.846352259318034,
+        "noticia": 7.663803895314534,
+        "asr": 7.646427710851033,
+        "ppl_lm": 2572.532733229914
+      },
+      "eq_som": 0.3229912519454956,
+      "punicoes": 1,
+      "prs": {
+        "trust": 0.3768,
+        "tau": 6.82558,
+        "clip": 5.0,
+        "boost": 1.0,
+        "streak": 0,
+        "ciclos_sgdr": 0,
+        "recompensa_acum": 9.712,
+        "beta_min_relativo": 2.0
+      },
+      "rpp": {
+        "rho": 1.0,
+        "streak": 0,
+        "recompensas": 2,
+        "punicoes": 1,
+        "penalidades": 90,
+        "kappa_rotas_mortas": 0.01
+      },
+      "roteador": {
+        "amostras": 45,
+        "pronto": false,
+        "lambda_rota": 0.35,
+        "gamma_empate": 0.15,
+        "drift_codebook": 0.009923,
+        "conf_media": 0.0,
+        "frac_rotas_ativas": 0.0,
+        "k": 24,
+        "taxa_ativos": 0.0417
+      },
+      "confianca": {
+        "h_ema": 0.398207426071167,
+        "ece": 0.13666666666666666,
+        "posterior": {
+          "media": 0.18478260869565216,
+          "bernstein": [
+            0.048734518728612175,
+            0.32083069866269215
+          ]
+        }
+      },
+      "memoria": {
+        "slots": 13,
+        "capacidade": 64,
+        "escritas": 13,
+        "rejeitadas_confianca": 10,
+        "hit_rate": 1.0,
+        "comprimidos": 0,
+        "entropia_codebook": 1.4736544073912228e-07,
+        "perda_vq": null,
+        "violacoes_contrato": 0,
+        "economia_bits_por_slot": 0.9990234375
+      },
+      "crescimento": []
+    }
+  ],
+  "passos": 3192,
+  "punicoes": 1,
+  "barreira_abmo_ativacoes": 0,
+  "pcgrad_ultimo": {
+    "pcgrad/dot": 0.0004723769121788418,
+    "pcgrad/projetado": 0.0,
+    "pcgrad/fator": 0.0
+  },
+  "prs_v8": {
+    "trust": 0.3768,
+    "tau": 6.82558,
+    "clip": 5.0,
+    "boost": 1.0,
+    "streak": 0,
+    "ciclos_sgdr": 0,
+    "recompensa_acum": 9.712,
+    "beta_min_relativo": 2.0
+  },
+  "confianca": {
+    "h_ema": 0.398207426071167,
+    "ece": 0.13666666666666666,
+    "posterior_media": 0.18478260869565216,
+    "bernstein": [
+      0.048734518728612175,
+      0.32083069866269215
+    ]
+  },
+  "memoria": {
+    "slots": 13,
+    "capacidade": 64,
+    "escritas": 13,
+    "rejeitadas_confianca": 10,
+    "hit_rate": 1.0,
+    "comprimidos": 0,
+    "entropia_codebook": 1.4736544073912228e-07,
+    "perda_vq": null,
+    "violacoes_contrato": 0,
+    "economia_bits_por_slot": 0.9990234375
+  },
+  "crescimento": [],
+  "microunidades": [
+    {
+      "ramos": [
+        "conv_dil",
+        "gru",
+        "mlp"
+      ],
+      "ativos": [
+        1.0,
+        1.0,
+        1.0
+      ],
+      "uso_ema": [
+        0.9752992987632751,
+        0.024680670350790024,
+        1.9912109564756975e-05
+      ],
+      "passos_rec": 2
+    },
+    {
+      "ramos": [
+        "conv_dil",
+        "gru",
+        "mlp",
+        "moe"
+      ],
+      "ativos": [
+        1.0,
+        1.0,
+        1.0,
+        1.0
+      ],
+      "uso_ema": [
+        0.12329785525798798,
+        0.4805801510810852,
+        0.07674114406108856,
+        0.31938061118125916
+      ],
+      "passos_rec": 2
+    },
+    {
+      "ramos": [
+        "conv_dil",
+        "gru",
+        "mlp",
+        "moe"
+      ],
+      "ativos": [
+        1.0,
+        1.0,
+        1.0,
+        1.0
+      ],
+      "uso_ema": [
+        0.9999496936798096,
+        2.324265779840573e-11,
+        4.997722862754017e-05,
+        2.525876396930471e-08
+      ],
+      "passos_rec": 2
+    }
+  ],
+  "dpo": {
+    "passos": 93,
+    "acc_final": 1.0,
+    "margem_final": 14.226043701171875,
+    "beta_final": 0.05858517438173294
+  },
+  "som": {
+    "variante_ativa": "cpn",
+    "variantes": {
+      "som": {
+        "k": 24,
+        "taxa_ativos": 1.0,
+        "resemeados": 24,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "gg": {
+        "k": 4,
+        "taxa_ativos": 1.0,
+        "resemeados": 4,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "gcs": {
+        "k": 3,
+        "arestas": 3,
+        "eq_treino": 4104.4892578125,
+        "atingiu_alvo": true
+      },
+      "gsom": {
+        "k": 15,
+        "gt": 1.05,
+        "erro_medio": 0.18949279189109802,
+        "atingiu_alvo": true
+      },
+      "hsom": {},
+      "tkm": {
+        "k": 32,
+        "taxa_ativos": 1.0,
+        "resemeados": 32,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "rsom": {
+        "k": 32,
+        "taxa_ativos": 1.0,
+        "resemeados": 32,
+        "usos": 256,
+        "atingiu_alvo": true
+      },
+      "cpn": {},
+      "ssom": {
+        "erro": "IndexError: index 8 is out of bounds for dimension 0 with size 8"
+      }
+    },
+    "roteador": {
+      "amostras": 1581,
+      "pronto": true,
+      "lambda_rota": 0.35,
+      "gamma_empate": 0.15,
+      "drift_codebook": 0.009923,
+      "conf_media": 0.4107,
+      "frac_rotas_ativas": 0.7188,
+      "k": 24,
+      "taxa_ativos": 1.0
+    },
+    "invariante_sem_orfaos": true,
+    "orfaos_por_variante": {
+      "som": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "gg": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "gcs": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "gsom": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "hsom": {
+        "orfaos": 0,
+        "relocados": 0
+      },
+      "tkm": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "rsom": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "cpn": {
+        "orfaos": 0,
+        "relocados": 0,
+        "taxa_ativos": 1.0
+      },
+      "ssom": {
+        "orfaos": 0,
+        "relocados": 23,
+        "taxa_ativos": 1.0
+      }
+    }
+  },
+  "avaliacao_final": {
+    "vqa": 6.4591522216796875,
+    "pontuacao": 7.7690675258636475,
+    "instrucao": 7.062118411064148,
+    "tts": 6.546424508094788,
+    "lm": 7.9568891525268555,
+    "imagem_caption": 7.035338521003723,
+    "ocr": 8.0436851978302,
+    "noticia": 7.5813761949539185,
+    "asr": 7.698689699172974,
+    "ppl_lm": 2855.177102389719
+  },
+  "metricas_completas": {
+    "neuronios_ativos": {
+      "ativos/som": 1.0,
+      "k/som": 24,
+      "ativos/gg": 1.0,
+      "k/gg": 4,
+      "ativos/gcs": 1.0,
+      "k/gcs": 3,
+      "ativos/gsom": 1.0,
+      "k/gsom": 15,
+      "ativos/hsom": 1.0,
+      "k/hsom": 12,
+      "ativos/tkm": 1.0,
+      "k/tkm": 32,
+      "ativos/rsom": 1.0,
+      "k/rsom": 32,
+      "ativos/cpn": 1.0,
+      "k/cpn": 24,
+      "ativos/ssom": 1.0,
+      "k/ssom": 24,
+      "A_global": 1.0
+    },
+    "estruturais": {
+      "ortogonalidade": 7.152557373046875e-07,
+      "balanceamento_moe": 0.0,
+      "gate_global": 0.3491619825363159,
+      "gate_janela": 0.3269121050834656,
+      "gate_linear": 0.3239259123802185,
+      "moe1/experts_ativos": 6.0,
+      "moe1/uso_max": 0.17838352918624878,
+      "moe1/perda_lb": 0.055772364139556885,
+      "moe1/perda_ort": 0.00034026303910650313,
+      "moe1/fase": 0.0,
+      "moe1/beta_feedback": 0.0,
+      "moe1/entropia_atn": 0.0,
+      "moe2/enc_uso_medio": 0.5,
+      "moe2/dec_uso_medio": 0.24999994039535522,
+      "moe2/dec_uso_min": 0.001363456016406417,
+      "moe2/agrupado": 0.0,
+      "moe2/perda_lb": 6.0,
+      "mtp/alpha0": 0.0005300508346408606,
+      "mtp/alpha1": 0.9994699358940125,
+      "mtp/termos_ce": 998.0,
+      "micra0/n_ramos": 3,
+      "micra0/ramos_ativos": 3,
+      "micra0/passos_rec": 2,
+      "micra0/alpha0": 1.0,
+      "micra0/alpha1": 1.3542193755267107e-10,
+      "micra0/alpha2": 1.4029073186149995e-15,
+      "micra0/uso0": 0.9752992987632751,
+      "micra0/uso1": 0.024680670350790024,
+      "micra0/uso2": 1.9912109564756975e-05,
+      "micra1/n_ramos": 4,
+      "micra1/ramos_ativos": 4,
+      "micra1/passos_rec": 2,
+      "micra1/alpha0": 0.07855360209941864,
+      "micra1/alpha1": 0.5188434720039368,
+      "micra1/alpha2": 0.07156255841255188,
+      "micra1/alpha3": 0.3310403823852539,
+      "micra1/uso0": 0.12329785525798798,
+      "micra1/uso1": 0.4805801510810852,
+      "micra1/uso2": 0.07674114406108856,
+      "micra1/uso3": 0.31938061118125916,
+      "micra2/n_ramos": 4,
+      "micra2/ramos_ativos": 4,
+      "micra2/passos_rec": 2,
+      "micra2/alpha0": 0.9999498128890991,
+      "micra2/alpha1": 2.1000236272161743e-11,
+      "micra2/alpha2": 5.0150272727478296e-05,
+      "micra2/alpha3": 2.1534841465609134e-08,
+      "micra2/uso0": 0.9999496936798096,
+      "micra2/uso1": 2.324265779840573e-11,
+      "micra2/uso2": 4.997722862754017e-05,
+      "micra2/uso3": 2.525876396930471e-08,
+      "nlp/gate_medio": 0.5649126768112183,
+      "nlp/intencao_id": 7,
+      "nlg/coerencia_bigramas_vistos": 0.0,
+      "nlg/estilo_medio": 0.5,
+      "nlg/estilo_disp": 0.0,
+      "janela1m/n_segmentos": 0,
+      "janela1m/m_max": 2017,
+      "janela1m/hit_celula": 0.0,
+      "janela1m/consultas": 0,
+      "mtp/rascunho_pronto": 1.0,
+      "roteador/amostras": 1581,
+      "roteador/pronto": 1.0,
+      "roteador/frac_rotas": 0.0,
+      "roteador/conf_media": 0.619,
+      "roteador/drift": 0.009923
+    },
+    "escala": {},
+    "regime": {
+      "fase_final": "B",
+      "alvo_ativos": 0.9
+    }
+  },
+  "rpp": {
+    "rho": 1.0,
+    "streak": 0,
+    "recompensas": 2,
+    "punicoes": 1,
+    "penalidades": 90,
+    "kappa_rotas_mortas": 0.01
+  },
+  "roteador_ssom": {
+    "amostras": 1581,
+    "pronto": true,
+    "lambda_rota": 0.35,
+    "gamma_empate": 0.15,
+    "drift_codebook": 0.009923,
+    "conf_media": 0.619,
+    "frac_rotas_ativas": 0.0,
+    "k": 24,
+    "taxa_ativos": 1.0
+  },
+  "inferencia_agente": {
+    "latencia_s": 0.481,
+    "tokens": 24,
+    "taxa_repeticao": 0.875,
+    "coerencia_bigramas": 0.0
+  },
+  "difusao": {
+    "modo": "planejado",
+    "op": "txt2img",
+    "latencia_s": 0.0,
+    "prompt_enriquecido": "a floresta amazonica de manha, com detalhes nítidos, com composição harmônica, com iluminação suave",
+    "gerou_pixels": false,
+    "estatisticas": {
+      "modo": "planejado",
+      "repo": "hf-internal-testing/tiny-stable-diffusion-torch",
+      "device": "cpu",
+      "pipelines": [],
+      "eventos": [
+        "pipeline txt2img: ImportError: \nStableDiffusionPipeline requires the transformers library but it was not found in your environment. You can install it with pip: `pip\ninstall transformers`\n"
+      ]
+    }
+  },
+  "agente_engenheiro": {
+    "aprovadas": 0,
+    "bloqueadas": 0,
+    "invariante_sem_orfaos": true
+  },
+  "checkpoints_eventos": [
+    "checkpoint epoca-007-p03102: 568 tensores, 0 pulados, 93 novos",
+    "1 checkpoint(s) antigo(s) apagado(s)",
+    "checkpoint epoca-007-p03150: local (62.0 MB)",
+    "1 checkpoint(s) antigo(s) apagado(s)",
+    "checkpoint epoca-007: local (62.0 MB)",
+    "1 checkpoint(s) antigo(s) apagado(s)",
+    "checkpoint fase-dpo: local (62.0 MB)",
+    "1 checkpoint(s) antigo(s) apagado(s)",
+    "checkpoint fase-som: local (62.0 MB)"
+  ],
+  "ram": {
+    "amostras": 5919,
+    "rss_min_mb": 428.7,
+    "rss_med_mb": 2524.4,
+    "rss_max_mb": 3358.4,
+    "disponivel_min_mb": 435.4,
+    "duracao_s": 14340.3
+  },
+  "tempo_nota": "wall time real do MonitorRAM sobre todos os segmentos; contagem pré-correção incluída"
+}

scripts/01_verificar_ambiente.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Verificação do ambiente KHTST v2: dependências, RAM/disco, token HF
+(PRESENÇA apenas — o valor NUNCA é impresso), módulos da v2 importáveis."""
+import os
+import sys
+
+sys.path.insert(0, "/home/z/my-project/khtst/src")
+
+
+def main():
+    print("== KHTST v2 — verificação de ambiente ==")
+    # dependências
+    faltando = []
+    for mod in ("torch", "datasets", "tokenizers", "huggingface_hub",
+                "safetensors", "soundfile", "numpy", "PIL", "requests",
+                "pyarrow"):
+        try:
+            m = __import__(mod)
+            versao = getattr(m, "__version__", "?")
+            print(f"  ✓ {mod} {versao}")
+        except ImportError:
+            faltando.append(mod)
+            print(f"  ✗ FALTA: {mod}")
+    if faltando:
+        print("Instale:", " ".join(faltando))
+        return 1
+    # recursos
+    import shutil
+    total, _, livre = shutil.disk_usage("/home/z/my-project")
+    print(f"  disco: {livre/2**30:.1f} GB livres de {total/2**30:.1f} GB")
+    with open("/proc/meminfo") as f:
+        memkb = int(next(f).split()[1])
+    print(f"  RAM:   {memkb/2**20:.1f} GB total")
+    # token (presença apenas)
+    tem_token = bool(os.environ.get("HF_TOKEN"))
+    print(f"  HF_TOKEN presente: {tem_token} (valor nunca é impresso)")
+    # módulos v2
+    from khtst.config import Config
+    from khtst.nucleo.modelo import KHTSTModel
+try:
+    from khtst.acelerado import status as status_acelerado
+except Exception:
+    status_acelerado = None
+    from khtst.percepcao.moe import MoEAgrupavel
+    from khtst.treino.mtp import MTPKHTST
+    from khtst.treino.dpo import PerdaDPO
+    from khtst.treino.cirurgia_grad import pcgrad_duas_perdas
+    from khtst.quanta.quantizacao import SmoothQuantAlpha
+    from khtst.dados.checkpoints import GestorCheckpoints
+    cfg = Config()
+    print("  ✓ módulos v2 importáveis (MoE, MTP, DPO, PCGrad, α-STE, Checkpoints)")
+    n_params_moe = 3 * cfg.modelo.moe["experts_por_grupo"] * \
+        2 * cfg.modelo.d_modelo * cfg.modelo.moe["d_ff_expert"]
+    print(f"  MoE: {cfg.modelo.moe['n_camadas_moe']} blocos × "
+          f"{cfg.modelo.moe['n_grupos']} grupos × "
+          f"{cfg.modelo.moe['experts_por_grupo']} experts "
+          f"(~{n_params_moe/1e6:.2f}M parâmetros de especialistas)")
+    print("OK")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/02_coletar_corpus.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Coleta do corpus v2 — UM DATASET POR VEZ, cada fonte em SUBPROCESSO isolado
+(estado limpo da biblioteca datasets; RAM devolvida ao SO; erro de uma fonte
+nunca contamina a seguinte). Streaming=True (+trust_remote_code onde aceito),
+18 fontes, dedup global, multimodal em base64. Cache temporário limpo após
+cada fonte."""
+import base64
+import json
+import os
+import subprocess
+import sys
+
+sys.path.insert(0, "/home/z/my-project/khtst/src")
+
+from khtst.dados.streaming import StreamingCorpus, limpar_cache_temp
+
+SAIDA = "/home/z/my-project/khtst/cache_dados/corpus_v2.jsonl"
+DIR_PARCIAL = "/home/z/my-project/khtst/cache_dados/parciais"
+RUNNER = "/home/z/my-project/khtst/scripts/02a_coletar_fonte.py"
+
+
+def _hash_texto(t: str) -> str:
+    import hashlib
+    return hashlib.sha1(t.encode("utf-8", "ignore")).hexdigest()[:16]
+
+
+def main():
+    os.makedirs(os.path.dirname(SAIDA), exist_ok=True)
+    os.makedirs("/home/z/my-project/khtst/telemetria_out", exist_ok=True)
+    os.makedirs(DIR_PARCIAL, exist_ok=True)
+    limpar_cache_temp()
+    plano_total = StreamingCorpus().PLANO
+    eventos = []
+    vistos: set[str] = set()
+    # v5 — RETOMÁVEL: corpus escrito INCREMENTALMENTE (append por fonte);
+    # na retomada, recarrega o acumulado e pula fontes já OK (estado persistido)
+    registros = []
+    if os.path.exists(SAIDA):
+        with open(SAIDA, encoding="utf-8") as f:
+            for linha in f:
+                try:
+                    reg = json.loads(linha)
+                except Exception:
+                    continue
+                chave = _hash_texto(reg.get("texto") or
+                                    ((reg.get("entrada") or "") + "␟" +
+                                     (reg.get("saida") or "")))
+                if chave not in vistos:
+                    vistos.add(chave)
+                    registros.append(reg)
+        print(f"retomada: {len(registros)} registros acumulados")
+    for i, plano in enumerate(plano_total):
+        fonte = plano["id"]
+        cam_estado_prev = os.path.join(DIR_PARCIAL, f"fonte_{i:02d}.estado.json")
+        if os.path.exists(cam_estado_prev):
+            ev_prev = json.load(open(cam_estado_prev, encoding="utf-8"))
+            if ev_prev.get("status") == "OK" and ev_prev.get("n", 0) > 0:
+                eventos.append(ev_prev)
+                print(f"  [SKIP] {fonte} (já coletada: n={ev_prev['n']})")
+                continue
+        if plano["via"] == "degradado":
+            # mensagem determinística gerada pelo próprio módulo de streaming
+            sub = StreamingCorpus()
+            list(sub._iterar_fonte(plano))          # registra evento degradado
+            eventos.extend([vars(ev) for ev in sub.eventos])
+            continue
+        cam_parcial = os.path.join(DIR_PARCIAL, f"fonte_{i:02d}.jsonl")
+        cam_estado = os.path.join(DIR_PARCIAL, f"fonte_{i:02d}.estado.json")
+        try:
+            r = subprocess.run(
+                [sys.executable, RUNNER, "--indice", str(i),
+                 "--saida", cam_parcial, "--estado", cam_estado],
+                capture_output=True, text=True, timeout=900,
+                env={**os.environ, "PYTHONPATH": "/home/z/my-project/khtst/src"})
+            r_erro = (r.stderr or "sem resposta")[-180:]
+        except subprocess.TimeoutExpired:
+            r_erro = "TIMEOUT 900s (fonte lenta — pulada)"
+        except Exception as e:                     # rede/Hub: nunca para o lote
+            r_erro = f"{type(e).__name__}: {e}"[-180:]
+        if os.path.exists(cam_estado):
+            ev = json.load(open(cam_estado, encoding="utf-8"))
+        else:
+            ev = {"fonte": fonte, "status": "ERRO", "detalhe": r_erro, "n": 0}
+        # v5 — dedup/append durável ÚNICO (abaixo); contagem de dedup por leitura
+        n_dedup = 0
+        if os.path.exists(cam_parcial):
+            with open(cam_parcial, encoding="utf-8") as f:
+                for linha in f:
+                    try:
+                        reg = json.loads(linha)
+                    except Exception:
+                        continue
+                    if reg.get("texto"):
+                        chave = _hash_texto(reg["texto"])
+                    else:
+                        chave = _hash_texto((reg.get("entrada") or "") + "␟" +
+                                             (reg.get("saida") or ""))
+                    if chave in vistos:
+                        n_dedup += 1
+        ev["dedup_descartados"] = n_dedup
+        eventos.append(ev)
+        print(f"  [{ev['status']}] {fonte} (n={ev['n']}, dedup={n_dedup})"
+              + (f" {ev['detalhe'][:80]}" if ev.get("detalhe") else ""))
+        # v5 — append DURÁVEL ao corpus (morte do processo não perde progresso)
+        novos = 0
+        if os.path.exists(cam_parcial) and ev.get("status") in ("OK", "PARCIAL"):
+            with open(cam_parcial, encoding="utf-8") as f, \
+                    open(SAIDA, "a", encoding="utf-8") as fa:
+                for linha in f:
+                    try:
+                        reg = json.loads(linha)
+                    except Exception:
+                        continue
+                    if plano["via"] in ("tts_marcos",):
+                        reg.setdefault("imagem", None)
+                        reg.setdefault("audio", None)
+                    if reg.get("texto"):
+                        chave = _hash_texto(reg["texto"])
+                    else:
+                        chave = _hash_texto((reg.get("entrada") or "") + "␟" +
+                                             (reg.get("saida") or ""))
+                    if chave in vistos:
+                        continue
+                    vistos.add(chave)
+                    if reg.get("imagem") is None:
+                        reg.pop("imagem", None)
+                    if reg.get("audio") is None:
+                        reg.pop("audio", None)
+                    registros.append(reg)
+                    fa.write(json.dumps(reg, ensure_ascii=False) + "\n")
+                    novos += 1
+        os.remove(cam_parcial) if os.path.exists(cam_parcial) else None
+        limpar_cache_temp()            # um dataset por vez → disco sob controle
+        import gc
+        gc.collect()
+    # escreve corpus final
+    n_multimodal = 0
+    with open(SAIDA, "w", encoding="utf-8") as f:
+        for r in registros:
+            if r.get("imagem") or r.get("audio"):
+                n_multimodal += 1
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+    cont = {}
+    for r in registros:
+        cont[r["tarefa"]] = cont.get(r["tarefa"], 0) + 1
+    print("== contagem por tarefa ==", cont)
+    print(f"total: {len(registros)} registros ({n_multimodal} multimodais) → {SAIDA}")
+    with open("/home/z/my-project/khtst/telemetria_out/eventos_coleta_v2.json",
+              "w", encoding="utf-8") as f:
+        json.dump(eventos, f, ensure_ascii=False, indent=2)
+    limpar_cache_temp()
+
+
+if __name__ == "__main__":
+    main()

scripts/02a_coletar_fonte.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Coleta UMA fonte (subprocesso isolado — estado limpo da biblioteca datasets,
+RAM devolvida ao SO ao terminar). Recebe o plano em JSON, escreve registros
+convertidos (multimodal em base64) num JSONL parcial."""
+import argparse
+import base64
+import json
+import sys
+
+sys.path.insert(0, "/home/z/my-project/khtst/src")
+
+from khtst.dados.streaming import StreamingCorpus, via_especial
+
+
+def _serializa(r: dict) -> dict:
+    out = {}
+    for k, v in r.items():
+        if v is None:
+            continue
+        if isinstance(v, bytes):
+            out[k] = base64.b64encode(v).decode("ascii")
+        else:
+            out[k] = v
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--indice", required=True, type=int,
+                    help="índice da fonte em StreamingCorpus.PLANO")
+    ap.add_argument("--saida", required=True)
+    ap.add_argument("--estado", required=True, help="JSON de evento (status/n)")
+    args = ap.parse_args()
+
+    corpus = StreamingCorpus()
+    plano = corpus.PLANO[args.indice]
+    registros = []
+    status, detalhe = "OK", plano.get("via", "")
+    try:
+        for ex in corpus._iterar_fonte(plano):
+            if len(registros) >= plano.get("max", 0):
+                break
+            reg = plano["ad"](ex) if plano.get("ad") else \
+                (ex if via_especial(plano["via"]) else None)
+            if reg is None:
+                continue
+            reg["fonte"] = plano["id"]
+            reg.setdefault("meta", {})
+            registros.append(reg)
+    except Exception as e:
+        status = "ERRO"
+        detalhe = f"{type(e).__name__}: {str(e)[:180]}"
+    if corpus.eventos:                      # erro/PULADO interno da fonte
+        ev = corpus.eventos[0]
+        status, detalhe = ev.status, ev.detalhe
+    with open(args.saida, "w", encoding="utf-8") as f:
+        for r in registros:
+            f.write(json.dumps(_serializa(r), ensure_ascii=False) + "\n")
+    with open(args.estado, "w", encoding="utf-8") as f:
+        json.dump({"fonte": plano["id"], "status": status,
+                   "detalhe": detalhe, "n": len(registros)}, f,
+                  ensure_ascii=False)
+    print(f"{status}: {plano['id']} n={len(registros)}")
+
+
+if __name__ == "__main__":
+    main()

scripts/03_treinar_tokenizador.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Treino do tokenizador BPE (Rust, paralelizável) sobre o corpus v2.
+Itera TODOS os campos textuais (texto/entrada/saida) — streaming do arquivo,
+RAM O(1)."""
+import json
+import os
+import sys
+
+sys.path.insert(0, "/home/z/my-project/khtst/src")
+
+from khtst.config import Config
+from khtst.dados.tokenizador import TokenizadorKHTST
+
+CORPUS = "/home/z/my-project/khtst/cache_dados/corpus_v2.jsonl"
+SAIDA = "/home/z/my-project/khtst/cache_dados/tokenizador.json"
+
+
+def iterar_textos(caminho):
+    with open(caminho, encoding="utf-8") as f:
+        for linha in f:
+            try:
+                r = json.loads(linha)
+            except Exception:
+                continue
+            for campo in ("texto", "entrada", "saida"):
+                t = r.get(campo)
+                if isinstance(t, str) and len(t.strip()) >= 10:
+                    yield t.strip()
+
+
+def main():
+    cfg = Config()
+    vocab = cfg.modelo.vocab
+    tk = TokenizadorKHTST()
+    stats = tk.treinar(iterar_textos(CORPUS), vocab=vocab, salvar_em=SAIDA)
+    # teste de ida-e-volta (ByteLevel insere espaço inicial — comparar sem ele)
+    amostras = list(iterar_textos(CORPUS))[:5]
+    for s in amostras:
+        ids = tk.encode(s, tarefa="lm", max_len=256)
+        dec = tk.decode(ids).strip()
+        assert dec[:40] == s.strip()[:40] or len(s) < 40, "roundtrip falhou"
+    print(f"tokenizador: {stats['vocab_size']} tokens (pedido {vocab}) "
+          f"→ {SAIDA}; roundtrip OK em {len(amostras)} amostras")
+
+
+if __name__ == "__main__":
+    main()

scripts/04_treinar.py

@@ -0,0 +1,381 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Treino v4 — pipeline completo em DUAS FASES (doc 15):
+
+  FASE A — rede aumentada (épocas 0..N-1, sem SOM):
+           FASE Densa (épocas 0..2): máx conexões, MoE softmax-total, MTP com
+           K ADAPTATIVO, PCGrad, ABMO, PRS V8, AgenteConfiança, MEMÓRIA INTERNA,
+           GESTOR DE CRESCIMENTO + AUTO-ESCALA POR COMPUTO (doc 12); unidades
+           NLP/NLG acopladas (nascem neutras — Teorema 15.1);
+           FASE Foco (época 3): MoE top-k + máscara + QAT-W8A8 final
+           (escalas POR GRUPO + correção de viés — doc 08 §§5-6);
+           FASE DPO: pares (dourado, corrompido) com β adaptativo.
+  FASE B — consolidação SOM com MÁXIMO de neurônios ativos (eq. 15.1):
+           8 variantes SEM neurônios isolados (reseeding garantido),
+           lr do tronco ×0.1, alvo A ≥ 0.90 (Teorema 15.2).
+
+Uso (CPU em segmentos):
+  python3 04_treinar.py --orcamento 1500        # segmento de 25 min
+  python3 04_treinar.py --orcamento 1500        # retoma do último estado do HF
+  ... quando 'pipeline completo' termina, roda DPO+SOM automaticamente.
+"""
+import argparse
+import base64
+import json
+import os
+import sys
+import threading
+import time
+
+sys.path.insert(0, "/home/z/my-project/khtst/src")
+
+import torch
+
+from khtst.config import Config
+from khtst.dados.checkpoints import GestorCheckpoints
+from khtst.geracao import GeradorMultimodal
+from khtst.qualidade import AgenteEngenheiro
+from khtst.dados.tokenizador import TokenizadorKHTST
+from khtst.memoria.orquestrador import OrquestradorSOM
+from khtst.nucleo.modelo import KHTSTModel
+from khtst.telemetria.hub import TelemetryHub
+from khtst.treino.treinador import TreinadorExtensao
+
+CORPUS = "/home/z/my-project/khtst/cache_dados/corpus_v2.jsonl"
+TOKENIZADOR = "/home/z/my-project/khtst/cache_dados/tokenizador.json"
+RESUMO = "/home/z/my-project/khtst/telemetria_out/resumo_treino_v8.json"
+RAM_JSONL = "/home/z/my-project/khtst/telemetria_out/ram_treino_v8.jsonl"
+
+
+class MonitorRAM:
+    """v7 — observação do CONSUMO DE MEMÓRIA RAM durante o treino inteiro
+    (pedido explícito do Agente Engenheiro). Amostra VmRSS do processo e
+    MemAvailable do sistema a cada `intervalo_s` em thread daemon; grava JSONL
+    (t, passo, rss_mb, disponivel_mb) e resume pico/média/mínimo no fim."""
+
+    def __init__(self, caminho: str, passo_ref, intervalo_s: float = 2.0):
+        self.caminho = caminho
+        self.passo_ref = passo_ref
+        self.intervalo_s = intervalo_s
+        self._parar = threading.Event()
+        self._thread = threading.Thread(target=self._laco, daemon=True)
+        self.amostras: list[dict] = []
+
+    @staticmethod
+    def _rss_mb() -> float:
+        try:
+            with open("/proc/self/status", encoding="utf-8") as f:
+                for linha in f:
+                    if linha.startswith("VmRSS:"):
+                        return float(linha.split()[1]) / 1024.0
+        except Exception:
+            pass
+        return 0.0
+
+    @staticmethod
+    def _disponivel_mb() -> float:
+        try:
+            with open("/proc/meminfo", encoding="utf-8") as f:
+                for linha in f:
+                    if linha.startswith("MemAvailable:"):
+                        return float(linha.split()[1]) / 1024.0
+        except Exception:
+            pass
+        return 0.0
+
+    def _laco(self):
+        # modo "a": segmentos separados do pipeline acumulam no MESMO jsonl
+        with open(self.caminho, "a", encoding="utf-8") as f:
+            while not self._parar.is_set():
+                amostra = {"t": round(time.time(), 2),
+                           "rss_mb": round(self._rss_mb(), 1),
+                           "disponivel_mb": round(self._disponivel_mb(), 1),
+                           "passo": self.passo_ref()}
+                f.write(json.dumps(amostra) + "\n")
+                f.flush()
+                self._parar.wait(self.intervalo_s)
+
+    def iniciar(self):
+        self._thread.start()
+
+    def parar(self) -> dict:
+        """Encerra a thread e resume o jsonl INTEIRO (todos os segmentos)."""
+        self._parar.set()
+        self._thread.join(timeout=5)
+        amostras: list[dict] = []
+        try:
+            with open(self.caminho, encoding="utf-8") as f:
+                for linha in f:
+                    try:
+                        amostras.append(json.loads(linha))
+                    except Exception:
+                        continue
+        except FileNotFoundError:
+            return {"amostras": 0}
+        rss = [a["rss_mb"] for a in amostras]
+        disp = [a["disponivel_mb"] for a in amostras]
+        if not rss:
+            return {"amostras": 0}
+        return {"amostras": len(rss),
+                "rss_min_mb": round(min(rss), 1),
+                "rss_med_mb": round(sum(rss) / len(rss), 1),
+                "rss_max_mb": round(max(rss), 1),
+                "disponivel_min_mb": round(min(disp), 1),
+                "duracao_s": round(amostras[-1]["t"] - amostras[0]["t"], 1)}
+
+
+def carregar_registros(caminho: str) -> list[dict]:
+    registros = []
+    with open(caminho, encoding="utf-8") as f:
+        for linha in f:
+            try:
+                r = json.loads(linha)
+            except Exception:
+                continue
+            # multimodal volta a bytes
+            if isinstance(r.get("imagem"), str):
+                try:
+                    r["imagem"] = base64.b64decode(r["imagem"])
+                except Exception:
+                    r["imagem"] = None
+            if isinstance(r.get("audio"), str):
+                try:
+                    r["audio"] = base64.b64decode(r["audio"])
+                except Exception:
+                    r["audio"] = None
+            registros.append(r)
+    return registros
+
+
+
+TEMPO_ACUM = "/home/z/my-project/khtst/telemetria_out/tempo_treino_acumulado.json"
+
+
+def tempo_acumulado_h() -> float:
+    import json as _json
+    try:
+        with open(TEMPO_ACUM) as f:
+            return float(_json.load(f).get("segundos", 0.0)) / 3600.0
+    except Exception:
+        return 0.0
+
+
+def registrar_tempo(segundos: float):
+    import json as _json
+    total = tempo_acumulado_h() * 3600.0 + max(0.0, segundos)
+    os.makedirs(os.path.dirname(TEMPO_ACUM), exist_ok=True)
+    with open(TEMPO_ACUM, "w") as f:
+        _json.dump({"segundos": total, "horas": total / 3600.0}, f)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--orcamento", type=float, default=None,
+                    help="segundos por segmento (CPU: retomada automática)")
+    ap.add_argument("--max_passos_epoca", type=int, default=None)
+    ap.add_argument("--sem_dpo", action="store_true")
+    ap.add_argument("--sem_som", action="store_true")
+    ap.add_argument("--sem_epocas", action="store_true",
+                    help="v7: pula o laço de épocas (retomada já completa) e vai "
+                         "direto a DPO→SOM→avaliação→resumo")
+    ap.add_argument("--sem_difusao", action="store_true",
+                    help="v7: pula o ciclo geracional de difusão (economiza RAM/tempo "
+                         "do segmento final; evidência já validada em v5/v6)")
+    ap.add_argument("--teto_horas", type=float, default=5.0,
+                    help="v8: TETO RÍGIDO de tempo ACUMULADO de treino (h). "
+                         "Ao atingir, o treino para (requisito: parar se "
+                         "ultrapassar 5 horas).")
+    ap.add_argument("--semente", type=int, default=None,
+                    help="v7: semente torch p/ REPRODUTIBILIDADE da inicialização "
+                         "(diagnóstico v7: init não semeada + lr 0.003 pode divergir; "
+                         "padrão = cfg.dados.semente)")
+    args = ap.parse_args()
+
+    # v8 — TETO RÍGIDO (requisito): parar se o treino acumulado passar de 5h
+    acum = tempo_acumulado_h()
+    if acum >= args.teto_horas:
+        print(f"[TETO] treino acumulado {acum:.2f} h ≥ teto {args.teto_horas:.1f} h — "
+              "PARANDO as tarefas de treino (requisito atendido).")
+        return
+    print(f"teto de treino: {acum:.2f}/{args.teto_horas:.1f} h acumuladas")
+
+    cfg = Config().de_arquivo("/home/z/my-project/khtst/configs/base.json")
+    # v7 — reprodutibilidade: init de pesos, dropout e amostragens torch
+    torch.manual_seed(args.semente if args.semente is not None
+                      else cfg.dados.semente)
+    os.makedirs("/home/z/my-project/khtst/telemetria_out", exist_ok=True)
+    hub = TelemetryHub(cfg.telemetria.arquivo_jsonl)
+    # v7 — Agente Engenheiro: observação do consumo de RAM durante TODO o treino
+    ram = MonitorRAM(RAM_JSONL, passo_ref=lambda: 0)
+    ram.iniciar()
+    print("monitor RAM: amostrando", RAM_JSONL)
+    tk = TokenizadorKHTST(TOKENIZADOR)
+    registros = carregar_registros(CORPUS)
+    print(f"corpus: {len(registros)} registros")
+    cont = {}
+    for r in registros:
+        cont[r["tarefa"]] = cont.get(r["tarefa"], 0) + 1
+    print("tarefas:", cont)
+
+    modelo = KHTSTModel(cfg, usar_multimodal=True)
+    print(f"modelo: {sum(p.numel() for p in modelo.parameters())/1e6:.2f}M parâmetros")
+
+    checkpoints = GestorCheckpoints(dir_local=cfg.checkpoints.dir_local)
+    orquestrador = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som, hub=hub,
+                    cfg_atencao=vars(cfg.som_atencao) if hasattr(cfg, "som_atencao") else None)
+    treinar = TreinadorExtensao(cfg, modelo, tk, hub, registros,
+                                orquestrador_som=orquestrador, checkpoints=checkpoints)
+    # v5 — Agente Engenheiro: observação integral durante o treino (doc 16 §9)
+    agente = AgenteEngenheiro(
+        tolerancia_regressao=cfg.agente_engenheiro.tolerancia_regressao, hub=hub)
+    treinar.agente_engenheiro = agente
+    treinar.intervalo_agente = cfg.agente_engenheiro.intervalo
+    # passo global do treino visível ao monitor de RAM
+    ram.passo_ref = lambda: treinar.passo_global
+    # v5 — gerador multimodal (difusão) para o ciclo geracional (doc 17)
+    difusao = GeradorMultimodal(repo_id=cfg.difusao.repo_id,
+                                altura=cfg.difusao.altura, largura=cfg.difusao.largura,
+                                passos_inferencia=cfg.difusao.passos_inferencia,
+                                guia_escala=cfg.difusao.guia_escala, hub=hub) \
+        if cfg.difusao.ativo and not args.sem_difusao else None
+
+    # item c: "salvar (e usar) estados" — retoma do checkpoint local mais avançado
+    tag_retomada = treinar.retomar_ultimo_checkpoint()
+    print(f"retomada do Hub: tag={tag_retomada} "
+          f"(passo {treinar.passo_global}, época {treinar.epoca})")
+
+    # ---------- fases 1+2: denso → foco (segmentos com retomada) ----------
+    if not args.sem_epocas:
+        while True:
+            resultado = treinar.treinar("/home/z/my-project/khtst/checkpoints",
+                                        max_passos_por_epoca=args.max_passos_epoca,
+                                        orcamento_s=args.orcamento)
+            print(f"segmento: {resultado['duracao_s']}s | passos={treinar.passo_global} "
+                  f"| épocas={len(treinar.historico_epocas)} | interrompido={resultado['interrompido']}")
+            registrar_tempo(resultado.get("duracao_s", 0.0))
+            print(f"→ tempo acumulado de treino: {tempo_acumulado_h():.2f} h "
+                  f"(teto {args.teto_horas:.1f} h)")
+            if not resultado["interrompido"]:
+                break
+            print("→ estado salvo no Hub; rode o script novamente para o próximo segmento")
+            if args.orcamento is not None:
+                return                 # sai: próximo segmento em nova invocação
+            return                     # sem orçamento: uma passada só por chamada
+
+    # ---------- fase 3: DPO ----------
+    resultado_dpo = {"pulado": True}
+    if not args.sem_dpo:
+        print("== fase DPO ==")
+        resultado_dpo = treinar.treinar_dpo()
+        print("DPO:", resultado_dpo)
+        treinar.salvar_checkpoint("fase-dpo", {"dpo": resultado_dpo})
+
+    # ---------- fase 4: SOM com máximo de neurônios ativos ----------
+    resultado_som = {"pulado": True}
+    if not args.sem_som:
+        print("== fase SOM (máx neurônios ativos) ==")
+        resultado_som = treinar.consolidar_som_max_ativos()
+        for nome, st in resultado_som.get("variantes", {}).items():
+            print(f"  {nome}: {st}")
+        treinar.salvar_checkpoint("fase-som", {"som": {
+            k: v for k, v in resultado_som.items() if k != "prototipos"}})
+
+    aval_final = treinar.avaliar(max_lotes=4)
+    print("avaliação final:", aval_final)
+
+    # v5 — evidência de INFERÊNCIA para o Agente Engenheiro (métricas de geração)
+    try:
+        ids_prompt = tk.encode("Pergunta: o que e o Kohonen? Resposta:",
+                               tarefa="instrucao", max_len=24)
+        t0 = time.time()
+        tokens = modelo.gerar(torch.tensor([ids_prompt]), max_novos=24)
+        evid_inf = agente.observar_inferencia(modelo, torch.tensor([ids_prompt]),
+                                              tokens, time.time() - t0)
+        print("inferência (agente):", evid_inf)
+        print("texto gerado:", tk.decode(tokens))
+    except Exception as e:
+        evid_inf = {"erro": str(e)}
+
+    # v5 — ciclo de compreensão geracional (difusão; modo honesto)
+    evid_difusao = None
+    if difusao is not None:
+        try:
+            r = difusao.compreensao_geracional(
+                "a floresta amazonica de manha", modelo,
+                orquestrador=orquestrador, op="txt2img")
+            evid_difusao = {"modo": r.get("modo"), "op": r.get("op"),
+                            "latencia_s": r.get("latencia_s"),
+                            "prompt_enriquecido": r.get("prompt_enriquecido"),
+                            "gerou_pixels": r.get("modo") == "real",
+                            "estatisticas": difusao.estatisticas()}
+            print("difusão (modo honesto):", evid_difusao["modo"],
+                  "—", evid_difusao["prompt_enriquecido"])
+        except Exception as e:
+            evid_difusao = {"erro": str(e)}
+
+    # v4 — MÉTRICAS COMPLETAS (doc 15 §3): neurônios ativos por variante,
+    # NLP/NLG, janela 1M, computo, crescimento
+    metricas_completas = {
+        "neuronios_ativos": (orquestrador.telemetria_ativos()
+                             if orquestrador is not None else {}),
+        "estruturais": modelo.metricas_estruturais(),
+        "escala": modelo.info_escalacao,
+        "regime": {"fase_final": treinar.regime.fase,
+                   "alvo_ativos": treinar.regime.alvo_ativos},
+    }
+    print("== métricas completas (doc 15 §3) ==")
+    print(json.dumps(metricas_completas, ensure_ascii=False, indent=1,
+                     default=str)[:2200])
+
+    rel_agente = agente.relatorio(orquestrador_som=orquestrador,
+                                  avaliacao=aval_final)
+    os.makedirs(os.path.dirname(RESUMO), exist_ok=True)
+    ram_resumo = ram.parar()   # resume TODOS os segmentos (jsonl completo)
+    with open(RESUMO, "w", encoding="utf-8") as f:
+        registrar_tempo(ram_resumo["duracao_s"] if isinstance(ram_resumo, dict) else 0.0)
+        json.dump({"versao": "v8-khtst-melhorias-a-j",
+                   "teto_horas": args.teto_horas,
+                   "tempo_acumulado_h": tempo_acumulado_h(),
+                   "memoria_v8": treinar.gestor_memoria.estatisticas(),
+                   "autoajuste_v8": getattr(treinar, "ultimo_autoajuste", None),
+                   "epocas": treinar.historico_epocas,
+                   "passos": treinar.passo_global,
+                   "punicoes": len(treinar.eventos_punicao),
+                   "barreira_abmo_ativacoes": treinar.barreira_ativa_count,
+                   "pcgrad_ultimo": treinar.ultimos_pcgrad,
+                   "prs_v8": treinar.prs.estado(),
+                   "confianca": {"h_ema": treinar.agente.ultimo_h,
+                                 "ece": treinar.agente.ece(),
+                                 "posterior_media": treinar.agente.posterior.media,
+                                 "bernstein": treinar.agente.posterior.bernstein()},
+                   "memoria": (treinar.memoria.estatisticas()
+                               if treinar.memoria is not None else None),
+                   "crescimento": (treinar.gestor.eventos
+                                   if treinar.gestor is not None else []),
+                   "microunidades": [
+                       {"ramos": c.nome_ramos,
+                        "ativos": [float(a) for a in c.ramo_ativo.tolist()],
+                        "uso_ema": (c.uso_ema.tolist()
+                                    if c.uso_ema is not None else None),
+                        "passos_rec": c.ultimo_passos_rec}
+                       for c in modelo.compositores],
+                   "dpo": resultado_dpo, "som": resultado_som,
+                   "avaliacao_final": aval_final,
+                   "metricas_completas": metricas_completas,
+                   "rpp": (treinar.rpp.estado() if treinar.rpp else None),
+                   "roteador_ssom": (treinar.roteador.estatisticas()
+                                     if treinar.roteador is not None else None),
+                   "inferencia_agente": evid_inf,
+                   "difusao": evid_difusao,
+                   "agente_engenheiro": {"aprovadas": rel_agente["revisoes_aprovadas"],
+                                          "bloqueadas": rel_agente["revisoes_bloqueadas"],
+                                          "invariante_sem_orfaos": rel_agente.get("som_invariante_sem_orfaos")},
+                   "checkpoints_eventos": checkpoints.eventos[-12:],
+                   "ram": ram_resumo},
+                  f, ensure_ascii=False, indent=2, default=str)
+    print(f"resumo → {RESUMO}")
+    print("ram:", json.dumps(ram_resumo))
+
+
+if __name__ == "__main__":
+    main()

scripts/05_avaliar.py

@@ -0,0 +1,654 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Avaliação v3 — relatório de QUALIDADE DO APRENDIZADO com evidências:
+
+ 1. perplexidade LM: modelo inicial (aleatório) vs treinado vs por época;
+ 2. perdas por tarefa (9 tarefas) treinado vs aleatório;
+ 3. MoE agrupável (roteamento POR TOKEN causal): top experts POR TAREFA;
+ 4. MTP adaptativo: perdas por cabeça, α e ECONOMIA de termos de CE;
+ 5. W8A8: delta de perda com/sem quantização na lm_head;
+ 6. SOM: taxa de neurônios ativos, EQ, TE por variante;
+ 7. geração: amostras com/sem punição dinâmica de repetição;
+ 8. MICROUNIDADES: ramos ativos, gating α por tarefa, refino recursivo;
+ 9. CONFIANÇA: posterior Beta, cota de Bernstein, ECE de calibração;
+10. MEMÓRIA INTERNA: hit-rate, escritas conficientes, compressão VQ;
+11. CRESCIMENTO: eventos de expansão/poda das microunidades.
+Salva telemetria_out/avaliacao_v5.json (v5: + Agente Engenheiro e difusão)."""
+import base64
+import json
+import math
+import os
+import random
+import sys
+import time
+
+sys.path.insert(0, "/home/z/my-project/khtst/src")
+
+import torch
+
+from khtst.config import Config
+from khtst.dados.checkpoints import GestorCheckpoints
+from khtst.geracao import GeradorMultimodal
+from khtst.qualidade import AgenteEngenheiro
+from khtst.dados.tokenizador import TokenizadorKHTST
+from khtst.memoria.orquestrador import OrquestradorSOM
+from khtst.nucleo.modelo import KHTSTModel
+from khtst.telemetria.hub import TelemetryHub
+from khtst.treino.treinador import (TAREFAS_AUDIO, TAREFAS_IMAGEM,
+                                     _audio_para_tensor, _imagem_para_tensor,
+                                     TreinadorExtensao)
+
+CORPUS = "/home/z/my-project/khtst/cache_dados/corpus_v2.jsonl"
+TOKENIZADOR = "/home/z/my-project/khtst/cache_dados/tokenizador.json"
+RELATORIO = "/home/z/my-project/khtst/telemetria_out/avaliacao_v8.json"
+
+
+def carregar_registros(caminho):
+    regs = []
+    with open(caminho, encoding="utf-8") as f:
+        for linha in f:
+            try:
+                r = json.loads(linha)
+            except Exception:
+                continue
+            if isinstance(r.get("imagem"), str):
+                r["imagem"] = base64.b64decode(r["imagem"])
+            if isinstance(r.get("audio"), str):
+                r["audio"] = base64.b64decode(r["audio"])
+            regs.append(r)
+    return regs
+
+
+@torch.no_grad()
+def perda_lote(modelo, tk, registros, tarefa, n_lotes=6, lote=8):
+    """Perda CE média da tarefa (multimodais usam o prefixo real treinável-não)."""
+    pool = [r for r in registros if r["tarefa"] == tarefa]
+    if not pool:
+        return None
+    perdas = []
+    for _ in range(n_lotes):
+        amostras = random.sample(pool, min(lote, len(pool)))
+        L = modelo.cfg.modelo.comprimento_ctx
+        seqs, extras = [], []
+        for s in amostras:
+            inp = tk.encode(s.get("entrada") or "", tarefa=tarefa, max_len=L // 2) \
+                if tarefa not in ("lm", "noticia") else [1]
+            saida_fonte = s.get("saida") or s.get("texto") or ""
+            out = tk.encode(saida_fonte, tarefa=None,
+                            max_len=max(L - len(inp) - 4, 8), com_bos=False)
+            if len(out) < 4:
+                continue
+            seqs.append(inp + out)
+            extras.append(s)
+        if not seqs:
+            continue
+        Tmax = max(len(s) for s in seqs)
+        ids = torch.zeros(len(seqs), Tmax, dtype=torch.long)
+        alvo = torch.full((len(seqs), Tmax), -100, dtype=torch.long)
+        emb_prefixo = None
+        for i, (s, seq) in enumerate(zip(extras, seqs)):
+            ids[i, :len(seq)] = torch.tensor(seq)
+            if tarefa not in ("lm", "noticia"):
+                ninp = len(tk.encode(s.get("entrada") or "", tarefa=tarefa,
+                                     max_len=L // 2))
+                alvo[i, ninp:len(seq)] = ids[i, ninp:len(seq)]
+            else:
+                alvo[i, 1:len(seq)] = ids[i, 1:len(seq)]
+        if modelo.usar_multimodal:
+            entradas = {}
+            if tarefa in TAREFAS_IMAGEM:
+                lado = modelo.cfg.modelo.imagem["resolucao"]
+                entradas["imagem"] = torch.stack([
+                    _imagem_para_tensor(s["imagem"], lado) if s.get("imagem")
+                    else torch.zeros(3, lado, lado) for s in extras])
+            if tarefa in TAREFAS_AUDIO:
+                ondas = [_audio_para_tensor(s["audio"]) for s in extras if s.get("audio")]
+                if ondas:
+                    Nmax = max(o.shape[0] for o in ondas)
+                    pad = torch.zeros(len(ondas), Nmax)
+                    for i, o in enumerate(ondas):
+                        pad[i, :o.shape[0]] = o
+                    entradas["audio"] = pad
+            if entradas:
+                emb_prefixo = modelo.codificar_multimodal(entradas)
+        _, perda = modelo(ids, alvo=alvo, emb_prefixo=emb_prefixo, tarefa=tarefa)
+        perdas.append(float(perda))
+    return sum(perdas) / len(perdas) if perdas else None
+
+
+@torch.no_grad()
+def perdas_som_amostra(modelo, tk, registros, orquestrador, n=64):
+    seqs = []
+    for r in registros[:n]:
+        seqs.append(tk.encode(r.get("texto") or (r.get("saida") or r.get("entrada", "")),
+                              tarefa=r["tarefa"], max_len=64)[:64])
+    Tmax = max(len(s) for s in seqs)
+    ids = torch.zeros(len(seqs), Tmax, dtype=torch.long)
+    for i, s in enumerate(seqs):
+        ids[i, :len(s)] = torch.tensor(s)
+    ctx = modelo.contexto(ids)
+    out = {}
+    for nome, v in orquestrador.variantes.items():
+        if hasattr(v, "taxa_ativos"):
+            out[nome] = {"taxa_ativos": v.taxa_ativos(),
+                         "eq": v.eq(ctx) if hasattr(v, "eq") else None}
+    return out
+
+
+def _salvar(rel: dict):
+    """Salvamento incremental — evidência parcial sobrevive a cortes de tempo."""
+    os.makedirs(os.path.dirname(RELATORIO), exist_ok=True)
+    with open(RELATORIO, "w", encoding="utf-8") as f:
+        json.dump(rel, f, ensure_ascii=False, indent=2, default=str)
+
+
+def main():
+    cfg = Config().de_arquivo("/home/z/my-project/khtst/configs/base.json")
+    random.seed(cfg.dados.semente)
+    torch.manual_seed(cfg.dados.semente)
+    hub = TelemetryHub(cfg.telemetria.arquivo_jsonl)
+    tk = TokenizadorKHTST(TOKENIZADOR)
+    registros = carregar_registros(CORPUS)
+
+    modelo = KHTSTModel(cfg, usar_multimodal=True)
+    checkpoints = GestorCheckpoints(dir_local=cfg.checkpoints.dir_local)
+    tag = checkpoints.ultima_tag()
+    if tag:
+        checkpoints.carregar(modelo, tag)
+    print(f"estado carregado: {tag or 'NENHUM (avaliando aleatório!)'}")
+    orquestrador = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som, hub=hub,
+                    cfg_atencao=vars(cfg.som_atencao) if hasattr(cfg, "som_atencao") else None)
+
+    # v5 — os SOMs são tensors puros (fora do state_dict): re-consolidação
+    # determinística a partir do modelo treinado (mesmo protocolo do 07 /
+    # Teorema 16.5) — as evidências de memória refletem o estado TREINADO.
+    print("== re-consolidação SOM (protocolo doc 16 §4/§5) ==")
+    relatorio = {"estado": tag}
+    amostras = random.sample(registros, min(4 * 64, len(registros)))
+    ctxs = []
+    for i in range(0, len(amostras), 64):
+        pedaco = amostras[i:i + 64]
+        seqs = [tk.encode(r.get("texto") or (r.get("saida") or r.get("entrada", "")),
+                          tarefa=r["tarefa"], max_len=64)[:64] for r in pedaco]
+        Tmax = max(len(x) for x in seqs)
+        ids_l = torch.zeros(len(seqs), Tmax, dtype=torch.long)
+        for j, x in enumerate(seqs):
+            ids_l[j, :len(x)] = torch.tensor(x)
+        ctxs.append(modelo.contexto(ids_l).detach())
+    ctx = torch.cat(ctxs, dim=0)
+    dominante = "instrucao" if any(r["tarefa"] == "instrucao" for r in amostras) else "lm"
+    orquestrador.escolher({"rotulo_tarefa": dominante, "denso": True})
+    orquestrador.treinar_memoria(ctx, epocas=2)
+    if getattr(orquestrador, "atencao", None) is not None:
+        inv = orquestrador.atencao.verificar_sem_orfas(orquestrador, dados=ctx,
+                                                       resemear=True)
+        print("  invariante zero-órfãos:", inv.pop("_invariante_ok", None))
+    # v6 — consolidação do ROTEADOR S-SOM com os MESMOS (ctx, tarefa) —
+    # contagens empíricas Laplace-suavizadas (doc 18 §1.1, Teorema 18.3)
+    if getattr(modelo, "roteador_ssom", None) is not None:
+        from khtst.percepcao.roteador_ssom import LISTA_TAREFAS as _LT
+        _rot = torch.tensor(
+            [_LT.index(r["tarefa"]) if r["tarefa"] in _LT else 0 for r in amostras],
+            dtype=torch.long)
+        eq_rot = modelo.roteador_ssom.consolidar(ctx, _rot, passos=6)
+        st_rot = modelo.roteador_ssom.estatisticas()
+        relatorio["roteador_ssom"] = st_rot
+        print(f"  roteador S-SOM consolidado: eq={eq_rot:.4f} "
+              f"conf_media={st_rot['conf_media']} frac_rotas={st_rot['frac_rotas_ativas']} "
+              f"taxa_ativos={st_rot['taxa_ativos']}")
+    print("  ativos:", json.dumps(orquestrador.telemetria_ativos())[:200])
+
+    # 1-2) perdas treinado vs aleatório
+    modelo.eval()
+    modelo_aleatorio = KHTSTModel(cfg, usar_multimodal=True)
+    modelo_aleatorio.eval()
+    print("== perdas por tarefa (treinado vs aleatório) ==")
+    perdas_tarefa = {}
+    for tarefa in ("lm", "noticia", "instrucao", "pontuacao", "imagem_caption",
+                   "vqa", "ocr", "asr", "tts"):
+        p_t = perda_lote(modelo, tk, registros, tarefa)
+        p_a = perda_lote(modelo_aleatorio, tk, registros, tarefa)
+        perdas_tarefa[tarefa] = {"treinado": p_t, "aleatorio": p_a}
+        print(f"  {tarefa:16s} treinado={p_t if p_t is None else round(p_t,3)} "
+              f"aleatório={p_a if p_a is None else round(p_a,3)}")
+    relatorio["perdas_tarefa"] = perdas_tarefa
+    _salvar(relatorio)
+    if perdas_tarefa["lm"]["treinado"]:
+        relatorio["ppl_lm"] = math.exp(min(perdas_tarefa["lm"]["treinado"], 12))
+        relatorio["ppl_lm_aleatorio"] = math.exp(min(perdas_tarefa["lm"]["aleatorio"], 12))
+        print(f"  ppl treinado={relatorio['ppl_lm']:.1f} "
+              f"aleatório={relatorio['ppl_lm_aleatorio']:.1f}")
+
+    # 3) MoE foco na tarefa: uso de experts por tarefa
+    print("== MoE fase foco: top-2 por tarefa (foco na tarefa) ==")
+    modelo.definir_fase_moe("foco")
+    moe_uso = {}
+    for tarefa in ("lm", "vqa", "ocr", "asr", "tts"):
+        perda_lote(modelo, tk, registros, tarefa, n_lotes=2)
+        moes = [b.moe for b in modelo.blocos if b.moe is not None]
+        # v8 — a MoE enc-dec (item g) não tem grupo_de_idx: reporta os
+        # DECODERS top-2 (4 experts de saída)
+        uso_tarefa = []
+        for m in moes:
+            if getattr(m, "_tipo_enc_dec", False):
+                topo = m.ultimo_p.topk(min(2, m.n_dec)).indices.tolist()
+                uso_tarefa.append({"experts_top": [int(i) for i in topo],
+                                   "grupo_top": ["dec" for _ in topo],
+                                   "agrupado": bool(m.agrupado)})
+            else:
+                uso_tarefa.append(
+                    {"experts_top": [int(i) for i in m.ultimo_p.topk(2).indices.tolist()],
+                     "grupo_top": [int(m.grupo_de_idx[i]) for i in m.ultimo_p.topk(2).indices]})
+        moe_uso[tarefa] = uso_tarefa
+    for tarefa, uso in moe_uso.items():
+        grupos = uso[0]["grupo_top"] if uso else []
+        print(f"  {tarefa:16s} grupos top: {grupos}")
+    relatorio["moe_uso_por_tarefa"] = moe_uso
+    _salvar(relatorio)
+
+    # 4) MTP (uma passada LM para popular os α e perdas por cabeça)
+    if modelo.mtp is not None:
+        ids_m, alvo_m = _lote_lm(tk, registros)
+        _, _ = modelo(ids_m, alvo=alvo_m, tarefa="lm")
+        modelo.mtp_do_trunk(ids_m, alvo_m, tarefa="lm")
+        relatorio["mtp"] = modelo.mtp.ultimos
+        print("== MTP ==" , relatorio["mtp"])
+
+    # 5) W8A8 delta
+    ids, alvo = _lote_lm(tk, registros)
+    _, p_fp = modelo(ids, alvo=alvo, tarefa="lm")
+    modelo.qat = True
+    _, p_q = modelo(ids, alvo=alvo, tarefa="lm")
+    modelo.qat = False
+    relatorio["w8a8_delta"] = float(p_q - p_fp)
+    print(f"== W8A8: Δperda = {relatorio['w8a8_delta']:+.5f} ==")
+
+    # 6) SOM — métricas TREINADAS vêm do resumo do treino (o orquestrador
+    # não é nn.Module: seu estado é consolidado na fase SOM e gravado lá)
+    resumo_path = "/home/z/my-project/khtst/telemetria_out/resumo_treino_v8.json"
+    if os.path.exists(resumo_path):
+        som_treinado = json.load(open(resumo_path)).get("som", {})
+        relatorio["som_treinado"] = som_treinado
+        print("== SOM (fase de consolidação — taxa de neurônios ativos) ==")
+        for nome, st in som_treinado.get("variantes", {}).items():
+            if isinstance(st, dict) and "taxa_ativos" in st:
+                print(f"  {nome}: taxa_ativos={st['taxa_ativos']:.2f} "
+                      f"alvo={st.get('atingiu_alvo')}")
+    # EQ fresco no espaço atual (referência)
+    relatorio["som_eq_fresco"] = perdas_som_amostra(modelo, tk, registros, orquestrador)
+    _salvar(relatorio)
+
+    # 7) geração com/sem punição
+    prompt = tk.encode("Recomende um filme brasileiro:", tarefa="instrucao", max_len=24)
+    ids_p = torch.tensor([prompt])
+    sem_pun = modelo.gerar(ids_p, max_novos=30, punicao_repeticao=1.0, top_k=0, top_p=0.9)
+    com_pun = modelo.gerar(ids_p, max_novos=30, punicao_repeticao=1.4, top_k=0, top_p=0.9)
+    relatorio["geracao"] = {
+        "sem_punicao": tk.decode(sem_pun),
+        "com_punicao": tk.decode(com_pun)}
+    print("== geração (amostra) ==")
+    print("  sem punição:", relatorio["geracao"]["sem_punicao"][:120])
+    print("  com punição:", relatorio["geracao"]["com_punicao"][:120])
+
+    # 8) MICROUNIDADES (doc 11): ramos, gating α por tarefa, recursão
+    print("== microunidades (composição serial/paralela/recursiva) ==")
+    micra = {}
+    for tarefa in ("lm", "vqa", "asr", "instrucao"):
+        perda_lote(modelo, tk, registros, tarefa, n_lotes=1)
+        micra[tarefa] = [
+            {"ramos": c.nome_ramos,
+             "alpha_medio": [round(a, 4) for a in c.ultimo_alpha.tolist()]
+             if c.ultimo_alpha is not None else None,
+             "passos_rec": c.ultimo_passos_rec}
+            for c in modelo.compositores]
+    for t, ms in micra.items():
+        if ms and ms[0]["alpha_medio"]:
+            print(f"  {t:10s} α bloco0 = {ms[0]['alpha_medio']} rec = {ms[0]['passos_rec']}")
+    relatorio["microunidades"] = micra
+
+    # 9-11) CONFIANÇA / MEMÓRIA / CRESCIMENTO — estado consolidado no resumo
+    resumo_v3 = json.load(open(resumo_path)) if os.path.exists(resumo_path) else {}
+    if resumo_v3:
+        for chave in ("prs_v8", "confianca", "memoria", "crescimento", "microunidades"):
+            if chave in resumo_v3 and chave not in relatorio:
+                relatorio[f"treino_{chave}"] = resumo_v3[chave]
+        if resumo_v3.get("confianca"):
+            c = resumo_v3["confianca"]
+            print(f"== confiança: h_ema={c.get('h_ema')}, ECE={c.get('ece')}, "
+                  f"Bernstein={c.get('bernstein')} ==")
+        if resumo_v3.get("memoria"):
+            m = resumo_v3["memoria"]
+            print(f"== memória: hit_rate={m.get('hit_rate')}, escritas={m.get('escritas')}, "
+                  f"rejeitadas={m.get('rejeitadas_confianca')}, "
+                  f"entropia_codebook={m.get('entropia_codebook')} ==")
+        if resumo_v3.get("crescimento") is not None:
+            print(f"== crescimento: {len(resumo_v3['crescimento'])} eventos ==")
+
+    # 12) MEMÓRIA INTERNA EM EXECUÇÃO (doc 11 §9): evidência de integração
+    # real — escrita conficiente dos contextos do corpus, consulta, evicção,
+    # compressão VQ e contratos, com o modelo JÁ TREINADO
+    print("== memória interna em execução (contextos reais do modelo) ==")
+    from khtst.memoria.interna import MemoriaInterna
+    from khtst.treino.confianca import AgenteConfianca
+    mi = MemoriaInterna(d=modelo.d, n_slots=32, h_escrita=0.25,
+                        idade_compressao_s=0.0, n_codigos=64)
+    ag = AgenteConfianca()
+    amostras_mem = random.sample(registros, min(64, len(registros)))
+    h_escreveras = 0
+    for r in amostras_mem[:48]:
+        seq = tk.encode(r.get("texto") or (r.get("saida") or r.get("entrada", "")),
+                        tarefa=r["tarefa"], max_len=64)[:64]
+        if len(seq) < 4:
+            continue
+        ids_m = torch.zeros(1, len(seq), dtype=torch.long)
+        ids_m[0] = torch.tensor(seq)
+        logits_m, _ = modelo(ids_m, tarefa=r["tarefa"])
+        perda_m = modelo.ultima_perda or 6.0
+        h_m = float(ag(AgenteConfianca.features_logits(logits_m),
+                       perda_atual=float(perda_m)))
+        z_m = modelo.contexto(ids_m)[0]
+        if mi.escrever(z_m, h_m, origem="nucleo", tarefa=r["tarefa"]):
+            h_escreveras += 1
+    consultas_ok = 0
+    for r in amostras_mem[48:]:
+        seq = tk.encode(r.get("texto") or (r.get("saida") or r.get("entrada", "")),
+                        tarefa=r["tarefa"], max_len=64)[:64]
+        if len(seq) < 4:
+            continue
+        ids_m = torch.zeros(1, len(seq), dtype=torch.long)
+        ids_m[0] = torch.tensor(seq)
+        z_m = modelo.contexto(ids_m)[0]
+        rec_m = mi.consultar(z_m, m=3, origem="raciocinio")
+        consultas_ok += int(rec_m["acerto"])
+    n_comp_m = mi.comprimir_antigos(origem="treino")
+    stats_m = mi.estatisticas()
+    stats_m["escritas_aceitas"] = h_escreveras
+    stats_m["consultas_com_acerto"] = consultas_ok
+    stats_m["comprimidos_agora"] = n_comp_m
+    relatorio["memoria_execucao"] = stats_m
+    _salvar(relatorio)
+    print(f"  escritas aceitas={h_escreveras}/48 · consultas com acerto="
+          f"{consultas_ok}/16 · comprimidos={n_comp_m} · "
+          f"entropia_codebook={stats_m['entropia_codebook']:.3f} · "
+          f"economia_bits/slot={stats_m['economia_bits_por_slot']:.4f} · "
+          f"violações_contrato={stats_m['violacoes_contrato']}")
+
+    # curva de épocas (telemetria)
+    resumo_path = "/home/z/my-project/khtst/telemetria_out/resumo_treino_v8.json"
+    if os.path.exists(resumo_path):
+        relatorio["curva_epocas"] = [
+            {"epoca": e["epoca"], "perda_media": e["perda_media"],
+             "ppl_lm": e["avaliacao"].get("ppl_lm")}
+            for e in json.load(open(resumo_path)).get("epocas", [])]
+
+    # v4 (doc 15 §3.5): COERÊNCIA À MEDIDA QUE OS DADOS CRESCEM
+    print("== coerência (repetição/ancoragem/entropia) por fator de corpus ==")
+    try:
+        coer = metricas_coerencia(modelo, tk, registros)
+        relatorio["coerencia"] = coer
+        for chave in ("corpus_25pct", "corpus_50pct", "corpus_100pct"):
+            if chave in coer:
+                c = coer[chave]
+                print(f"  {chave}: n={c['n_registros']} "
+                      f"repetição={c['repeticao_pct']}% "
+                      f"ancoragem={c['ancoragem_bigramas']} "
+                      f"entropia={c['entropia_logits']}")
+        for s in coer.get("amostras", []):
+            print(f"  amostra: {s[:100]}")
+    except Exception as e:
+        relatorio["coerencia_erro"] = f"{type(e).__name__}: {e}"
+        print(f"  (coerência falhou: {type(e).__name__})")
+
+    # v6 (doc 18 §3): PACOTE COMPLETO DE MÉTRICAS — alinhamento cross-modal,
+    # geração de texto, benchmarks e SOM expandido (QE/TE/distorção/σ/α/drift/
+    # freq de ativação/U-Matrix)
+    print("== v6: ALINHAMENTO CROSS-MODAL (CLIP Score + ITM + PPL Multimodal) ==")
+    try:
+        from khtst.metricas import (avaliar_clip, avaliar_itm, avaliar_todos,
+                                     codigos_visuais, metricas_variante,
+                                     pacote_completo, ppl_multimodal_texto,
+                                     ppl_visual_bigrama, treinar_itm)
+        from PIL import Image
+        import io as _io
+        pares_mm = []
+        for r in registros:
+            if r["tarefa"] in ("imagem_caption", "vqa") and r.get("imagem"):
+                try:
+                    img = Image.open(_io.BytesIO(r["imagem"])).convert("RGB")
+                    lado = modelo.cfg.modelo.imagem["resolucao"]
+                    import numpy as _np
+                    arr = _np.asarray(img.resize((lado, lado)),
+                                      dtype=_np.float32) / 255.0
+                    tens = torch.from_numpy(arr).permute(2, 0, 1)
+                    pares_mm.append((r.get("entrada") or "Descreva a imagem:", tens))
+                except Exception:
+                    continue
+            if len(pares_mm) >= 32:
+                break
+        if pares_mm:
+            relatorio["clip_score"] = avaliar_clip(modelo, tk, pares_mm,
+                                                   n_controle=16)
+            print("  CLIP Score:", relatorio["clip_score"])
+            cab, _ = treinar_itm(modelo, tk, pares_mm[:24], epocas=3, lote=8)
+            relatorio["itm"] = avaliar_itm(cab, modelo, tk, pares_mm[24:])
+            print("  ITM:", relatorio["itm"])
+            # corrente visual: códigos VQ por imagem → PPL bigrama
+            codigos = [codigos_visuais(modelo, p[1]) for p in pares_mm[:24]]
+            relatorio["ppl_visual"] = ppl_visual_bigrama(
+                codigos, n_codigos=max(2, max(max(c) for c in codigos) + 1
+                                       if codigos and codigos[0] else 2))
+            print("  PPL visual (bigrama códigos VQ):", relatorio["ppl_visual"])
+        relatorio["ppl_multimodal"] = ppl_multimodal_texto(modelo, tk, registros)
+        print("  PPL Multimodal (texto sob prefixo visual/áudio):",
+              relatorio["ppl_multimodal"])
+    except Exception as e:
+        relatorio["alinhamento_erro"] = f"{type(e).__name__}: {e}"
+        print("  (alinhamento falhou:", relatorio["alinhamento_erro"], ")")
+
+    print("== v6: GERAÇÃO DE TEXTO (CIDEr + BLEU 1-4 + ROUGE-L + METEOR) ==")
+    try:
+        from collections import Counter as _Counter
+        from khtst.metricas import pacote_completo
+        from khtst.metricas.geracao_texto import tokenizar as gen_tokenizar
+        pool_cap = [r for r in registros if r["tarefa"] in ("imagem_caption", "vqa")
+                    and (r.get("saida") or "").strip()][:12]
+        if pool_cap:
+            df_corpus = _Counter()
+            for r in pool_cap:
+                toks = gen_tokenizar(r["saida"])
+                for n in range(1, 5):
+                    for i in range(len(toks) - n + 1):
+                        df_corpus[tuple(toks[i:i + n])] += 1
+            medias = {}
+            por_item = []
+            for r in pool_cap:
+                prompt = (r.get("entrada") or "Descreva a imagem:")[:140]
+                ids_p = torch.tensor([tk.encode(prompt, tarefa=r["tarefa"],
+                                                max_len=48)])
+                novos = modelo.gerar(ids_p, max_novos=20, temperatura=0.7,
+                                     top_p=0.9)
+                hip = tk.decodificar(novos)
+                m = pacote_completo(hip, [r["saida"]], df_corpus=df_corpus,
+                                    n_docs=len(pool_cap))
+                por_item.append({"hipotese": hip[:80], "ref": r["saida"][:60],
+                                 "bleu": m["bleu"], "rouge_l": m["rouge_l"],
+                                 "meteor": m["meteor"], "cider": m["cider"]})
+            for chave in ("bleu", "rouge_l", "meteor", "cider"):
+                vals = [p[chave] for p in por_item]
+                medias[chave] = round(sum(vals) / len(vals), 4)
+            relatorio["geracao_metricas"] = {"medias": medias,
+                                             "n": len(por_item),
+                                             "amostras": por_item[:4]}
+            print("  médias:", medias)
+    except Exception as e:
+        relatorio["geracao_metricas_erro"] = f"{type(e).__name__}: {e}"
+        print("  (geração-métricas falhou:", relatorio["geracao_metricas_erro"], ")")
+
+    print("== v6: BENCHMARKS (MMMU / MME / MathVista — proxies PT-BR) ==")
+    try:
+        from khtst.metricas import avaliar_todos
+        relatorio["benchmarks"] = avaliar_todos(modelo, tk, registros, n_max=30)
+        for k, v in relatorio["benchmarks"].items():
+            print(f"  {v.get('benchmark')}: n={v.get('n')} "
+                  f"score={v.get('acuracia', v.get('score_mme'))}")
+    except Exception as e:
+        relatorio["benchmarks_erro"] = f"{type(e).__name__}: {e}"
+        print("  (benchmarks falhou:", relatorio["benchmarks_erro"], ")")
+
+    print("== v6: SOM EXPANDIDO (QE/TE/distorção/σ/α/drift/freq/U-Matrix) ==")
+    try:
+        from khtst.metricas import metricas_variante
+        som_exp = {}
+        probe_x = ctx                     # contexto da re-consolidação (doc 16 §4)
+        for nome, v in orquestrador.variantes.items():
+            som_exp[nome] = metricas_variante(nome, v, probe_x)
+        relatorio["som_expandido"] = som_exp
+        for nome, mv in som_exp.items():
+            if "qe" in mv:
+                print(f"  {nome}: QE={mv['qe']} TE={mv['te']} "
+                      f"distorcao={mv['distorcao']} "
+                      f"drift={mv.get('codebook_drift')} "
+                      f"u={mv.get('u_matrix_resumo', {}).get('u_media')}")
+    except Exception as e:
+        relatorio["som_expandido_erro"] = f"{type(e).__name__}: {e}"
+        print("  (som expandido falhou:", relatorio["som_expandido_erro"], ")")
+
+    # v5 — Agente Engenheiro: observação de INFERÊNCIA + relatório final
+    print("== Agente Engenheiro (inferência + relatório integral) ==")
+    try:
+        ag = AgenteEngenheiro(
+            tolerancia_regressao=cfg.agente_engenheiro.tolerancia_regressao,
+            hub=hub)
+        for tarefa, ids_ex in (("instrucao", None),):
+            pass
+        _ids = torch.tensor([tk.encode("Pergunta: quem escreveu isso? Resposta:",
+                                       tarefa="instrucao", max_len=24)])
+        t0 = time.time()
+        _novos = modelo.gerar(_ids, max_novos=24)
+        relatorio["inferencia_agente"] = ag.observar_inferencia(
+            modelo, _ids, _novos, time.time() - t0)
+        print("  ", relatorio["inferencia_agente"])
+        # v5 — ciclo de compreensão geracional (difusão, modo honesto)
+        if cfg.difusao.ativo:
+            gd = GeradorMultimodal(repo_id=cfg.difusao.repo_id,
+                                   altura=cfg.difusao.altura,
+                                   largura=cfg.difusao.largura,
+                                   passos_inferencia=cfg.difusao.passos_inferencia,
+                                   guia_escala=cfg.difusao.guia_escala, hub=hub)
+            r = gd.compreensao_geracional("o pantanal ao entardecer", modelo,
+                                          orquestrador=orquestrador, op="txt2img")
+            relatorio["difusao"] = {"modo": r.get("modo"),
+                                    "prompt_enriquecido": r.get("prompt_enriquecido"),
+                                    "latencia_s": r.get("latencia_s"),
+                                    "gerou_pixels": r.get("modo") == "real"}
+            print("  difusão:", relatorio["difusao"]["modo"], "—",
+                  relatorio["difusao"]["prompt_enriquecido"])
+        rel_ag = ag.relatorio(orquestrador_som=orquestrador,
+                              avaliacao={"ppl_lm": relatorio.get("ppl_lm")})
+        relatorio["agente_engenheiro"] = {
+            "revisoes_aprovadas": rel_ag["revisoes_aprovadas"],
+            "revisoes_bloqueadas": rel_ag["revisoes_bloqueadas"],
+            "som_invariante_sem_orfaos": rel_ag.get("som_invariante_sem_orfaos"),
+            "som_ativos": rel_ag.get("som_ativos")}
+    except Exception as e:
+        relatorio["agente_erro"] = f"{type(e).__name__}: {e}"
+
+    os.makedirs(os.path.dirname(RELATORIO), exist_ok=True)
+    with open(RELATORIO, "w", encoding="utf-8") as f:
+        json.dump(relatorio, f, ensure_ascii=False, indent=2, default=str)
+    print(f"relatório → {RELATORIO}")
+
+
+def _lote_lm(tk, registros, lote=8, L=192):
+    pool = [r for r in registros if r["tarefa"] == "lm"] or registros
+    seqs = []
+    for r in random.sample(pool, min(lote, len(pool))):
+        t = (r.get("texto") or r.get("saida") or r.get("entrada") or "")[:800]
+        seqs.append(tk.encode(t, tarefa="lm", max_len=L))
+    Tmax = max(len(s) for s in seqs)
+    ids = torch.zeros(len(seqs), Tmax, dtype=torch.long)
+    alvo = torch.full((len(seqs), Tmax), -100, dtype=torch.long)
+    for i, s in enumerate(seqs):
+        ids[i, :len(s)] = torch.tensor(s)
+        alvo[i, 1:len(s)] = ids[i, 1:len(s)]
+    return ids, alvo
+
+
+# ---------------- v4 (doc 15 §3.5): COERÊNCIA das respostas ----------------
+
+def metricas_coerencia(modelo, tk, registros, rotulos_prompts=None):
+    """Coerência medida em três dimensões (doc 15 §3.5):
+    (i) REPETIÇÃO: n-gramas repetidos por 100 tokens gerados;
+    (ii) ANCORAGEM no corpus: fração de bigramas gerados que existem nos
+        bigramas do corpus (proxy de coerência de língua);
+    (iii) ENTROPIA média dos logits (confiança da política).
+    Avaliada em FATORES de tamanho de corpus — coerência exibida À MEDIDA
+    QUE OS DADOS CRESCEM (requisito do usuário)."""
+    prompts = rotulos_prompts or [
+        "O Brasil é um país",
+        "Para fazer um bolo simples você precisa",
+        "A previsão do tempo para amanhã",
+        "O melhor jeito de estudar é",
+    ]
+    # bigramas de referência do corpus (hash de pares de ids)
+    corpus_bg: set[int] = set()
+    pool = [r for r in registros if r.get("texto") or r.get("saida")] or registros
+    for r in random.sample(pool, min(60, len(pool))):
+        t = (r.get("texto") or r.get("saida") or r.get("entrada") or "")[:600]
+        ids = tk.encode(t, tarefa="lm", max_len=96)
+        for a, b in zip(ids, ids[1:]):
+            corpus_bg.add(a * 1000003 + b)
+    resultados = {}
+    gerados_todos: list[list[int]] = []
+    for fator in (0.25, 0.5, 1.0):           # subcorpus crescente
+        n = max(1, int(len(pool) * fator))
+        sub = pool[:n]
+        # bigramas de referência do subcorpus (menor → menos âncoras)
+        bg_sub: set[int] = set()
+        for r in random.sample(sub, min(40, len(sub))):
+            t = (r.get("texto") or r.get("saida") or r.get("entrada") or "")[:600]
+            ids = tk.encode(t, tarefa="lm", max_len=96)
+            for a, b in zip(ids, ids[1:]):
+                bg_sub.add(a * 1000003 + b)
+        repeticoes, ancoragens, entropias = [], [], []
+        for p in prompts:
+            ids_p = tk.encode(p, tarefa="lm", max_len=24)
+            t_ids = torch.tensor([ids_p])
+            novos = modelo.gerar(t_ids, max_novos=36, temperatura=0.85,
+                                 top_p=0.92)
+            gerados_todos.append(novos)
+            if not novos:
+                continue
+            # (i) repetição: fração de 3-gramas duplicados
+            trigs = [tuple(novos[i:i + 3]) for i in range(len(novos) - 2)]
+            rep = 1.0 - (len(set(trigs)) / len(trigs)) if trigs else 0.0
+            repeticoes.append(rep * 100.0)
+            # (ii) ancoragem: bigramas gerados presentes no subcorpus
+            bigs = [novos[i] * 1000003 + novos[i + 1]
+                    for i in range(len(novos) - 1)]
+            anc = (sum(1 for g in bigs if g in bg_sub) / len(bigs)) if bigs else 0.0
+            ancoragens.append(anc)
+            # (iii) entropia média dos logits (confiança)
+            modelo.eval()
+            with torch.no_grad():
+                x = modelo.emb(t_ids)
+                for bloco in modelo.blocos:
+                    x, _, _ = bloco(x)
+                h = modelo.norm_f(x)
+                if modelo.nlp is not None:
+                    h, _ = modelo.nlp(h)
+                lg = torch.log_softmax(modelo.lm_head(h[:, -1]), dim=-1)
+                entropias.append(float(-(lg.exp() * lg).sum()))
+        resultados[f"corpus_{int(fator*100)}pct"] = {
+            "n_registros": n,
+            "repeticao_pct": round(sum(repeticoes) / max(1, len(repeticoes)), 2),
+            "ancoragem_bigramas": round(sum(ancoragens) / max(1, len(ancoragens)), 4),
+            "entropia_logits": round(sum(entropias) / max(1, len(entropias)), 4),
+        }
+    # amostras para o relatório (legibilidade humana)
+    resultados["amostras"] = [tk.decodificar(g)[:140] for g in gerados_todos[:4]]
+    return resultados
+
+
+if __name__ == "__main__":
+    main()

scripts/06_publicar_hf.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Publica o KHTST v7 no HuggingFace de modo ORGANIZADO e COMPLETO:
+
+  README.md (model card v7 COM GRÁFICOS DE DESEMPENHO) · LICENSE · configs/ ·
+  src/khtst/ · scripts/ · docs/matematica/ (provas 00–18) · tests/ · evidências
+  de treino/avaliação/comparação · estados/fase-v8/ (pesos finais + meta SHA-256)
+
+REGRAS DO HUB (escopo v5): publicação em UM ÚNICO COMMIT COMPLETO —
+`upload_folder` com `delete_patterns=["*"]` substitui ATOMICAMENTE todo o
+conteúdo do repo (arquivos antigos somem no MESMO commit; nunca há uploads
+parciais em sequência curta — o Hub bloqueia esse padrão).
+
+SEGURANÇA: token EXCLUSIVAMENTE da variável HF_TOKEN — nunca gravado em
+arquivo, log ou repo. A publicação NUNCA inclui: cache_dados, telemetria_out,
+estados_local, stage_publicar, arquivos com o token.
+
+Verificações de porta do Agente Engenheiro (pré-publicação):
+  • nenhum segredo no stage (regex hf_[A-Za-z0-9]{30,});
+  • nenhum resíduo proibido (bugwatch, estados_hf, __pycache__, .pt).
+
+Uso:  HF_TOKEN=... python3 06_publicar_hf.py [--repo PowerMachine/khtst-multimodal-ptbr]
+"""
+import argparse
+import os
+import re
+import shutil
+import sys
+
+RAIZ = "/home/z/my-project/khtst"
+STAGE = "/home/z/my-project/khtst/stage_publicar"
+PASTA_ESTADO = "estados/fase-v8"   # ÚNICO estado publicado (pesos finais)
+IGNORAR_DIRS = {"__pycache__", "cache_dados", "telemetria_out",
+                "cache_hub_tmp", ".git", "build", "estados_local",
+                "estados_local_teste", "stage_publicar", "hf_stage",
+                "download", "upload"}
+IGNORAR_EXT = (".pt", ".pyc", ".pt.tmp")
+PADRAO_TOKEN = re.compile(r"hf_[A-Za-z0-9]{30,}")
+RESIDUOS_PROIBIDOS = ("bugwatch", "estados_hf")
+
+
+def preparar_stage() -> int:
+    if os.path.exists(STAGE):
+        shutil.rmtree(STAGE)
+    n = 0
+    for raiz, dirs, arquivos in os.walk(RAIZ):
+        dirs[:] = [d for d in dirs if d not in IGNORAR_DIRS]
+        rel = os.path.relpath(raiz, RAIZ)
+        alvo_raiz = os.path.join(STAGE, rel) if rel != "." else STAGE
+        os.makedirs(alvo_raiz, exist_ok=True)
+        for a in arquivos:
+            if a.endswith(IGNORAR_EXT) or a.startswith("."):
+                continue
+            if any(r in a.lower() for r in RESIDUOS_PROIBIDOS):
+                print(f"  porta do Agente: arquivo proibido ignorado: {a}")
+                continue
+            shutil.copy2(os.path.join(raiz, a), os.path.join(alvo_raiz, a))
+            n += 1
+    # evidências de treino/avaliação (artefatos de 1ª classe, v7)
+    for nome in ("avaliacao_v8.json", "resumo_treino_v8.json",
+                 "relatorio_agente_engenheiro.json",
+                 "comparacao_treino_v8.json", "test_khtst_v6_pos_treino.txt",
+                 "teste_item_b_v8.json", "test_khtst_v7_pos_treino.txt",
+                 "tempo_treino_acumulado.json"):
+        fonte = os.path.join(RAIZ, "telemetria_out", nome)
+        if os.path.exists(fonte):
+            shutil.copy2(fonte, os.path.join(STAGE, nome))
+            n += 1
+    # v7 — GRÁFICOS DE DESEMPENHO (publicados APENAS no card HF — README.md)
+    dir_graf = os.path.join(RAIZ, "graficos")
+    if os.path.isdir(dir_graf):
+        os.makedirs(os.path.join(STAGE, "graficos"), exist_ok=True)
+        for a in sorted(os.listdir(dir_graf)):
+            if a.endswith(".png"):
+                shutil.copy2(os.path.join(dir_graf, a),
+                             os.path.join(STAGE, "graficos", a))
+                n += 1
+    # v8.3 — GATE DE QUALIDADE (regra do usuário): os ESTADOS do modelo só
+    # entram se a não-regressão vs AURORA for aprovada; gate False ⇒ publica
+    # APENAS código/docs/evidências (sem pesos, sem alegação de paridade).
+    import json as _json
+    gate_ok = None
+    cmp_path = os.path.join(RAIZ, "telemetria_out", "comparacao_treino_v8.json")
+    try:
+        gate_ok = bool(_json.load(open(cmp_path))["nao_regressao"]["aprovado"])
+    except Exception:
+        gate_ok = None
+    if gate_ok is False:
+        print("GATE DE QUALIDADE: FALHOU — estados do modelo NÃO publicados "
+              "(regra: só publicar estados se qualidade ≥ AURORA).")
+        return n
+    sys.path.insert(0, os.path.join(RAIZ, "src"))
+    from khtst.dados.checkpoints import GestorCheckpoints
+    from khtst.config import Config
+    gestor = GestorCheckpoints(dir_local=Config().checkpoints.dir_local,
+                               pasta_publicacao=PASTA_ESTADO)
+    if gestor.preparar_para_publicacao(STAGE):
+        n += 2
+        print(f"estado final incluído: {PASTA_ESTADO}/modelo.safetensors")
+    else:
+        print("AVISO: sem checkpoint local — publicando só código/docs")
+    return n
+
+
+def auditoria_segredos() -> list[str]:
+    suspeitos = []
+    for raiz, dirs, arquivos in os.walk(STAGE):
+        for a in arquivos:
+            if not a.endswith((".json", ".md", ".py", ".txt", ".yaml", ".yml")):
+                continue
+            caminho = os.path.join(raiz, a)
+            try:
+                with open(caminho, encoding="utf-8", errors="ignore") as f:
+                    if PADRAO_TOKEN.search(f.read()):
+                        suspeitos.append(caminho)
+            except Exception:
+                pass
+    return suspeitos
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--repo", default="PowerMachine/khtst-multimodal-ptbr")
+    args = ap.parse_args()
+
+    token = os.environ.get("HF_TOKEN")
+    if not token:
+        print("ERRO: defina HF_TOKEN no ambiente (nunca em arquivo).")
+        sys.exit(1)
+
+    n = preparar_stage()
+    print(f"stage: {n} arquivos (sem caches/segredos/resíduos)")
+
+    suspeitos = auditoria_segredos()
+    if suspeitos:
+        print("ERRO: possíveis segredos detectados:", suspeitos)
+        sys.exit(1)
+
+    from huggingface_hub import HfApi
+    api = HfApi(token=token)
+    api.create_repo(args.repo, repo_type="model", exist_ok=True, private=False)
+
+    # PUBLICAÇÃO ÚNICA E COMPLETA: delete_patterns=["*"] remove no MESMO commit
+    # qualquer arquivo antigo — nada de uploads parciais em sequência
+    api.upload_folder(
+        folder_path=STAGE, repo_id=args.repo, repo_type="model",
+        commit_message="KHTST v7 — RETREINO OBSERVADO: estados antigos apagados; "
+                       "treino do zero com monitor de RAM integral (Agente Engenheiro); "
+                       "métricas de tests/test_khtst_v6.py comparadas com o treino "
+                       "anterior; gráficos de desempenho publicados no card",
+        delete_patterns=["*"],
+        allow_patterns=["*.py", "*.md", "*.json", "*.yaml", "*.yml",
+                        "*.txt", "*.png", "*.safetensors", "LICENSE*"])
+    print("✓ PUBLICAÇÃO ÚNICA COMPLETA (1 commit; antigos removidos "
+          "atomicamente)")
+
+    # verificação final: resíduos proibidos não podem existir no repo
+    arquivos = api.list_repo_files(args.repo, repo_type="model")
+    restos = [f for f in arquivos
+              if any(r in f.lower() for r in RESIDUOS_PROIBIDOS)
+              or "__pycache__" in f or f.endswith(".pt")]
+    if restos:
+        print("ERRO: resíduos no repo:", restos)
+        sys.exit(1)
+    parciais = [f for f in arquivos if f.startswith("estados/")
+                and "fase-v7" not in f]
+    print(f"✓ verificação: {len(arquivos)} arquivos no repo; "
+          f"resíduos=0; estados parciais={len(parciais)} (0 esperado)")
+
+    print(f"REPO: https://huggingface.co/{args.repo}")
+    print("Higienização: unset HF_TOKEN && python3 -m pip show huggingface_hub "
+          ">/dev/null && python3 -c 'from huggingface_hub import HfApi; "
+          "HfApi().logout()'")
+
+
+if __name__ == "__main__":
+    main()

scripts/07_reconsolidar_som.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Reconsolidação SOM (FASE B) sobre o estado final do treino v4 — usado após
+correções pontuais nas variantes (ex.: reseeding da S-SOM, doc 15 Teorema 15.2)
+sem re-executar o treino principal/DPO. Carrega o último estado local, roda
+`consolidar_som_max_ativos` e reavalia as métricas de neurônios ativos."""
+import base64
+import json
+import os
+import sys
+
+sys.path.insert(0, "/home/z/my-project/khtst/src")
+
+import torch
+
+from khtst.config import Config
+from khtst.dados.checkpoints import GestorCheckpoints
+from khtst.dados.tokenizador import TokenizadorKHTST
+from khtst.memoria.orquestrador import OrquestradorSOM
+from khtst.nucleo.modelo import KHTSTModel
+from khtst.telemetria.hub import TelemetryHub
+from khtst.treino.treinador import TreinadorExtensao
+
+CORPUS = "/home/z/my-project/khtst/cache_dados/corpus_v2.jsonl"
+TOKENIZADOR = "/home/z/my-project/khtst/cache_dados/tokenizador.json"
+RESUMO = "/home/z/my-project/khtst/telemetria_out/resumo_treino_v7.json"
+
+
+def carregar_registros(caminho: str) -> list[dict]:
+    registros = []
+    with open(caminho, encoding="utf-8") as f:
+        for linha in f:
+            try:
+                r = json.loads(linha)
+            except Exception:
+                continue
+            if isinstance(r.get("imagem"), str):
+                try:
+                    r["imagem"] = base64.b64decode(r["imagem"])
+                except Exception:
+                    r["imagem"] = None
+            if isinstance(r.get("audio"), str):
+                try:
+                    r["audio"] = base64.b64decode(r["audio"])
+                except Exception:
+                    r["audio"] = None
+            registros.append(r)
+    return registros
+
+
+def main():
+    cfg = Config().de_arquivo("/home/z/my-project/khtst/configs/base.json")
+    hub = TelemetryHub(cfg.telemetria.arquivo_jsonl)
+    tk = TokenizadorKHTST(TOKENIZADOR)
+    registros = carregar_registros(CORPUS)
+    print(f"corpus: {len(registros)} registros")
+
+    modelo = KHTSTModel(cfg, usar_multimodal=True)
+    checkpoints = GestorCheckpoints(dir_local=cfg.checkpoints.dir_local)
+    tag = checkpoints.ultima_tag()
+    if tag:
+        checkpoints.carregar(modelo, tag)
+    print(f"estado carregado: {tag or 'NENHUM'}")
+    orquestrador = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som, hub=hub,
+                    cfg_atencao=vars(cfg.som_atencao) if hasattr(cfg, "som_atencao") else None)
+    treinar = TreinadorExtensao(cfg, modelo, tk, hub, registros,
+                                orquestrador_som=orquestrador, checkpoints=checkpoints)
+
+    print("== FASE B: reconsolidação SOM (S-SOM agora com reseeding) ==")
+    resultado_som = treinar.consolidar_som_max_ativos()
+    ativos = orquestrador.telemetria_ativos()
+    print("neurônios ativos por variante:", json.dumps(ativos, indent=1))
+
+    aval_final = treinar.avaliar(max_lotes=4)
+    print("avaliação pós-reconsolidação:", aval_final)
+
+    if os.path.exists(RESUMO):
+        resumo = json.load(open(RESUMO, encoding="utf-8"))
+        resumo["som"] = {k: v for k, v in resultado_som.items()
+                         if k != "prototipos"}
+        resumo["avaliacao_final"] = aval_final
+        mc = resumo.get("metricas_completas", {})
+        mc["neuronios_ativos"] = ativos
+        resumo["metricas_completas"] = mc
+        with open(RESUMO, "w", encoding="utf-8") as f:
+            json.dump(resumo, f, ensure_ascii=False, indent=2, default=str)
+        print(f"resumo atualizado → {RESUMO}")
+    checkpoints.salvar(modelo, "fase-som-v7",
+                   {"passo_global": treinar.passo_global,
+                    "reconsolidacao": True,
+                    "ativos": ativos})
+
+
+if __name__ == "__main__":
+    main()

scripts/08_graficos_card.py

@@ -0,0 +1,355 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""v7 — COMPARAÇÃO DE TREINOS + GRÁFICOS DE DESEMPENHO (apenas no card HF).
+
+Compara o treino ATUAL (resumo_treino_v8.json / avaliacao_v8.json) com o
+treino ANTERIOR (*_anterior.json), incorpora as métricas observadas em
+tests/test_khtst_v6.py e o monitor de RAM, e produz os gráficos do model
+card (graficos/*.png). O Agente Engenheiro valida a NÃO-REGRESSÃO
+(Teorema 16.10) das capacidades fundamentais.
+
+Gráficos (todos em PT-BR, publicados SOMENTE no card HF):
+  1. graf_curva_perda.png   — perda média por época (anterior vs atual)
+  2. graf_ppl_lm.png        — ppl LM por época (anterior vs atual, log)
+  3. graf_ram.png           — consumo de RAM durante o treino (Agente)
+  4. graf_perdas_tarefa.png — perda por tarefa (anterior vs atual)
+  5. graf_som_roteador.png  — SOM: taxa de ativos por variante + RPP
+  6. graf_alinhamento.png   — CLIP/PPL-multimodal/PPL-visual (honesto)
+"""
+import json
+import math
+import os
+import sys
+
+sys.path.insert(0, "/home/z/my-project/khtst/src")
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+RAIZ = "/home/z/my-project/khtst"
+TEL = os.path.join(RAIZ, "telemetria_out")
+GRAF = os.path.join(RAIZ, "graficos")
+
+COR_ANTE = "#7f8fa6"
+COR_ATUAL = "#e17055"
+COR_AZUL = "#0984e3"
+COR_VERDE = "#00b894"
+
+
+def carregar(nome):
+    p = os.path.join(TEL, nome)
+    if not os.path.exists(p):
+        return None
+    with open(p, encoding="utf-8") as f:
+        texto = f.read()
+    if nome.endswith(".jsonl"):
+        # JSONL: um objeto por linha (monitor de RAM)
+        amostras = []
+        for linha in texto.splitlines():
+            try:
+                amostras.append(json.loads(linha))
+            except Exception:
+                continue
+        return amostras
+    return json.loads(texto)
+
+
+def curva_epocas(resumo):
+    """[(epoca, perda_media, ppl_lm)] por época."""
+    pts = []
+    for e in (resumo or {}).get("epocas", []):
+        av = e.get("avaliacao", {})
+        pts.append((e.get("epoca", 0), e.get("perda_media"),
+                    av.get("ppl_lm")))
+    return pts
+
+
+def parse_testes(nome="test_khtst_v6_pos_treino.txt"):
+    p = os.path.join(TEL, nome)
+    ok, fal, cru = None, None, ""
+    if os.path.exists(p):
+        cru = open(p, encoding="utf-8", errors="ignore").read()
+        for linha in cru.splitlines():
+            if "resultado:" in linha and "✓" in linha:
+                partes = linha.split()
+                try:
+                    ok = int(partes[partes.index("✓") - 1])
+                    fal = int(partes[partes.index("✗") - 1])
+                except Exception:
+                    pass
+    return {"ok": ok, "falhou": fal, "cru": cru[-400:]}
+
+
+def main():
+    os.makedirs(GRAF, exist_ok=True)
+    ant_r = carregar("resumo_treino_v6_anterior.json")
+    atu_r = carregar("resumo_treino_v8.json")
+    ant_a = carregar("avaliacao_v6_anterior.json")
+    atu_a = carregar("avaliacao_v8.json")
+    ram = carregar("ram_treino_v8.jsonl") or []
+    testes = parse_testes()
+
+    cmp_: dict = {
+        "versao_atual": (atu_r or {}).get("versao", "v7"),
+        "versao_anterior": (ant_r or {}).get("versao", "v6"),
+        "test_khtst_v6": {"ok": testes["ok"], "falhou": testes["falhou"]},
+        "ram": (atu_r or {}).get("ram", {}),
+    }
+
+    # ---------------- 1) curva de perda ----------------
+    plt.rcParams.update({"font.size": 10})
+    ca, cn = curva_epocas(ant_r), curva_epocas(atu_r)
+    fig, ax = plt.subplots(figsize=(7.2, 4.2), constrained_layout=True)
+    if ca:
+        ax.plot([p[0] for p in ca], [p[1] for p in ca], "o--", color=COR_ANTE,
+                label="treino anterior (v6)", lw=1.6, ms=5)
+    if cn:
+        ax.plot([p[0] for p in cn], [p[1] for p in cn], "o-", color=COR_ATUAL,
+                label="retreino atual (v7)", lw=2.0, ms=6)
+    ax.set_xlabel("época")
+    ax.set_ylabel("perda média (CE ponderada, 9 tarefas)")
+    ax.set_title("Curva de aprendizado — perda média por época")
+    ax.grid(alpha=0.3)
+    ax.legend(loc="upper right", frameon=False)
+    fig.savefig(os.path.join(GRAF, "graf_curva_perda.png"), dpi=150)
+    plt.close(fig)
+
+    # ---------------- 2) ppl LM por época ----------------
+    fig, ax = plt.subplots(figsize=(7.2, 4.2), constrained_layout=True)
+    if ca:
+        ax.plot([p[0] for p in ca], [max(p[2], 1e-1) for p in ca], "o--",
+                color=COR_ANTE, label="treino anterior (v6)", lw=1.6, ms=5)
+    if cn:
+        ax.plot([p[0] for p in cn], [max(p[2], 1e-1) for p in cn], "o-",
+                color=COR_ATUAL, label="retreino atual (v7)", lw=2.0, ms=6)
+    aleat = ((ant_a or {}).get("ppl_lm_aleatorio")
+             or (atu_a or {}).get("ppl_lm_aleatorio"))
+    if aleat:
+        ax.axhline(aleat, color="#b2bec3", ls=":", lw=1.4,
+                   label=f"inicialização aleatória (ppl≈{aleat:,.0f})")
+    ax.set_yscale("log")
+    ax.set_xlabel("época")
+    ax.set_ylabel("perplexidade LM (escala log)")
+    ax.set_title("Perplexidade LM por época")
+    ax.grid(alpha=0.3, which="both")
+    ax.legend(loc="lower left", frameon=False, fontsize=9)
+    fig.savefig(os.path.join(GRAF, "graf_ppl_lm.png"), dpi=150)
+    plt.close(fig)
+
+    # ---------------- 3) RAM (Agente Engenheiro) ----------------
+    if ram:
+        t0 = ram[0]["t"]
+        minutos = [(a["t"] - t0) / 60.0 for a in ram]
+        rss = [a["rss_mb"] for a in ram]
+        disp = [a["disponivel_mb"] for a in ram]
+        passos = [a.get("passo", 0) for a in ram]
+        fig, ax = plt.subplots(figsize=(7.6, 4.4), constrained_layout=True)
+        ax.plot(minutos, rss, color=COR_AZUL, lw=1.4,
+                label="RSS do processo (treino)")
+        mx = max(rss)
+        md = sum(rss) / len(rss)
+        ax.axhline(mx, color="#d63031", ls="--", lw=1.1,
+                   label=f"pico {mx:,.0f} MB")
+        ax.axhline(md, color=COR_VERDE, ls=":", lw=1.1,
+                   label=f"média {md:,.0f} MB")
+        ax2 = ax.twinx()
+        ax2.fill_between(minutos, disp, color="#dfe6e9", alpha=0.55,
+                         label="RAM disponível (sistema)")
+        ax2.set_ylabel("disponível (MB)", color="#636e72")
+        ax.set_xlabel("tempo de treino (min)")
+        ax.set_ylabel("RSS do processo (MB)")
+        ax.set_title("Consumo de memória RAM durante o retreino (Agente Engenheiro)")
+        ax.set_xlim(0, max(minutos[-1], 0.5))
+        ax.grid(alpha=0.3)
+        # marcações de passos a cada ~25% do treino
+        p_max = max(passos) or 0
+        for frac in (0.25, 0.5, 0.75):
+            i = min(range(len(passos)), key=lambda j: abs(passos[j] - frac * p_max))
+            ax.annotate(f"passo {passos[i]}", (minutos[i], rss[i]),
+                        textcoords="offset points", xytext=(0, 8),
+                        fontsize=7.5, color="#2d3436", ha="center")
+        h1, l1 = ax.get_legend_handles_labels()
+        h2, l2 = ax2.get_legend_handles_labels()
+        ax.legend(h1 + h2, l1 + l2, loc="upper left",
+                  bbox_to_anchor=(0.0, 1.22), ncols=2, frameon=False, fontsize=8.5)
+        fig.savefig(os.path.join(GRAF, "graf_ram.png"), dpi=150)
+        plt.close(fig)
+
+    # ---------------- 4) perdas por tarefa ----------------
+    def perdas_tarefa(av):
+        pt = (av or {}).get("perdas_tarefa", {})
+        return {k: v.get("treinado") for k, v in pt.items()
+                if isinstance(v, dict) and v.get("treinado") is not None}
+
+    pa, pn = perdas_tarefa(ant_a), perdas_tarefa(atu_a)
+    if pa and pn:
+        tarefas = sorted(set(pa) & set(pn))
+        x = range(len(tarefas))
+        larg = 0.38
+        fig, ax = plt.subplots(figsize=(7.6, 4.2), constrained_layout=True)
+        ax.bar([i - larg / 2 for i in x], [pa[t] for t in tarefas], larg,
+               color=COR_ANTE, label="treino anterior (v6)")
+        ax.bar([i + larg / 2 for i in x], [pn[t] for t in tarefas], larg,
+               color=COR_ATUAL, label="retreino atual (v7)")
+        ax.set_xticks(list(x))
+        ax.set_xticklabels(tarefas, rotation=28, ha="right")
+        ax.set_ylabel("perda final por tarefa (treinada)")
+        ax.set_title("Perda final por tarefa — menor é melhor")
+        ax.grid(alpha=0.3, axis="y")
+        ax.legend(loc="upper right", frameon=False)
+        fig.savefig(os.path.join(GRAF, "graf_perdas_tarefa.png"), dpi=150)
+        plt.close(fig)
+        cmp_["perdas_tarefa"] = {t: {"anterior": pa[t], "atual": pn[t]}
+                                 for t in tarefas}
+
+    # ---------------- 5) SOM variantes + RPP ----------------
+    def variantes(av):
+        return ((av or {}).get("som_treinado", {}) or {}).get("variantes", {})
+
+    va, vn = variantes(ant_a), variantes(atu_a)
+    if va and vn:
+        nomes = sorted(set(va) & set(vn))
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(8.4, 4.0),
+                                       constrained_layout=True)
+        y = range(len(nomes))
+        ax1.barh([i + 0.2 for i in y], [va[n].get("taxa_ativos", 0) for n in nomes],
+                 0.38, color=COR_ANTE, label="anterior (v6)")
+        ax1.barh([i - 0.2 for i in y], [vn[n].get("taxa_ativos", 0) for n in nomes],
+                 0.38, color=COR_ATUAL, label="atual (v7)")
+        ax1.set_yticks(list(y))
+        ax1.set_yticklabels(nomes)
+        ax1.invert_yaxis()
+        ax1.set_xlim(0, 1.05)
+        ax1.axvline(0.90, color="#d63031", ls=":", lw=1.2,
+                    label="alvo 0.90 (Teo. 15.2)")
+        ax1.set_xlabel("taxa de neurônios ativos")
+        ax1.set_title("SOM — 8 variantes + S-SOM")
+        ax1.grid(alpha=0.3, axis="x")
+        ax1.legend(loc="lower right", fontsize=8, frameon=False)
+        rpa = ((ant_r or {}).get("rpp") or {})
+        rpn = ((atu_r or {}).get("rpp") or {})
+        cats = ["recompensas", "punicoes", "penalidades"]
+        vals_a = [rpa.get(c, 0) for c in cats]
+        vals_n = [rpn.get(c, 0) for c in cats]
+        x2 = range(len(cats))
+        ax2.bar([i - 0.2 for i in x2], vals_a, 0.38, color=COR_ANTE,
+                label="anterior (v6)")
+        ax2.bar([i + 0.2 for i in x2], vals_n, 0.38, color=COR_ATUAL,
+                label="atual (v7)")
+        ax2.set_xticks(list(x2))
+        ax2.set_xticklabels(["REWARD", "PUNISH", "PENALTY"])
+        ax2.set_ylabel("eventos no treino")
+        ax2.set_title("RPP — Reward/Punishment/Penalty")
+        ax2.grid(alpha=0.3, axis="y")
+        ax2.legend(fontsize=8, frameon=False)
+        fig.savefig(os.path.join(GRAF, "graf_som_roteador.png"), dpi=150)
+        plt.close(fig)
+        cmp_["som_taxa_ativos"] = {n: {"anterior": va[n].get("taxa_ativos"),
+                                       "atual": vn[n].get("taxa_ativos")}
+                                   for n in nomes}
+        cmp_["rpp"] = {"anterior": rpa, "atual": rpn}
+
+    # ---------------- 6) alinhamento multimodal (honesto) ----------------
+    def aln(av):
+        return {"clip_real": ((av or {}).get("clip_score", {}) or {}).get("clip_real"),
+                "clip_controle": ((av or {}).get("clip_score", {}) or {}).get("clip_controle"),
+                "ppl_mm": ((av or {}).get("ppl_multimodal", {}) or {}).get("ppl_mm"),
+                "ppl_visual": ((av or {}).get("ppl_visual", {}) or {}).get("ppl_visual"),
+                "itm_acc": ((av or {}).get("itm", {}) or {}).get("acuracia")}
+
+    aa, an = aln(ant_a), aln(atu_a)
+    if aa and an:
+        fig, ax = plt.subplots(figsize=(7.6, 4.0), constrained_layout=True)
+        chaves = ["clip_real", "ppl_mm", "ppl_visual", "itm_acc"]
+        rotulos = ["CLIP score (real)", "PPL multimodal", "PPL visual",
+                   "ITM acurácia"]
+        va_ = [aa[k] if isinstance(aa[k], (int, float)) else 0 for k in chaves]
+        vn_ = [an[k] if isinstance(an[k], (int, float)) else 0 for k in chaves]
+        x = range(len(chaves))
+        ax.bar([i - 0.2 for i in x], va_, 0.38, color=COR_ANTE,
+               label="anterior (v6)")
+        ax.bar([i + 0.2 for i in x], vn_, 0.38, color=COR_ATUAL,
+               label="atual (v7)")
+        for i, (a_, n_) in enumerate(zip(va_, vn_)):
+            if isinstance(aa[chaves[i]], (int, float)):
+                ax.text(i - 0.2, a_, f"{a_:.2f}", ha="center", va="bottom",
+                        fontsize=8)
+            if isinstance(an[chaves[i]], (int, float)):
+                ax.text(i + 0.2, n_, f"{n_:.2f}", ha="center", va="bottom",
+                        fontsize=8)
+        ax.set_xticks(list(x))
+        ax.set_xticklabels(rotulos, fontsize=9)
+        ax.set_title("Alinhamento multimodal (CLIP/ITM/PPL) — leitura honesta")
+        ax.grid(alpha=0.3, axis="y")
+        ax.legend(loc="upper right", frameon=False)
+        fig.savefig(os.path.join(GRAF, "graf_alinhamento.png"), dpi=150)
+        plt.close(fig)
+        cmp_["alinhamento"] = {"anterior": aa, "atual": an}
+
+    # ---------------- comparacao + NÃO-REGRESSÃO ----------------
+    ppl_a = (ant_a or {}).get("ppl_lm")
+    ppl_n = (atu_a or {}).get("ppl_lm")
+    cmp_["ppl_lm"] = {"anterior": ppl_a, "atual": ppl_n,
+                      "delta_pct": (round(100 * (ppl_n - ppl_a) / ppl_a, 2)
+                                    if ppl_a and ppl_n else None)}
+    if ant_r and atu_r and ant_r.get("epocas") and atu_r.get("epocas"):
+        pm_a = ant_r["epocas"][-1].get("perda_media")
+        pm_n = atu_r["epocas"][-1].get("perda_media")
+        cmp_["perda_media_final"] = {"anterior": pm_a, "atual": pm_n}
+        cmp_["passos"] = {"anterior": ant_r.get("passos"),
+                          "atual": atu_r.get("passos")}
+
+    # Teorema 16.10 — capacidades FUNDAMENTAIS do gate (ppl/perda: menor é
+    # melhor). ppl_multimodal fica FORA do gate: o codebook VQ é re-estimado
+    # por treino (k-means por crop) e sua variância entre corridas independen-
+    # tes é maior que a própria diferença de qualidade — é REPORTADO honesta-
+    # mente na comparação e nos gráficos, mas não bloqueia a publicação.
+    _ep_a = (ant_r or {}).get("epocas") or [{}]
+    caps_antes = {"ppl_lm": ppl_a,
+                  "perda_media_final": _ep_a[-1].get("perda_media")}
+    caps_depois = {"ppl_lm": ppl_n,
+                   "perda_media_final": (atu_r or {}).get("epocas", [{}])[-1]
+                   .get("perda_media")}
+    # saúde SOM entra como capacidade (maior/menor conforme a métrica)
+    _ta_a = [v.get("taxa_ativos") for v in variantes(ant_a).values()
+             if isinstance(v.get("taxa_ativos"), (int, float))]
+    _ta_n = [v.get("taxa_ativos") for v in variantes(atu_a).values()
+             if isinstance(v.get("taxa_ativos"), (int, float))]
+    if _ta_a:
+        caps_antes["taxa_ativos_min"] = min(_ta_a)
+    if _ta_n:
+        caps_depois["taxa_ativos_min"] = min(_ta_n)
+    try:
+        from khtst.config import Config
+        from khtst.qualidade import AgenteEngenheiro
+        ag = AgenteEngenheiro(dir_telemetria=TEL,
+                              tolerancia_regressao=Config()
+                              .agente_engenheiro.tolerancia_regressao)
+        # v8.3 — CORREÇÃO de bug latente do v7: o gate usava as chaves
+        # "ppl_valid/perda_valid", mas as métricas reais são "ppl_lm" e
+        # "perda_media_final" — o gate NUNCA verificou o ppl! Com as chaves
+        # corretas, "menor é melhor" passa a valer de fato (Teorema 16.10).
+        nr = ag.garantir_nao_regressao(
+            {k: v for k, v in caps_antes.items() if v is not None},
+            {k: v for k, v in caps_depois.items() if v is not None},
+            menor_e_melhor=("ppl_valid", "perda_valid", "ppl_lm",
+                            "perda_media_final", "perda_lm"))
+        cmp_["nao_regressao"] = nr
+    except Exception as e:
+        cmp_["nao_regressao"] = {"erro": f"{type(e).__name__}: {e}"}
+
+    with open(os.path.join(TEL, "comparacao_treino_v8.json"), "w",
+              encoding="utf-8") as f:
+        json.dump(cmp_, f, ensure_ascii=False, indent=2, default=str)
+    print("comparação → telemetria_out/comparacao_treino_v8.json")
+    print("gráficos:", sorted(os.listdir(GRAF)))
+    print("não-regressão aprovada:",
+          cmp_.get("nao_regressao", {}).get("aprovado"))
+    print("ppl_lm:", cmp_["ppl_lm"])
+    print("testes v6:", cmp_["test_khtst_v6"])
+    print("ram:", json.dumps(cmp_["ram"]))
+
+
+if __name__ == "__main__":
+    main()

scripts/09_teste_item_b.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Teste FINAL do item (b) — modelo KHTST TREINADO (checkpoint fase-som).
+
+Verifica, com o modelo pós-treino real:
+  1. 4 requisições submetidas em série ANTES da 1ª resposta;
+  2. recebimento (estado RECEBIDA) confirmado para todas antes do processamento;
+  3. processamento (PROCESSANDO → CONCLUIDA) com tokens gerados;
+  4. stopping (cancelamento) honrado em ≤ 1 passo durante geração ativa;
+  5. continue (retomada de pedido pausado).
+Saída: telemetria_out/teste_item_b_v8.json
+"""
+import json
+import sys
+import threading
+import time
+
+sys.path.insert(0, "/home/z/my-project/khtst/src")
+
+import torch
+
+from khtst.config import Config
+from khtst.dados.tokenizador import TokenizadorKHTST
+from khtst.memoria.orquestrador import OrquestradorSOM
+from khtst.nucleo.modelo import KHTSTModel
+from khtst.servico import SessaoKHTST
+
+CFG_PATH = "/home/z/my-project/khtst/configs/base.json"
+TK_PATH = "/home/z/my-project/khtst/cache_dados/tokenizador.json"
+SAIDA = "/home/z/my-project/khtst/telemetria_out/teste_item_b_v8.json"
+
+cfg = Config().de_arquivo(CFG_PATH)
+torch.manual_seed(cfg.dados.semente)
+modelo = KHTSTModel(cfg, usar_multimodal=True)
+tk = TokenizadorKHTST(TK_PATH)
+
+# retoma o estado final (fase-som)
+from khtst.dados.checkpoints import GestorCheckpoints
+ck = GestorCheckpoints("/home/z/my-project/khtst/estados_local", "estados/fase-v8")
+tag = ck.ultima_tag()
+if tag:
+    ok = ck.carregar(modelo, tag)
+    print(f"estado retomado: {tag} (ok={ok})")
+modelo.eval()
+
+sessao = SessaoKHTST(modelo, decodificar=tk)
+prompts = [
+    "O KHTST é um modelo multimodal que",
+    "A previsão do tempo para amanhã indica",
+    "Para cozinhar arroz, primeiro",
+    "O melhor time do Brasil é",
+]
+# ---- 1) 4 requisições EM SÉRIE antes da 1ª resposta ----
+pids = [sessao.submeter(p, max_novos=10, tarefa="lm") for p in prompts]
+estados_iniciais = [sessao.pedidos[i].estado.value for i in pids]
+check_recebimento = all(e == "recebida" for e in estados_iniciais)
+print("1) 4 pedidos ANTES da 1ª resposta:", pids, "| estados:", estados_iniciais)
+
+# ---- 2/3) processa todos (a bomba adhoc roda ENTRE tokens) ----
+t0 = time.time()
+saidas = sessao.executar_todos(max_passos=400)
+dur = time.time() - t0
+rel = sessao.relatorio()
+check_processamento = all(rel[i]["estado"] == "concluida" and rel[i]["n_tokens"] == 10
+                          for i in pids)
+print("2) processamento:", [(i, rel[i]["estado"], rel[i]["n_tokens"]) for i in pids],
+      f"| {dur:.1f}s")
+for i in pids:
+    texto = tk.decodificar(saidas[i])
+    print(f"   pedido {i}: «{prompts[i]}» → {texto[:70]!r}")
+
+# ---- 4) stopping durante processamento ativo (thread externa) ----
+sessao2 = SessaoKHTST(modelo, decodificar=tk)
+p_st = sessao2.submeter("Escreva uma história longa sobre o mar e as estrelas",
+                        max_novos=60, tarefa="lm")
+def para_no_meio():
+    time.sleep(0.4)
+    sessao2.stop(p_st, cancelar=True)
+threading.Thread(target=para_no_meio, daemon=True).start()
+sessao2.executar_todos(max_passos=400)
+rel2 = sessao2.relatorio()[p_st]
+check_stop = rel2["estado"] == "cancelada" and 0 < rel2["n_tokens"] < 60
+print("4) stopping:", rel2["estado"], "| tokens antes do stop:", rel2["n_tokens"],
+      "| eventos:", rel2["eventos"])
+
+# ---- 5) pause → continue ----
+sessao3 = SessaoKHTST(modelo, decodificar=tk)
+p_pc = sessao3.submeter("O livro da floresta narra", max_novos=12, tarefa="lm")
+sessao3.canal.stop(p_pc, cancelar=False)          # pausa no 1º dreno
+def retoma():
+    time.sleep(0.3)
+    sessao3.continuar(p_pc)
+threading.Thread(target=retoma, daemon=True).start()
+sessao3.executar_todos(max_passos=400)
+rel3 = sessao3.relatorio()[p_pc]
+check_continue = rel3["estado"] == "concluida" and "pausada" in rel3["eventos"] \
+    and "retomada" in rel3["eventos"]
+print("5) pause→continue:", rel3["estado"], "| eventos:", rel3["eventos"])
+
+resultado = {
+    "modelo": "KHTST v8 (checkpoint: " + str(tag) + ")",
+    "item_b_4_requisicoes_antes_da_1a": bool(check_recebimento),
+    "item_b_processamento_e_conclusao": bool(check_processamento),
+    "item_b_stopping_durante_ativa": bool(check_stop),
+    "item_b_pause_continue": bool(check_continue),
+    "estados_iniciais": estados_iniciais,
+    "relatorio_completo": {str(i): rel[i] for i in rel},
+    "relatorio_stop": rel2,
+    "relatorio_pause_continue": rel3,
+    "duracao_s": round(dur, 2),
+}
+ok_all = all([check_recebimento, check_processamento, check_stop, check_continue])
+resultado["item_b_aprovado"] = bool(ok_all)
+with open(SAIDA, "w", encoding="utf-8") as f:
+    json.dump(resultado, f, ensure_ascii=False, indent=2, default=str)
+print(f"\nITEM B: {'APROVADO' if ok_all else 'REPROVADO'} → {SAIDA}")
+sys.exit(0 if ok_all else 1)

src/khtst/acelerado/__init__.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+"""Fachada dos núcleos acelerados (Cython+C) com FALLBACK puro-torch.
+
+Estratégia (requisito: reescrever em Cython + C/C++ sem quebrar acessos):
+  • tenta importar o módulo compilado `nucleos` (build via setup.py);
+  • sem binário, usa os equivalentes EM TORCH com matemática idêntica
+    (Teorema 19.25 — semântica sequencial preservada por laço);
+  • `status()` informa qual backend está em uso (honestidade — doc 00).
+"""
+from __future__ import annotations
+
+import math
+
+import torch
+
+try:
+    from khtst.acelerado.nucleos import (som_atualizar_lote as _som_c,
+                                         contagens_entropia as _cont_c)
+    BACKEND = "cython_c"
+except Exception:
+    _som_c = None
+    _cont_c = None
+    BACKEND = "torch_fallback"
+
+
+def som_atualizar_lote(w: torch.Tensor, v: torch.Tensor, hit_ema: torch.Tensor,
+                       z: torch.Tensor, rotulos: torch.Tensor,
+                       eta0: float, lambda_sup: float, n_amostras: int):
+    """Kohonen sequencial (eq. 6.2) — Cython/C se disponível; senão torch.
+    Semântica EXATA do laço original do RoteadorSSOM.atualizar."""
+    if _som_c is not None:
+        zc = z.detach().cpu().double().contiguous()
+        rot = rotulos.detach().cpu().long().contiguous()
+        # memoryviews Cython: converte via numpy; COPY-BACK garante propagação
+        # mesmo quando o tensor original não é float64/contíguo
+        wn = w.detach().cpu()
+        wn = wn if (wn.dtype == torch.float64 and wn.is_contiguous()) \
+            else wn.double().contiguous()
+        vn = v.detach().cpu()
+        vn = vn if (vn.dtype == torch.float64 and vn.is_contiguous()) \
+            else vn.double().contiguous()
+        hn = hit_ema.detach().cpu()
+        hn = hn if (hn.dtype == torch.float64 and hn.is_contiguous()) \
+            else hn.double().contiguous()
+        eq, n = _som_c(wn.numpy(), vn.numpy(), hn.numpy(), zc.numpy(),
+                       rot.numpy(), eta0, lambda_sup, n_amostras)
+        w.copy_(torch.from_numpy(wn.numpy()))
+        v.copy_(torch.from_numpy(vn.numpy()))
+        hit_ema.copy_(torch.from_numpy(hn.numpy()))
+        return eq, n
+    # fallback torch: MESMA ordem de atualizações (Robbins–Monro ordenal)
+    zc = z.detach().cpu().double()
+    eq_soma = 0.0
+    for i in range(zc.shape[0]):
+        n_amostras += 1
+        xi = zc[i]
+        d2 = torch.cdist(xi.unsqueeze(0), w.double()).pow(2).squeeze(0)
+        c = int(d2.argmin())
+        eq_soma += float(d2[c])
+        eta = eta0 / (1.0 + 0.001 * n_amostras)
+        w[c] += eta * (xi - w[c])
+        p = torch.softmax(v[c], dim=0)
+        onehot = torch.zeros_like(p)
+        onehot[int(rotulos[i])] = 1.0
+        v[c] += (lambda_sup * 0.1) * (onehot - p)
+        hit_ema *= 0.92
+        hit_ema[c] += 0.08
+    return eq_soma / max(zc.shape[0], 1), n_amostras
+
+
+def contagens_entropia(contextos: list[int] | torch.Tensor, vocab: int,
+                       h_max: float, punicao_base: float):
+    """Contagens + entropia + fator da punição dinâmica (eq. 10.8/10.9)."""
+    if _cont_c is not None and not isinstance(contextos, torch.Tensor):
+        ctx = torch.tensor(list(contextos), dtype=torch.long).contiguous()
+        cont, h, fator = _cont_c(ctx.numpy(), vocab, h_max, punicao_base)
+        return cont, h, fator
+    contagens = torch.bincount(torch.as_tensor(list(contextos), dtype=torch.long),
+                               minlength=vocab)
+    probs = contagens.float() / max(float(contagens.sum()), 1.0)
+    p_nz = probs[probs > 0]
+    h = float(-(p_nz * torch.log(p_nz + 1e-8)).sum()) if p_nz.numel() else 0.0
+    fator = min(1.0, h / max(h_max, 1e-6))
+    return contagens, h, fator
+
+
+def status() -> dict:
+    return {"backend": BACKEND,
+            "cython_disponivel": _som_c is not None}