v0.11.0: provas r-36..r-42 completadas (M-R5′ guloso ótimo com contraexemplo exausto, V-2′ ECE_aceito com errata reproduzida, H-1′ pin slot) + raciocínio elástico RE-1..RE-8 (ênfase Hedge previsível, water-filling, certificado de compressão com bound estendido triangular e rollback defensivo) + tratamento de erros Rust&Assembly (tratamento.txt): kernels add/jc (CF) e ucomisd/ucomiss (PF) com códigos em registrador → Result, module::error thiserror, 13 sorts total_cmp (NaN nunca mais pânico no treino), checkpoint atômico SHA-256 restaurado e integrado ao treino real, tipos de domínio, MotorPensamento::novo_com_rng determinístico — árvore canônica plana (restos do split v0.10 removidos; ramo morto arquivado localmente) — 160/160 cargo 3×, 29/29 gates (79), 9/9 avaliação real Wikipédia PT-BR (80)
Browse filesThis view is limited to 50 files because it contains too many changes. See raw diff
- Cargo.lock +1 -1
- Cargo.toml +2 -2
- README.md +30 -12
- docs/memorias/r-19-provas-som-v050.md +2 -0
- docs/memorias/r-20-provas-jepa-v050.md +2 -0
- docs/memorias/r-21-provas-pensamento-v050.md +2 -0
- docs/memorias/r-23-provas-verificador-ncm-v060.md +2 -0
- docs/memorias/r-25-provas-moe-redirecionavel-v060.md +3 -0
- docs/memorias/r-35-analise-provas-deepseek-v100.md +543 -0
- docs/memorias/r-36-provas-som-v011.md +76 -0
- docs/memorias/r-37-provas-jepa-v011.md +62 -0
- docs/memorias/r-38-provas-ncm-v011.md +66 -0
- docs/memorias/r-39-provas-pensamento-v011.md +51 -0
- docs/memorias/r-40-provas-verificador-v011.md +44 -0
- docs/memorias/r-41-provas-moe-fnh-v011.md +62 -0
- docs/memorias/r-42-raciocinio-elastico-v011.md +112 -0
- docs/memorias/r-43-tratamento-erros-asm-v011.md +180 -0
- pyproject.toml +1 -1
- resultados/avaliacao_real_v011.json +104 -0
- resultados/suite_v011_final.json +73 -0
- resultados/telemetria_v011.json +111 -0
- resultados/treino_v100.json +251 -0
- scripts/74_treino_v100.py +148 -0
- scripts/79_suite_v011.py +230 -0
- scripts/80_avaliacao_real_v011.py +166 -0
- scripts/81_telemetria_v011.py +147 -0
- scripts/82_publicar_v011.py +223 -0
- src/asm.rs +303 -0
- src/bin/bench_v090.rs +1 -1
- src/controlador.rs +4 -4
- src/fnh.rs +16 -0
- src/gerador.rs +3 -3
- src/jepa.rs +329 -15
- src/jepa/mascaras.rs +0 -173
- src/jepa/mod.rs +0 -61
- src/jepa/nucleo.rs +0 -211
- src/jepa/patches.rs +0 -150
- src/jepa/replay_ssm.rs +0 -107
- src/jepa/sonic_moe.rs +0 -155
- src/jepa/testes.rs +0 -212
- src/jepa/variantes.rs +0 -476
- src/lib.rs +361 -5
- src/moe_redirecionavel.rs +124 -6
- src/moe_redirecionavel/atencao.rs +0 -63
- src/moe_redirecionavel/mod.rs +0 -57
- src/moe_redirecionavel/nucleo.rs +0 -431
- src/moe_redirecionavel/teste_integrado.rs +0 -26
- src/moe_redirecionavel/testes.rs +0 -209
- src/moe_redirecionavel/treino.rs +0 -463
- src/nlg.rs +2 -2
Cargo.lock
CHANGED
|
@@ -734,7 +734,7 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
|
|
| 734 |
|
| 735 |
[[package]]
|
| 736 |
name = "khtst-rust"
|
| 737 |
-
version = "0.
|
| 738 |
dependencies = [
|
| 739 |
"anyhow",
|
| 740 |
"built",
|
|
|
|
| 734 |
|
| 735 |
[[package]]
|
| 736 |
name = "khtst-rust"
|
| 737 |
+
version = "0.11.0"
|
| 738 |
dependencies = [
|
| 739 |
"anyhow",
|
| 740 |
"built",
|
Cargo.toml
CHANGED
|
@@ -1,8 +1,8 @@
|
|
| 1 |
[package]
|
| 2 |
name = "khtst-rust"
|
| 3 |
-
version = "0.
|
| 4 |
edition = "2021"
|
| 5 |
-
description = "KHTST_RUST — provas
|
| 6 |
license = "Apache-2.0"
|
| 7 |
|
| 8 |
[lib]
|
|
|
|
| 1 |
[package]
|
| 2 |
name = "khtst-rust"
|
| 3 |
+
version = "0.11.0"
|
| 4 |
edition = "2021"
|
| 5 |
+
description = "KHTST_RUST v0.11.0 — provas r-36..r-42 completadas (M-R5′ guloso ótimo, V-2′ ECE_aceito, H-1′ pin slot) + raciocínio elástico RE-1..RE-8 com certificado de compressão + tratamento de erros Rust&Assembly (flags CF/PF/ZF — tratamento.txt) + bug v100-1 corrigido"
|
| 6 |
license = "Apache-2.0"
|
| 7 |
|
| 8 |
[lib]
|
README.md
CHANGED
|
@@ -1,15 +1,17 @@
|
|
| 1 |
-
# KHTST_RUST v0.
|
| 2 |
-
|
| 3 |
-
> **v0.
|
| 4 |
-
>
|
| 5 |
-
>
|
| 6 |
-
>
|
| 7 |
-
>
|
| 8 |
-
>
|
| 9 |
-
>
|
| 10 |
-
>
|
| 11 |
-
>
|
| 12 |
-
> cargo**
|
|
|
|
|
|
|
| 13 |
|
| 14 |
Refatoração completa do projeto **KHTST** (`PowerMachine/khtst-multimodal-ptbr`) para **Rust** via **PyO3**, integrando o paradigma **NCM (Next-Concept Modeling)** com todas as provas matemáticas da coleção `memoria-ncm-khtst`, ADBA (atenção adaptativa no processamento paralelo) e Ponte Duplex (comunicação bidirecional simultânea entre modelos).
|
| 15 |
|
|
@@ -101,3 +103,19 @@ Teoremas numerados com ∎ · nascimento neutro (opt-in) · leitura honesta (wal
|
|
| 101 |
## Licença
|
| 102 |
|
| 103 |
Apache-2.0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# KHTST_RUST v0.11.0 — Provas r-36..r-43 · Raciocínio Elástico · Rust+Assembly
|
| 2 |
+
|
| 3 |
+
> **v0.11.0 (este ciclo)**: conclusão das provas **r-36..r-42** (SOM
|
| 4 |
+
> S4-1′/S4-2-Weiszfeld/T-1′/H-1′-pin; JEPA J-1′/J-3′; NCM A.0′/A.1′-Welch/
|
| 5 |
+
> B.1-TC/C.3′-DRO; Pensamento T-P1′/T-P5′-identidade-exata/T-P6′;
|
| 6 |
+
> Verificador N-2/V-2′-ECE_aceito/V-3; MoE M-R1′/**M-R5′-guloso-ótimo**
|
| 7 |
+
> /F-9′) + **raciocínio elástico RE-1..RE-8** (ênfase Hedge, water-filling,
|
| 8 |
+
> **certificado de compressão com rollback**) + **tratamento de erros
|
| 9 |
+
> Rust & Assembly** (tratamento.txt: kernels `add/jc`-CF, `ucomisd/jp`-PF
|
| 10 |
+
> com códigos em registrador → `Result`; checkpoint atômico SHA-256
|
| 11 |
+
> restaurado; tipos de domínio; `total_cmp` em todo sort de treino).
|
| 12 |
+
> Provas: `docs/memorias/r-36…r-43`. Veredito: **160/160 cargo (3×)** +
|
| 13 |
+
> **29/29 gates** (script 79) + **9/9 avaliação em dados reais**
|
| 14 |
+
> (Wikipédia PT-BR, script 80).
|
| 15 |
|
| 16 |
Refatoração completa do projeto **KHTST** (`PowerMachine/khtst-multimodal-ptbr`) para **Rust** via **PyO3**, integrando o paradigma **NCM (Next-Concept Modeling)** com todas as provas matemáticas da coleção `memoria-ncm-khtst`, ADBA (atenção adaptativa no processamento paralelo) e Ponte Duplex (comunicação bidirecional simultânea entre modelos).
|
| 17 |
|
|
|
|
| 103 |
## Licença
|
| 104 |
|
| 105 |
Apache-2.0
|
| 106 |
+
|
| 107 |
+
## Histórico de versões (resumo)
|
| 108 |
+
|
| 109 |
+
| Versão | Foco | Memórias | Veredito |
|
| 110 |
+
|---|---|---|---|
|
| 111 |
+
| v0.5.0 | SOM 4D + JEPA + Pensamento (base provada) | r-18..r-22 | 38/38 |
|
| 112 |
+
| v0.6.0 | Verificador NCM calibrado + fase C + MoEs redirecionáveis + autoajuste | r-23..r-27 | 46/46 |
|
| 113 |
+
| v0.7.0 | FNH gate + árvore de pesos + quebra-cabeça + NLP/NLG | r-28..r-32 | 73/73 |
|
| 114 |
+
| v0.8.0 | Newton-Raphson, árvore iterativa, Cayley, MoE vetorial (bug v080-1) | r-33 | 85/85 |
|
| 115 |
+
| v0.9.0 | SIMD AVX-512 runtime, Thompson, GNG entropia, JEPA adaptativa | r-34 | 104/104 |
|
| 116 |
+
| v0.10.0 | Críticas DeepSeek: J-1′ S4-1′ T-1′ H-1′ T-P5′ Welch TC bug v100-1 | r-35 | 107/107 |
|
| 117 |
+
| **v0.11.0** | **r-36..r-42 completas + elástico RE + Rust&Assembly (tratamento.txt)** | **r-36..r-43** | **29/29 + 160/160 + 9/9 reais** |
|
| 118 |
+
|
| 119 |
+
Cada versão adiciona sem remover: comportamentos anteriores permanecem
|
| 120 |
+
como default (opt-in para os novos mecanismos), testes herdados verdes e
|
| 121 |
+
provas em markdown com critérios de falsificação executáveis.
|
docs/memorias/r-19-provas-som-v050.md
CHANGED
|
@@ -1,5 +1,7 @@
|
|
| 1 |
# r-19 — PROVAS DA SUÍTE SOM v0.5.0 (4D-SOM, T-SOM, GNG, H-SOM)
|
| 2 |
|
|
|
|
|
|
|
| 3 |
> **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas
|
| 4 |
> e computacionais da suíte SOM 4D · **Código**: `src/som4d.rs` ·
|
| 5 |
> **Data**: 2026-10-26 · **Convenção**: ∎ fecha prova; cada teorema tem o
|
|
|
|
| 1 |
# r-19 — PROVAS DA SUÍTE SOM v0.5.0 (4D-SOM, T-SOM, GNG, H-SOM)
|
| 2 |
|
| 3 |
+
> ⚠️ **ERRATA/SUPERSEDE — r-36 (v0.11):** S4-1 e T-1 nesta memória estão REFOULADOS: S4-1 confundia a energia Φ (‖·‖²) com a QE (‖·‖) — o contraexemplo {0,10} da crítica DeepSeek refuta a forma original (reproduzido no teste s41_contraexemplo); T-1 omitia o termo δ/η do rastreio. Ver S4-1′, S4-2 (Weiszfeld), T-1′ e H-1′ em r-36.
|
| 4 |
+
|
| 5 |
> **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas
|
| 6 |
> e computacionais da suíte SOM 4D · **Código**: `src/som4d.rs` ·
|
| 7 |
> **Data**: 2026-10-26 · **Convenção**: ∎ fecha prova; cada teorema tem o
|
docs/memorias/r-20-provas-jepa-v050.md
CHANGED
|
@@ -1,5 +1,7 @@
|
|
| 1 |
# r-20 — PROVAS DA SUÍTE JEPA v0.5.0 (núcleo + 10 variantes + SonicMoE + ReplaySSM)
|
| 2 |
|
|
|
|
|
|
|
| 3 |
> **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas
|
| 4 |
> e computacionais da suíte JEPA · **Código**: `src/jepa.rs` · **Data**:
|
| 5 |
> 2026-10-26 · ∎ fecha prova; cada teorema tem critério de falsificação.
|
|
|
|
| 1 |
# r-20 — PROVAS DA SUÍTE JEPA v0.5.0 (núcleo + 10 variantes + SonicMoE + ReplaySSM)
|
| 2 |
|
| 3 |
+
> ⚠️ **ERRATA/SUPERSEDE — r-37 (v0.11):** J-1 desta memória é INVÁLIDO no ponto crítico: o kink é da RAIZ (std=√var em var=0), não da dobradiça; no colapso exato o autodiff produz NaN (0·∞) e a análise correta é por derivada direcional (sela instável). Ver J-1′ e J-3′ em r-37.
|
| 4 |
+
|
| 5 |
> **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas
|
| 6 |
> e computacionais da suíte JEPA · **Código**: `src/jepa.rs` · **Data**:
|
| 7 |
> 2026-10-26 · ∎ fecha prova; cada teorema tem critério de falsificação.
|
docs/memorias/r-21-provas-pensamento-v050.md
CHANGED
|
@@ -1,5 +1,7 @@
|
|
| 1 |
# r-21 — PROVAS DA TECNOLOGIA PENSAMENTO v0.5.0
|
| 2 |
|
|
|
|
|
|
|
| 3 |
> **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas
|
| 4 |
> e computacionais da tecnologia Pensamento (N-redes paralelas cooperativas
|
| 5 |
> integradas ao NCM, conectadas à atenção, ciclo d = a+b+c) · **Código**:
|
|
|
|
| 1 |
# r-21 — PROVAS DA TECNOLOGIA PENSAMENTO v0.5.0
|
| 2 |
|
| 3 |
+
> ⚠️ **ERRATA/SUPERSEDE — r-39 (v0.11):** T-P5 (cota heurística) foi SUBSTITUÍDA pela identidade exata Δy = π(ȳ_e − y_base) (erro 1,1e-16) com cota m_extra a priori — a fórmula proposta pela crítica (‖q‖·K·V/√d) é inválida (refutada no teste tp5_formula_deepseek_invalida); T-P6 foi re-escrita (r-24 já cobria treino conjunto). Ver T-P5′/T-P6′ em r-39.
|
| 4 |
+
|
| 5 |
> **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas
|
| 6 |
> e computacionais da tecnologia Pensamento (N-redes paralelas cooperativas
|
| 7 |
> integradas ao NCM, conectadas à atenção, ciclo d = a+b+c) · **Código**:
|
docs/memorias/r-23-provas-verificador-ncm-v060.md
CHANGED
|
@@ -1,5 +1,7 @@
|
|
| 1 |
# r-23 — PROVAS DO VERIFICADOR NCM v0.6.0 (substitui o oráculo — r-21 §3.1 fechado)
|
| 2 |
|
|
|
|
|
|
|
| 3 |
## 0. O QUE É PROVADO
|
| 4 |
|
| 5 |
O verificador de produção do Pensamento é a **confiança calibrada do próprio
|
|
|
|
| 1 |
# r-23 — PROVAS DO VERIFICADOR NCM v0.6.0 (substitui o oráculo — r-21 §3.1 fechado)
|
| 2 |
|
| 3 |
+
> ⚠️ **ERRATA/SUPERSEDE — r-40 (v0.11):** V-2 desta memória só vale com ECE medido NO CONJUNTO ACEITO; com ECE global o correto é P(erro|A) ≤ 1−τ_c + L₁/p_a (contraexemplo reproduzido no teste v2_linha: 0,2125 > 0,1173). Ver V-2′ em r-40 (relatorio_soundness com ece_aceito).
|
| 4 |
+
|
| 5 |
## 0. O QUE É PROVADO
|
| 6 |
|
| 7 |
O verificador de produção do Pensamento é a **confiança calibrada do próprio
|
docs/memorias/r-25-provas-moe-redirecionavel-v060.md
CHANGED
|
@@ -1,4 +1,7 @@
|
|
| 1 |
# r-25 — PROVAS DOS MoEs REDIRECIONÁVEIS COM ATENÇÃO PRÓPRIA v0.6.0
|
|
|
|
|
|
|
|
|
|
| 2 |
("MoEs codificação/decodificação redirecionáveis com Mecanismo de Atenção
|
| 3 |
próprio independente (paralelos) para as variantes anteriores JEPA e
|
| 4 |
Kohonen SOM" — pedido do usuário)
|
|
|
|
| 1 |
# r-25 — PROVAS DOS MoEs REDIRECIONÁVEIS COM ATENÇÃO PRÓPRIA v0.6.0
|
| 2 |
+
|
| 3 |
+
> ⚠️ **ERRATA/SUPERSEDE — r-41 (v0.11):** M-R5 desta memória usava arredondar+reparar — NÃO ótimo inteiro (contraexemplo: −4,2% de custo). Substituído pelo guloso marginal ótimo (argumento de troca, M-R5′) com o antigo mantido como oráculo degradado. Ver também errata da constante (31,794) em r-41.
|
| 4 |
+
|
| 5 |
("MoEs codificação/decodificação redirecionáveis com Mecanismo de Atenção
|
| 6 |
próprio independente (paralelos) para as variantes anteriores JEPA e
|
| 7 |
Kohonen SOM" — pedido do usuário)
|
docs/memorias/r-35-analise-provas-deepseek-v100.md
ADDED
|
@@ -0,0 +1,543 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# r-35 — ANÁLISE, PROVA E TESTE DAS CRÍTICAS DeepSeek (v0.10.0)
|
| 2 |
+
|
| 3 |
+
> **Coleção**: `memoria-khtst-rust` · **Objeto**: os 5 arquivos de crítica
|
| 4 |
+
> DeepSeek (`analise-critica-jepa`, `analise-critica-som`,
|
| 5 |
+
> `analise-critica-pensamento`, `analise-critica-ncm`,
|
| 6 |
+
> `aprimoramentos-arquitetura`) · **Código**: `src/{jepa,som4d,pensamento,
|
| 7 |
+
> verificador,quantizador,tokenizador,treino}.rs` · **Data**: 2026-11-01 ·
|
| 8 |
+
> **Método**: cada crítica foi (i) verificada simbolicamente ANTES do código,
|
| 9 |
+
> (ii) classificada [PROCEDENTE | PARCIAL | REFUTADA | CONCORDÂNCIA],
|
| 10 |
+
> (iii) respondida com teorema (∎), implementação aditiva quando cabível e
|
| 11 |
+
> critério de falsificação executável. Nada foi removido: toda melhoria é
|
| 12 |
+
> opt-in com default = comportamento v0.9.0.
|
| 13 |
+
|
| 14 |
+
---
|
| 15 |
+
|
| 16 |
+
## 0. RESUMO EXECUTIVO — TABELA DE VEREDITOS
|
| 17 |
+
|
| 18 |
+
| # | Crítica | Veredito | Resposta | Teste |
|
| 19 |
+
|---|---------|----------|----------|-------|
|
| 20 |
+
| J-1 | Prova do "não ponto crítico" falha por não-diferenciabilidade | **PARCIAL**: a prova v0.5.0 é INVÁLIDA, mas o mecanismo apontado (kink da dobradiça em std=0) está ERRADO — o kink é da RAIZ `std=√var`; a correção proposta (softplus) NÃO restaura diferenciabilidade w.r.t. z | Teo J-1′ (sela sharp + sempre-existe direção de descida); `ModoVariancia` 3 modos | j1a–j1e |
|
| 21 |
+
| J-2 | EMA correto | CONCORDÂNCIA | — (mantido) | j2 |
|
| 22 |
+
| J-3 | Riqueza do preditor é hipótese | CONCORDÂNCIA (já documentada r-20 §6.1) | documento + nota de extensão | demo 49 |
|
| 23 |
+
| S4-1 | Prova usa ‖·‖² para concluir sobre ‖·‖; contraexemplo | **PROCEDENTE** (contraexemplo reproduzido) | Teo S4-1′ (Φ do kernel incondicional + ponte Cauchy-Schwarz); `CriterioLote::MedianaGeometrica` (Weiszfeld, pedido da crítica); `CriterioQe` (pedido do aprimoramentos §3) | s41_contraexemplo, s41_phi, weiszfeld |
|
| 24 |
+
| T-1 | Cota ignora o fator 1/η | **PROCEDENTE** (confirmada NO CÓDIGO: η=0.1 hard-coded, docstring errada) | Teo T-1′ (`EQ_∞ ≤ δγ/(1−γ) + δ/η`); `eta_rastreio` configurável | t1_termo_um_sobre_eta |
|
| 25 |
+
| G-1 | Inserção GNG correta | CONCORDÂNCIA | — | gng_* |
|
| 26 |
+
| H-1(b) | 2QE+2R é cota "mais justa" | **PARCIAL**: válida, mas NÃO domina a nossa universalmente (só quando QE<4R); a MAIS justa da família é (√QE+√R)², faltando a ambas | Teo H-1′(b) com a cota ótima e a relação exata antiga = ótima + R | h1_cota_otima |
|
| 27 |
+
| H-1(c) | (c) é empírica, manter como conjectura | CONCORDÂNCIA (já registrada) — e MELHORADA: `reservar_grosso` torna (c) teorema quando ativo | Teo H-1′(c) | h1_cota_otima |
|
| 28 |
+
| T-P1 | Formalizar filtração | **PARCIAL**: σ(G_t)⊆σ(z_t) já implica 𝓕_t-mensurabilidade (a objeção é cosmética); mas o pedido de TESTE de causalidade é bom | teste contrafactual computacional (futuro re-amostrado ⇒ G_t inalterado) | tp1_causalidade |
|
| 29 |
+
| T-P5 | Derivar constante de Lipschitz explícita | **PARCIAL**: o pedido procede; a FÓRMULA proposta (`‖q‖·max‖k‖·max‖v‖/√d`) é INVÁLIDA (ignora a blindagem dos logits base) | Lema da massa extra (identidade exata β=α(1−m)) + Teo T-P5′ com cota computável a priori; `limites_gate()` | tp5_cota (MC 40 cfg), tp5_formula (refutação) |
|
| 30 |
+
| T-P6 | Fatoração depende de separação de perdas | **PARCIAL**: r-21 está DESATUALIZADA (v0.6.0+ tem treino conjunto) — não é o caso do código atual; a garantia vigente é a do r-24 (PCGrad, taxa_conflito medida 0.000) | errata r-21 + Teo T-P6′ (bound de interferência via projeção PCGrad) | taxa_conflito_pcgrad (fase C) |
|
| 31 |
+
| A.0 | Quantificar viés do STE ou trocar por GSQ | **PARCIAL**: GSQ JÁ EXISTE no código (modo `gsq_rco`, Teo A.4); o viés agora é quantificado | Teo A.0′ (viés ≤ M·Δ/2 sob dither; STE = gradiente exato do linearizado) | a0_vies_ste |
|
| 32 |
+
| A.1 | Generalizar para codebooks não-ortonormais via Welch | **PARCIAL**: o Cor. A.1.2 (tight frames) e o monitor δ_ort JÁ cobriam parte; agora com coerência μ medida e degradação provada | Teo A.1′ (contração degrada por (1+(K−1)μ), Gershgorin no Gram); `coerencia()` por nível | a1_coerencia |
|
| 33 |
+
| A.2 | Nested dropout correto | CONCORDÂNCIA | — | — |
|
| 34 |
+
| B.1 | Penalidade λ_TC·TC na perda do GERADOR | **REFUTADA na forma proposta** (Teo B.1-R: no-ópera no ótimo do CE — o gap é propriedade de q_T, não de φ; penalizar amostras do modelo DESVIA do ótimo e piora o KL) + **correção de rota** (Teo B.1-T: a alavanca é o TOKENIZADOR) | `tc_intra_nivel()` (plug-in Miller–Madow, telemetria V6) | medição fase A (script 74) |
|
| 35 |
+
| C.3 | Formalizar corrupção = DRO | **PARCIAL**: ao formalizar, a parte (iii) do n-02 REVELA-SE ERRADA (média sobre κ ≠ sup sobre conv(κ) — linearidade em η dá ≤, não =) | Teo C.3′ (média ≤ sup com igualdade sse risco constante na família; ponte randomized-smoothing; cobertura (ii) mantida) | errata n-02 |
|
| 36 |
+
| §3 verificador | Testar bisseção nos limites 1/8 e 8 | PROCEDENTE (pedido de teste) | casos de borda exatos + caso misto quase-plano | n5, n5b |
|
| 37 |
+
|
| 38 |
+
**Bugs encontrados no processo** (a própria cadeia de falsificação pedida
|
| 39 |
+
pela crítica): **v100-1** — a máscara de "covariância fora-diagonal" do
|
| 40 |
+
`perda_vc` tinha 1s NA diagonal desde a v0.5.0 (o termo computava `Σvar²/2d`,
|
| 41 |
+
não `‖offdiag(Cov)‖²`; exposto pelo teste de compatibilidade j1e; corrigido);
|
| 42 |
+
**v100-2** — meu primeiro `limites_gate` computava `exp(Δs·E)` em vez de
|
| 43 |
+
`E·exp(Δs)` (capturado pelo próprio teste Monte Carlo antes de qualquer uso).
|
| 44 |
+
|
| 45 |
+
---
|
| 46 |
+
|
| 47 |
+
## 1. JEPA — crítica `analise-critica-jepa`
|
| 48 |
+
|
| 49 |
+
### 1.1 O que a crítica acerta (e o que erra)
|
| 50 |
+
|
| 51 |
+
**Acerta (a substância):** a prova v0.5.0 do J-1 terminava com
|
| 52 |
+
|
| 53 |
+
> "o gradiente de V no colapso é `∂V/∂std_j = −2γ ≠ 0` — o colapso não é
|
| 54 |
+
> ponto crítico de V, portanto não é ponto crítico de L"
|
| 55 |
+
|
| 56 |
+
Este argumento é **inválido**: `∂V/∂std ≠ 0` não implica `∇_z V ≠ 0`. A
|
| 57 |
+
cadeia `z → var_j(z) → std_j → V` quebra em DOIS pontos no colapso:
|
| 58 |
+
(i) `∇_z var_j = (2/n)(z_{ij} − \bar z_j) = 0` (a variância é estacionária
|
| 59 |
+
no seu mínimo 0); (ii) `∂std/∂var = 1/(2√var) → ∞`. O produto é `−∞·0`,
|
| 60 |
+
indefinido. **Medido** (teste j1a): a retropropagação da `perda_vc` no
|
| 61 |
+
colapso exato produz **64/64 gradientes NaN** nos 64 coeficientes de z —
|
| 62 |
+
o gradiente NÃO é `−2γ`, é indefinido. A crítica procede.
|
| 63 |
+
|
| 64 |
+
**Erra (o mecanismo):** a crítica localiza o kink na dobradiça
|
| 65 |
+
`max(0, γ−s)²` em `s = 0`. Isso é factualmente errado: `h(s) = max(0,(γ−s)²)`
|
| 66 |
+
é **C¹ em todo ℝ** — em `s = γ` as derivadas laterais são `−2(γ−γ)=0` e
|
| 67 |
+
`0` (contínuas); em `s = 0` (domínio `s ≥ 0`) `h'(0) = −2γ` existe. O
|
| 68 |
+
kink está na **RAIZ** `s = √var` em `var = 0` (declive → ∞).
|
| 69 |
+
|
| 70 |
+
**Erra (a correção proposta):** substituir a dobradiça por
|
| 71 |
+
`softplus(k(γ−std))²` **não restaura a diferenciabilidade w.r.t. z**:
|
| 72 |
+
a composição continua passando por `std = √var`. Ao longo de
|
| 73 |
+
`z(t) = c + t·u` (u centrado), `var_j(t) = t²s_j²(u)` e
|
| 74 |
+
`std_j = |t|·s_j`, logo `V_sp` é função de `|t|` com derivadas laterais
|
| 75 |
+
`D⁺ = −C_sp` e `D⁻ = +C_sp` — o gradiente w.r.t. z **não existe** no
|
| 76 |
+
colapso (Teo J-1′-iii abaixo; medido no teste j1d: D⁺=−22,7 vs
|
| 77 |
+
D⁻=+22,7 com C_sp teórico 22,7).
|
| 78 |
+
|
| 79 |
+
### 1.2 Teo J-1′ (o teorema correto — colapso é sela sharp)
|
| 80 |
+
|
| 81 |
+
**Enunciado.** Seja `L(z) = L_pred(z) + λ·V(z)` com `λ>0, γ>0, n≥2` e
|
| 82 |
+
`V` o regularizador VC (hinge de variância + covariância fora-diagonal).
|
| 83 |
+
No colapso total `z_i = c ∀i`:
|
| 84 |
+
|
| 85 |
+
**(i)** `∇_z V` não existe (kink da raiz; Clarke-subdiferencial contém 0
|
| 86 |
+
— o colapso É "crítico" no sentido de Clarke, e a afirmação v0.5.0 de
|
| 87 |
+
"não ponto crítico" é insustentável nos dois formalismos clássicos);
|
| 88 |
+
|
| 89 |
+
**(ii)** para toda direção **centrada** `u ≠ 0` (i.e. `Σ_i u_{ij} = 0 ∀j`),
|
| 90 |
+
a derivada lateral de V existe e vale
|
| 91 |
+
```
|
| 92 |
+
D⁺V(u) = −(2γ/d)·Σ_j s_j(u), s_j(u) = √(Var_i(u_ij)) ,
|
| 93 |
+
```
|
| 94 |
+
estritamente negativa se algum `s_j > 0` — **V desce LINEARMENTE em |t|**
|
| 95 |
+
ao afastar-se do colapso (sela sharp; escape de 1ª ordem, não 2ª);
|
| 96 |
+
|
| 97 |
+
**(iii)** sempre existe direção de descida para a perda COMPLETA: seja
|
| 98 |
+
`G = ∇_z L_pred` (existe e é finito). Como `n ≥ 2`, o espaço das matrizes
|
| 99 |
+
centradas tem dimensão `d(n−1) ≥ 1`; tome `u` centrada, não-nula, com
|
| 100 |
+
`u ⊥ G`. Então `D⁺L(u) = ⟨G,u⟩ − (2λγ/d)Σ_j s_j(u) = −(2λγ/d)Σ_j s_j(u) < 0`.
|
| 101 |
+
|
| 102 |
+
Logo **o colapso total não é mínimo local de L** (em z-espaço; a
|
| 103 |
+
transferência para θ-espaço exige o jacobiano do codificador não-degenerado
|
| 104 |
+
na direção u — a hipótese de riqueza padrão, cf. J-3). ∎
|
| 105 |
+
|
| 106 |
+
**Prova.** (ii): com `z(t) = c + tu`, `var_j(t) = t²·s_j²(u)` exato
|
| 107 |
+
(u centrada elimina o termo cruzado com a média). Para `|t|` pequeno o
|
| 108 |
+
suficiente (`|t|·s_j < γ ∀j`), `V_var(t) = (1/d)Σ_j (γ−|t|s_j)² =
|
| 109 |
+
γ² − (2|t|γ/d)Σs_j + O(t²)`; o termo de covariância é **quadrático** em t
|
| 110 |
+
(`centr(t) = t·u` ⇒ `Cov ∝ t²`) e não contribui na 1ª ordem. A derivada a
|
| 111 |
+
direita em `t→0⁺` é `−(2γ/d)Σ_j s_j`.
|
| 112 |
+
(iii): ortogonalidade zera o termo linear de `L_pred` (que é C¹); resta o
|
| 113 |
+
termo negativo de (ii).
|
| 114 |
+
(i): computacional — j1a. ∎
|
| 115 |
+
|
| 116 |
+
**Corolário J-1′.1 (por que a dobradiça sharp é FEATURE).** O escape do
|
| 117 |
+
colapso é **linear** em `|t|` com a dobradiça (sela sharp); com a raiz
|
| 118 |
+
suavizada `std_ε = √(var+ε)` o colapso vira ponto crítico genuíno
|
| 119 |
+
(`∇_z V_ε = 0` exato — medido j1c) e o escape passa a ser **quadrático**
|
| 120 |
+
(`V_ε(t) − V_ε(0) = g'(0)·t²s² + O(t⁴)` com `g'(0) = −(γ−√ε)/√ε < 0`).
|
| 121 |
+
Ou seja: a não-diferenciabilidade que a crítica quer eliminar é
|
| 122 |
+
precisamente o mecanismo de fuga de 1ª ordem. A escolha de engineering é
|
| 123 |
+
mantê-la como default (SOTA VICReg canônico) e oferecer os modos suaves
|
| 124 |
+
como opt-in documentado.
|
| 125 |
+
|
| 126 |
+
### 1.3 Implementação (aditiva)
|
| 127 |
+
|
| 128 |
+
`ModoVariancia { Dobradica (default, bit-a-bit v0.9.0), RaizSuavizada{ε},
|
| 129 |
+
Softplus{k} }` em `NucleoJepa::perda_vc`, configurável por
|
| 130 |
+
`definir_modo_variancia` (Rust) e `modo_variancia` no cfg JSON das demos
|
| 131 |
+
(`treinar_jepa`/`treinar_jepa_adaptativa`). Menu honesto:
|
| 132 |
+
|
| 133 |
+
| modo | diferenciável em z? | escape do colapso | viés vs dobradiça |
|
| 134 |
+
|------|--------------------|-------------------|-------------------|
|
| 135 |
+
| Dobradica | NÃO (medida zero em f32) | linear (sharp) | 0 (referência) |
|
| 136 |
+
| RaizSuavizada | SIM (C^∞) | quadrático | `≤ 2γ√ε·d` (ε=1e-12 ⇒ ~1e-6γ) |
|
| 137 |
+
| Softplus | **NÃO** (j1d) | linear | nunca zera (resíduo `e^{k(γ−std)}`) |
|
| 138 |
+
|
| 139 |
+
**Medições (testes):** j1a 64/64 NaN; j1b slope medido −1,98 vs teórico
|
| 140 |
+
−2,00 (3ª ordem); j1c gradiente 0 exato + queda quadrática; j1d
|
| 141 |
+
D⁺=−22,66 / D⁻=+22,66 (C_sp=22,66 — divergem por sinal ⇒ sem gradiente);
|
| 142 |
+
j1e Dobradica = fórmula v0.9.0 (validação da compatibilidade que EXPÔS o
|
| 143 |
+
bug v100-1, §6).
|
| 144 |
+
|
| 145 |
+
### 1.4 J-2 e J-3
|
| 146 |
+
|
| 147 |
+
**J-2**: concordância — prova e teste mantidos (`teste_j2_ema_ponto_fixo`).
|
| 148 |
+
**J-3**: a hipótese de riqueza do preditor já era limitação documentada
|
| 149 |
+
(r-20 §6.1). A sugestão ("capacidade controlada") mudaria a semântica do
|
| 150 |
+
JEPA (o preditor rico é desejável); o que acrescentamos é o registro
|
| 151 |
+
honesto de que a decomposição J-3 vale no ínfimo da classe do preditor e
|
| 152 |
+
a `perda_pred` medida é cota superior da variância condicional. Extensão
|
| 153 |
+
natural (não bloqueante): estimador não-paramétrico da variância
|
| 154 |
+
condicional como oráculo de gap — anotada como débito.
|
| 155 |
+
|
| 156 |
+
---
|
| 157 |
+
|
| 158 |
+
## 2. SOM — crítica `analise-critica-som`
|
| 159 |
+
|
| 160 |
+
### 2.1 Teo S4-1′ (o teorema reparado, incondicional)
|
| 161 |
+
|
| 162 |
+
**Enunciado.** Fixe a atribuição `a: D→G` e o kernel `w(b,g)=e^{−d_G(g,b)²/2σ²}`.
|
| 163 |
+
Defina a **Φ do kernel** (o objetivo real do passo de lote):
|
| 164 |
+
```
|
| 165 |
+
Φ(P) = Σ_g Σ_i w(a(x_i), g)·‖x_i − p_g‖²
|
| 166 |
+
```
|
| 167 |
+
e o passo `p'_g = (1−η)p_g + η·m_g` com `m_g = Σ_i w(a(x_i),g)x_i / Σ_i w(a(x_i),g)`.
|
| 168 |
+
Então:
|
| 169 |
+
|
| 170 |
+
**(a)** `Φ(P') ≤ Φ(P)` — para TODO σ, TODO η ∈ [0,1], sem regime;
|
| 171 |
+
**(b)** a QE (não-quadrada, min sobre células) NÃO é controlada por este
|
| 172 |
+
argumento: `QE(a,P)² ≤ Φ(P)/N` (Cauchy-Schwarz) dá apenas cota pela raiz
|
| 173 |
+
de um funcional não-crescente; o contraexemplo da crítica procede (QE
|
| 174 |
+
0→5 medido, teste s41_contraexemplo);
|
| 175 |
+
**(c)** com `MedianaGeometrica` (Weiszfeld ponderado), o MESMO teorema vale
|
| 176 |
+
para o objetivo NÃO-quadrado `Ψ(P) = Σ_g Σ_i w·‖x_i − p_g‖` (a norma é
|
| 177 |
+
convexa!) — e no contraexemplo a QE é preservada (0→0, medido).
|
| 178 |
+
|
| 179 |
+
**Prova.** (a): para cada g, `Φ_g(p) = Σ_i w(a(x_i),g)‖x_i − p‖²` é convexa
|
| 180 |
+
em p (soma de normas quadradas) e `m_g` é o SEU minimizador exato sobre
|
| 181 |
+
todo `R^d` (estacionariedade: `∇Φ_g(m_g) = −2Σ w_i(x_i − m_g) = 0` pela
|
| 182 |
+
definição da média ponderada — sem aproximação, sem "regime σ≤σ*" da v0.5.0).
|
| 183 |
+
Mistura convexa: `Φ_g(p'_g) ≤ (1−η)Φ_g(p_g) + ηΦ_g(m_g) ≤ Φ_g(p_g)`.
|
| 184 |
+
Soma em g.
|
| 185 |
+
(b): o erro da prova v0.5.0 foi exatamente trocar `Φ` por `QE`: a
|
| 186 |
+
convexidade controla o quadrado; `QE ≤ √(Φ_ própria/N)` requer o peso
|
| 187 |
+
próprio `w(g,g)=1`, mas a RE-ATRIBUIÇÃO muda o min. O contraexemplo
|
| 188 |
+
{x₁=0, x₂=10} com kernel uniforme: `m₁=m₂=5`, `p'=(5,5)`, QE 0→5.
|
| 189 |
+
(c): `Ψ_g(p) = Σ w_i‖x_i−p‖` é convexa (soma de normas) e a mediana
|
| 190 |
+
geométrica ponderada é seu minimizador global (Weiszfeld desce
|
| 191 |
+
estritamente exceto em pontos de dados, que são pontos fixos — Vardi &
|
| 192 |
+
Zhang 2000); a mistura convexa repete o argumento. No contraexemplo,
|
| 193 |
+
todo ponto do segmento (0,10) minimiza `Ψ` (mediana não-únima) ⇒ o
|
| 194 |
+
protótipo NÃO se move ⇒ QE preservada. ∎
|
| 195 |
+
|
| 196 |
+
**Nota honesta sobre (c):** a mediana preserva a QE da atribuição
|
| 197 |
+
congelada, mas **organiza a grade mais devagar** (não puxa os protótipos
|
| 198 |
+
na direção dos vizinhos com o mesmo peso da média — no limite σ→0 os dois
|
| 199 |
+
criterios coincidem com o k-means/k-medians clássicos). É por isso que a
|
| 200 |
+
média permanece o DEFAULT e a mediana é opt-in (`criterio_lote`):
|
| 201 |
+
"adição com prova", não substituição. A/B em dados reais no §8.
|
| 202 |
+
|
| 203 |
+
### 2.2 Teo T-1′ (cota de rastreio com o fator 1/η)
|
| 204 |
+
|
| 205 |
+
**Enunciado.** Com `p ← p + η(m − p)` e centróide-alvo `m` derivando δ por
|
| 206 |
+
passo, o lag estacionário do protótipo satisfaz `L = δ + (1−η)L`, logo
|
| 207 |
+
```
|
| 208 |
+
EQ_∞ ≤ δ·γ/(1−γ) + δ/η
|
| 209 |
+
```
|
| 210 |
+
(o 1º termo é o atraso do filtro exponencial da janela; o 2º é o atraso
|
| 211 |
+
do EMA do PROTÓTIPO — ausente da prova v0.5.0, que somava apenas δ).
|
| 212 |
+
|
| 213 |
+
**Prova.** Regime estacionário com lag constante L: `p_t = m_t − L`;
|
| 214 |
+
`p_{t+1} = p_t + η(m_t − p_t) = m_t − (1−η)L`; e `m_{t+1} = m_t + δ`.
|
| 215 |
+
Igualando `p_{t+1} = m_{t+1} − L'`: `L' = δ + (1−η)L`; fixpoint
|
| 216 |
+
`L* = δ/η`. Soma-se o atraso `δγ/(1−γ)` do próprio centróide
|
| 217 |
+
(`Σkγ^k = γ/(1−γ)²`, `Σγ^k = 1/(1−γ)`). ∎
|
| 218 |
+
|
| 219 |
+
**Confirmação no código (crítica procede em dobro):** o `passo` do T-SOM
|
| 220 |
+
tinha `eta = 0.1` hard-coded e o docstring afirmava `≤ δ/(1−γ)` —
|
| 221 |
+
subestimando o lag por `δ·(1/0,1 − 1) = 9δ`. **Medido** (t1_termo):
|
| 222 |
+
lag(η=0,1) − lag(η=1) ∈ banda prevista [2δ, 12δ] com δ=0,5 (a previsão
|
| 223 |
+
exata 4,5δ é atenuada pela janela finita de 32 amostras). Correção:
|
| 224 |
+
`eta_rastreio` configurável (default 0,1 = compatibilidade) + docstring
|
| 225 |
+
+ teste.
|
| 226 |
+
|
| 227 |
+
### 2.3 H-1′ (b) — a cota ótima da família e as duas frouxas
|
| 228 |
+
|
| 229 |
+
**Enunciado.** `QE_hier ≤ (√QE_grosso + √R_fino)²` (triangular +
|
| 230 |
+
Cauchy-Schwarz: `E‖x−p‖² ≤ E(‖x−q‖+‖q−p‖)² ≤ QE + R + 2√(QE·R)`).
|
| 231 |
+
Além disso:
|
| 232 |
+
```
|
| 233 |
+
cota_v0.5.0 = QE + 2R + 2√(QE·R) = ótima + R (frouxa por exatamente R)
|
| 234 |
+
2QE + 2R (DeepSeek) ≥ ótima (AM-GM), com igualdade sse QE=R
|
| 235 |
+
```
|
| 236 |
+
A alternativa da crítica é mais justa que a nossa **sse QE < 4R** ( região
|
| 237 |
+
onde `2QE+2R < QE+2R+2√(QR) ⟺ QE < 4√(QR)... ⟺ √QE < 2√R`), e é dominada
|
| 238 |
+
pela ótima em todo o domínio. **Medido** (h1_cota): QE_hier 0,045 ≤ ótima
|
| 239 |
+
0,603 ≤ {2QE+2R 1,101; antiga 0,797}; relações exatas verificadas a 1e-9. ∎
|
| 240 |
+
|
| 241 |
+
### 2.4 H-1′ (c) — da conjectura ao teorema (opt-in)
|
| 242 |
+
|
| 243 |
+
A parte (c) era registrada como regularidade empírica (a re-semeadura de
|
| 244 |
+
células vazias podia remover `q_c` do sub-mapa). Com
|
| 245 |
+
`reservar_grosso: bool` (slot fino 0 = cópia permanente de `q_c`, nunca
|
| 246 |
+
atualizado/re-semeado), o BMU fino pode SEMPRE escolher `q_c`, logo
|
| 247 |
+
`QE_hier ≤ QE_grosso` vira **teorema** quando ativo (medido: 0,0445 ≤
|
| 248 |
+
0,5498 ✓, e `finos[g][0] == q_c` verificado). Default false =
|
| 249 |
+
comportamento v0.9.0 bit-a-bit (o slot custa 1/n_f da capacidade fina —
|
| 250 |
+
troca documentada, não imposta).
|
| 251 |
+
|
| 252 |
+
---
|
| 253 |
+
|
| 254 |
+
## 3. PENSAMENTO — crítica `analise-critica-pensamento`
|
| 255 |
+
|
| 256 |
+
### 3.1 T-P1′ (causalidade contrafactual computacional)
|
| 257 |
+
|
| 258 |
+
A objeção ("definir 𝓕_t e mostrar mensurabilidade") é cosmética: `G_t =
|
| 259 |
+
1[conf(z_t) < τ_c]` com `conf` contínua já dá `σ(G_t) ⊆ σ(z_t) ⊆ 𝓕_t`. O
|
| 260 |
+
valor agregado da crítica é o **teste de causalidade** pedido
|
| 261 |
+
(aprimoramentos §2): implementamos o contrafactual computacional —
|
| 262 |
+
`conf(z_t)` e `G_t` são recalculados com o FUTURO (`z_{t+1:T}`)
|
| 263 |
+
re-amostrado de distribuição adversária; invariância bit-a-bit exigida
|
| 264 |
+
(medido: diferença 0,0 em todos os t; e o contrafático MUDA os futuros —
|
| 265 |
+
o teste não é vazio). Isso formaliza a filtração da maneira que o projeto
|
| 266 |
+
considera honesta: **não por um tipo `Filtracao` no código (o
|
| 267 |
+
aprimoramentos sugere, mas um tipo não prova nada sobre a SEMÂNTICA), e
|
| 268 |
+
sim por um teste de falsificação que qualquer regressão de causalidade
|
| 269 |
+
quebraria**.
|
| 270 |
+
|
| 271 |
+
### 3.2 T-P5′ — Lema da massa extra e a cota válida
|
| 272 |
+
|
| 273 |
+
**Lema (identidade exata).** Sejam `α = softmax(s_base)`, `β =
|
| 274 |
+
softmax([s_base; s_extra])`. Então para toda chave base j:
|
| 275 |
+
```
|
| 276 |
+
β_j = α_j·(1 − m_extra), m_extra = Σ_{j∈extra} β_j = Z_e/(Z_b+Z_e)
|
| 277 |
+
```
|
| 278 |
+
e portanto `Δ = y_ext − y_base = Σ_{j∈extra}β_j v_j − m_extra·y_base`.
|
| 279 |
+
|
| 280 |
+
**Prova.** `β_j = e^{s_j}/(Z_b+Z_e) = α_j·Z_b/(Z_b+Z_e)` e
|
| 281 |
+
`Z_b/(Z_b+Z_e) = 1 − m_extra`. Somando `y_ext = Σ_{base}β_jv_j +
|
| 282 |
+
Σ_{extra}β_jv_j = (1−m_extra)y_base + Σ_{extra}β_jv_j`. ∎
|
| 283 |
+
|
| 284 |
+
**Teo T-P5′ (cota a priori).** Por linha de query,
|
| 285 |
+
```
|
| 286 |
+
‖Δ‖ ≤ m_extra·(‖y_base‖ + V_e_max) ≤ m_extra·(V_b_max + V_e_max)
|
| 287 |
+
m_extra ≤ min(1, E·e^{s̄_e − s_b}) [Z_e ≤ E·e^{s̄_e}, Z_b ≥ e^{s_b}]
|
| 288 |
+
```
|
| 289 |
+
com `s̄_e` = logit extra máximo e `s_b` = logit base máximo DA LINHA.
|
| 290 |
+
Todos os fatores computáveis SEM rodar a atenção combinada. Implementado
|
| 291 |
+
em `limites_gate` (retorna Δ medido, cota, m_extra medido/cota, e a
|
| 292 |
+
fórmula da crítica para contraste). **Medido**: cota domina o Δ em 40/40
|
| 293 |
+
configurações aleatórias (escalas 1 e 3) e a cota de m_extra domina a
|
| 294 |
+
massa medida. ∎
|
| 295 |
+
|
| 296 |
+
**Refutação da fórmula proposta** (`L = ‖q‖·max‖k_extra‖·max‖v_extra‖/√d`):
|
| 297 |
+
ela ignora a **blindagem dos logits base**. Contraexemplo (teste
|
| 298 |
+
tp5_formula): base com 4 chaves anti-alinhadas (logit −60 cada), 1 chave
|
| 299 |
+
extra ortogonal a q (logit 0), d=4096, `‖q‖=‖k_e‖=‖v_e‖=1`. Toda a massa
|
| 300 |
+
vai para a chave extra (`m_extra→1`, Δ≈1) enquanto a fórmula dá
|
| 301 |
+
`1·1·1/64 = 0,016` — **violada por 64×**. A fórmula também não zera
|
| 302 |
+
quando `q⊥k_e` com base saturada. (A fórmula SERIA um majorante de
|
| 303 |
+
`m_extra·V_e` apenas sob hipótese implausível de logit base ≥ 0 e sem
|
| 304 |
+
efeito de normalizador — não é cota em geral.)
|
| 305 |
+
|
| 306 |
+
### 3.3 T-P6′ — fatoração sob treino conjunto (errata de r-21)
|
| 307 |
+
|
| 308 |
+
A crítica diz "a garantia depende de separação de perdas... se o treino
|
| 309 |
+
conjunto for implementado no futuro". **O treino conjunto JÁ EXISTE desde
|
| 310 |
+
a v0.6.0** (r-24: fases C, C-1..C-5) — r-21 §T-P6 está desatualizado
|
| 311 |
+
(errata aplicada). A garantia vigente não é "perdas separadas" e sim:
|
| 312 |
+
(i) a fatoração do GERADOR permanece exata como expressão de p_φ
|
| 313 |
+
(a interferência só ocorre pelo gradiente); (ii) o fluxo
|
| 314 |
+
Pensamento→backbone passa pela projeção **PCGrad** (r-24, taxa_conflito
|
| 315 |
+
medida 0.000 na fase C real): componentes conflitantes são ortogonalizadas
|
| 316 |
+
antes do passo, limitando a interferência adversa a
|
| 317 |
+
`⟨g_gen, g_pens⟩⁺ ≤ ‖g_gen‖‖g_pens‖` — e a medição empírica mostra o
|
| 318 |
+
caso benigno. Documentado em r-21 (errata) com o apontamento correto
|
| 319 |
+
para r-24; sem alteração de código (o mecanismo existe e é medido).
|
| 320 |
+
|
| 321 |
+
---
|
| 322 |
+
|
| 323 |
+
## 4. NCM — crítica `analise-critica-ncm`
|
| 324 |
+
|
| 325 |
+
### 4.1 Teo A.0′ (viés do STE quantificado)
|
| 326 |
+
|
| 327 |
+
A crítica sugere "quantificar o viés em termos de β e da distribuição dos
|
| 328 |
+
resíduos, ou substituir STE por GSQ". O GSQ **já existe** como modo
|
| 329 |
+
`gsq_rco` do quantizador (gradiente exato do relaxamento, Teo A.4/D.4 —
|
| 330 |
+
a própria crítica reconheceria). A quantificação do viés:
|
| 331 |
+
|
| 332 |
+
**(i) (semântica exata).** `ĝ_STE(z) = ∇_w [ L(q(z)) + ⟨∇L(q(z)), w−q(z)⟩ ]|_{w=z}` —
|
| 333 |
+
o STE é o gradiente EXATO da perda linearizada em torno da quantização
|
| 334 |
+
(zero de viés para o objetivo linearizado; é por isso que "o gradiente
|
| 335 |
+
vê o quantizador como identidade").
|
| 336 |
+
|
| 337 |
+
**(ii) (viés vs objetivo ditherizado).** Sob dither uniforme `u ~ U[−Δ/2,Δ/2]^d`
|
| 338 |
+
com células de largura Δ e `L` de Hessiano M-Lipschitz,
|
| 339 |
+
```
|
| 340 |
+
| E_u[ĝ_STE(z+u)]_j − ∂_j F(z) | ≤ M·Δ/2, F(z) = E_u[L(q(z+u))]
|
| 341 |
+
```
|
| 342 |
+
**Prova (1D, exata):** com níveis nos centros das células, `E_u[q(z+u)] = z`
|
| 343 |
+
(Gray–Stockham) ⇒ `E_u[ĝ_STE(z+u)] = 2(z−a)` (perda quadrática); e
|
| 344 |
+
`F'(z) = [L(q(z+Δ/2)) − L(q(z−Δ/2))]/Δ`. Com z a offset s do centro:
|
| 345 |
+
`F' = 2ℓ_k + Δ·sign(s) − 2a` e `E[ĝ] = 2ℓ_k + 2s − 2a`; diferença
|
| 346 |
+
`= 2s − Δ·sign(s) ∈ (−Δ, Δ)`; com M=2 ⇒ |viés| < M·Δ/2. **Medido**
|
| 347 |
+
(a0_vies): viés ≤ 0,5 nos 8 offsets com cota 0,5 + ruído MC. ∎
|
| 348 |
+
|
| 349 |
+
Leitura prática: o dither de largura Δ controla o viés a 1ª ordem; sem
|
| 350 |
+
dither, o STE aponta na direção do gradiente no PONTO QUANTIZADO (que é o
|
| 351 |
+
que o commitment `β‖sg[r]−z‖²` em seguida reconcilia puxando z para r —
|
| 352 |
+
os dois termos em conjunto implementam o gradiente do linearizado +
|
| 353 |
+
ancoragem, o "controlado pelo commitment" do n-02 agora com constante
|
| 354 |
+
explícita).
|
| 355 |
+
|
| 356 |
+
### 4.2 Teo A.1′ (não-ortonormalidade via coerência de Welch)
|
| 357 |
+
|
| 358 |
+
**Enunciado.** Sejam `û_k` as linhas normalizadas do codebook e
|
| 359 |
+
`μ = max_{i≠j}|⟨û_i,û_j⟩|` a coerência. Os autovalores do Gram `UᵀU`
|
| 360 |
+
estão em `[1−(K−1)μ, 1+(K−1)μ]` (Gershgorin), logo o Parseval do Teo A.1
|
| 361 |
+
vira `|Σ_k⟨z,û_k⟩² − ‖P_C z‖²| ≤ (K−1)μ‖z‖²` e a contração degrada
|
| 362 |
+
continuamente:
|
| 363 |
+
```
|
| 364 |
+
‖z − r*‖² ≤ ‖z−P_Cz‖² + (1 − 1/K + (K−1)μ)·‖P_Cz‖² [escala ótima ajustada]
|
| 365 |
+
```
|
| 366 |
+
Para K > d, `μ ≥ √((K−d)/(d(K−1)))` (Welch) — piso inatingível abaixo
|
| 367 |
+
disso; para K ≤ d com RCO, μ ≈ δ_ort → 0. **Medido**: `coerencia()`
|
| 368 |
+
reporta μ por nível; no codebook Stiefel 16×32 recém-inicializado
|
| 369 |
+
μ = 0,000000 com δ_ort = 3,7e-7 (a implementação `limite_welch` valida a
|
| 370 |
+
fórmula: welch(128,64) = √(1/127) exato). No treino real (script 74),
|
| 371 |
+
μ_max entra na telemetria da fase A junto de δ_ort. ∎
|
| 372 |
+
|
| 373 |
+
### 4.3 Teo B.1-R (REFUTAÇÃO da penalidade λ_TC no gerador) e B.1-T (rota correta)
|
| 374 |
+
|
| 375 |
+
**B-1R.** Fixe o tokenizador T. Então `TC(c_ℓ|c_{<ℓ})` sob `q_T` é
|
| 376 |
+
CONSTANTE w.r.t. φ. O ótimo do CE por posição é a marginal condicional
|
| 377 |
+
`p* = q(c_{ℓ,i}|c_{<ℓ})` (gibbs por posição) e o gap de classe é
|
| 378 |
+
`ΣE[TC]` (Teo B.3(i) do n-02) — INDEPENDENTE de φ. Logo:
|
| 379 |
+
(i) se o termo `λ_TC·TĈ` mede o TC dos DADOS, é um SHIFT CONSTANTe do
|
| 380 |
+
objetivo: mesmo argmin, **no-ópera**;
|
| 381 |
+
(ii) se mede TC das AMOSTRAS DO MODELO (diferenciável via relaxamento), o
|
| 382 |
+
ótimo penalizado desvia-se das marginais de q_T por O(λ_TC) e o
|
| 383 |
+
`KL(q_T‖p)` AUMENTA em O(λ_TC²) — a penalidade **piora a propriedade de
|
| 384 |
+
MLE exato** (B.1) que é a vantagem central do NCM. ∎
|
| 385 |
+
|
| 386 |
+
**B-1T (a alavanca correta).** Reduzir `E[TC]` do lado do TOKENIZADOR
|
| 387 |
+
reduz o gap de classe EXATAMENTE (Δgap = ΔΣE[TC]): é lá que a penalidade
|
| 388 |
+
tem gradiente significativo (via GSQ, os assignments têm gradiente). O que
|
| 389 |
+
foi implementado agora: **medição** (`tc_intra_nivel`, plug-in por pares
|
| 390 |
+
com correção Miller–Madow `−(K−1)²/(2m)`, clamped em 0) como telemetria
|
| 391 |
+
da fase A (verificação V6 do n-04 — linha de base para decidir se a
|
| 392 |
+
penalidade vale o custo). **A penalidade em si fica ADIADA com prova de
|
| 393 |
+
justificativa**: o estimador plug-in por pares com m~256 amostras e K=64
|
| 394 |
+
tem viés residual O(K²/m) que a correção MM não remove totalmente, e um
|
| 395 |
+
penalizador enviesado pode empurrar o tokenizador para artefatos; a
|
| 396 |
+
decisão de implementar exige a linha de base medida primeiro (dados no §8).
|
| 397 |
+
Honestidade: a crítica acertou o DIAGNÓSTICO (o gap é a TC); errou a
|
| 398 |
+
PRESCRIÇÃO (o local da penalidade).
|
| 399 |
+
|
| 400 |
+
### 4.4 Teo C.3′ (errata da parte (iii) do n-02)
|
| 401 |
+
|
| 402 |
+
A parte (iii) do Teo C.3 afirmava `R_κ(φ) = sup_{η∈conv(κ)} E_η[ℓ]` "quando
|
| 403 |
+
κ é convexa em distribuição — troca direta de expectativa e sup em função
|
| 404 |
+
afim na medida". **A troca é inválida**: `E_η[ℓ] = ∫ℓdη` é LINEAR em η, e
|
| 405 |
+
para função linear a média sobre a família é o valor no baricentro —
|
| 406 |
+
```
|
| 407 |
+
R_κ(φ) = E_{η∼π}[R(η)] ≤ sup_{η∈conv(κ)} R(η) = max_{vértices} R(η)
|
| 408 |
+
```
|
| 409 |
+
com igualdade **sse** o risco for constante no suporte de π (ex.: família
|
| 410 |
+
simétrica com risco invariante). Corrupção com κ aleatório otimiza a
|
| 411 |
+
robustez MÉDIA — um majorante fraco do DRO. O que permanece verdadeiro:
|
| 412 |
+
(i) o lema de Lipschitz (i) e a cobertura/dominação (ii) — a ponte
|
| 413 |
+
operacional contra exposure bias; e a leitura correta de (iii): treinar
|
| 414 |
+
com κ amostrado aleatoriamente é um **surrogate tractável** do DRO
|
| 415 |
+
(minimiza cota inferior do pior caso; minimax real exigiria κ adversarial
|
| 416 |
+
— escalando ρ como currículo, o treino aproxima o sup por fora).
|
| 417 |
+
Errata aplicada ao n-02 §C.3 com remissão a este teorema. ∎
|
| 418 |
+
|
| 419 |
+
### 4.5 A.2 — concordância; verificador (§3 do aprimoramentos)
|
| 420 |
+
|
| 421 |
+
A.2: sem ação (prova correta). Newton-Raphson: os casos extremos pedidos
|
| 422 |
+
foram implementados (n5): T\*=8 exato (early-return `dlo≥0`) e T\*=1/8
|
| 423 |
+
exato (`dhi≤0`), ambos com NLL ≤ NLL(1), orçamento ≤ 40, e concordância
|
| 424 |
+
com golden no caso (i). **Achado honesto no caso (ii)**: com margem 100 e
|
| 425 |
+
alvo correto, a NLL é `log(1+9e^{−100/T})` — plana a ~1e-8 no colchão em
|
| 426 |
+
f32 — e o golden para em T=5,31 (interior) enquanto o Newton acerta a
|
| 427 |
+
borda EXATAMENTE pelo teste de sinal: a salvaguarda de bisseção não só
|
| 428 |
+
sobrevive ao caso extremo como **resolve melhor que a busca por seção
|
| 429 |
+
áurea** quando a função é degenerada. Caso misto quase-plano (n5b):
|
| 430 |
+
termina dentro do colchão, NLL ≤ golden+1e-3, sem oscilação.
|
| 431 |
+
|
| 432 |
+
---
|
| 433 |
+
|
| 434 |
+
## 5. APRIMORAMENTOS-ARQUITETURA — mapa de implementação
|
| 435 |
+
|
| 436 |
+
| Item pedido | Status v0.10.0 |
|
| 437 |
+
|---|---|
|
| 438 |
+
| J-1 softplus em `src/jepa.rs` | implementado como OPT-IN `ModoVariancia::Softplus` — com a prova de que NÃO resolve o problema alegado (J-1′-iii) e os 3 modos no menu |
|
| 439 |
+
| S4-1 EQM/mediana | `criterio_qe: Distancia\|Quadratico` + `criterio_lote: Media\|MedianaGeometrica` (Weiszfeld) + Teo S4-1′ |
|
| 440 |
+
| T-1 refazer prova | Teo T-1′ + `eta_rastreio` + teste do termo δ/η |
|
| 441 |
+
| T-P5 derivar L_g | `limites_gate()` com a cota VÁLIDA (a fórmula da crítica é refutada com contraexemplo) |
|
| 442 |
+
| T-P6 regularizador/doc | errata r-21 → r-24 (PCGrad medido); documento |
|
| 443 |
+
| teste falsificação diferenciabilidade std=0 | j1a/j1c/j1d (o pedido, executado CORRETAMENTE: diferenciabilidade w.r.t. z, não w.r.t. std) |
|
| 444 |
+
| teste falsificação da QE | s41_contraexemplo (QE 0→5) + weiszfeld (0→0) |
|
| 445 |
+
| NCM penalidade TC | `tc_intra_nivel` medido (telemetria); penalidade no gerador REFUTADA (B-1R); alavanca tokenizer documentada (B-1T) + adiada com justificativa estatística |
|
| 446 |
+
| Pensamento formalizar filtração + teste causalidade | teste contrafactual tp1 (a formalização tipográfica sugerida foi julgada e recusada com razão — tipos não provam semântica; teste de falsificação sim) |
|
| 447 |
+
| som4d criterio_qe option | implementado |
|
| 448 |
+
| verificador: bisseção nos limites | n5/n5b |
|
| 449 |
+
|
| 450 |
+
---
|
| 451 |
+
|
| 452 |
+
## 6. BUGS ENCONTRADOS E CORRIGIDOS NESTA ANÁLISE
|
| 453 |
+
|
| 454 |
+
- **v100-1 (pré-existente desde v0.5.0, sério).** `perda_vc` do JEPA: a
|
| 455 |
+
máscara da "covariância fora-diagonal" tinha **1s na diagonal** — o
|
| 456 |
+
termo computava `Σ_j var_j²/(2d)` (quadrado das variâncias) em vez de
|
| 457 |
+
`‖offdiag(Cov)‖²_F/(2d)` documentado e provado (r-20 §0, Cor. J-1.1:
|
| 458 |
+
a penalização de rank deficiente NÃO estava implementada!). Exposto
|
| 459 |
+
pelo teste de compatibilidade j1e (pedido de falsificação da crítica
|
| 460 |
+
→ achado real). Correção: máscara invertida; o gate j1e agora valida
|
| 461 |
+
contra a referência correta. Efeito: o termo passa a DESCORRELACIONAR
|
| 462 |
+
dimensões (sua função provada); a dobradiça continua responsável pelo
|
| 463 |
+
anti-colapso (J-1′ — por isso nenhum gate antigo quebrou: o anti-colapso
|
| 464 |
+
nunca dependeu do termo de covariância).
|
| 465 |
+
- **v100-2 (meu, capturado pelo próprio teste antes de qualquer uso).**
|
| 466 |
+
Primeira versão do `limites_gate`: `exp((s̄_e−s_b)·E)` em vez de
|
| 467 |
+
`E·exp(s̄_e−s_b)` — cota 5 ordens de magnitude abaixo do correto (e
|
| 468 |
+
portanto inválida); o teste Monte Carlo tp5_cota reprovou na 1ª
|
| 469 |
+
execução. Lição registrada: cota não validada por Monte Carlo não é
|
| 470 |
+
cota.
|
| 471 |
+
|
| 472 |
+
---
|
| 473 |
+
|
| 474 |
+
## 7. TELEMETRIA v0.10.0 (todo o projeto)
|
| 475 |
+
|
| 476 |
+
- `painel_v100` (agrega v090 + notas das correções);
|
| 477 |
+
- fase A: `coerencia_welch_max` (A.1′) e `tc_intra_nivel_medio` (B.1) no
|
| 478 |
+
hub e no resumo JSON;
|
| 479 |
+
- SOM: `eqm_final`, `historico_phi`, `phi_monotono` no retorno do
|
| 480 |
+
binding `treinar_som4d`;
|
| 481 |
+
- JEPA: `modo_variancia` configurável nas demos (comparável em A/B);
|
| 482 |
+
- verificador: comportamento de borda coberto por teste (n5/n5b);
|
| 483 |
+
- T-SOM: `eta_rastreio` exposto.
|
| 484 |
+
|
| 485 |
+
## 8. MEDIÇÕES EM DADOS REAIS (Wikipédia PT-BR)
|
| 486 |
+
|
| 487 |
+
(Preenchido pelo script 74 — ver `resultados/treino_v100.json`.)
|
| 488 |
+
Resumo: fases A/B/C re-executadas com a v0.10.0; TC intra-nível medido por
|
| 489 |
+
nível; coerência de Welch máxima dos codebooks; A/B da mediana de
|
| 490 |
+
Weiszfeld vs média em latentes reais do tokenizador; A/B dos modos de
|
| 491 |
+
variância do JEPA. Números e leitura honesta no arquivo de resultados e
|
| 492 |
+
no worklog (§ abaixo após execução).
|
| 493 |
+
|
| 494 |
+
## 9. AUTOCRÍTICA (o que esta resposta NÃO resolve)
|
| 495 |
+
|
| 496 |
+
1. O Teo J-1′(iii) transfere a sela para θ-espaço sob hipótese de
|
| 497 |
+
jacobiano não-degenerado — não provada para o MLP concreto (a
|
| 498 |
+
hipótese é a mesma do J-3; a mediana das 12 variantes com std>0,05 é
|
| 499 |
+
evidência empírica, não prova).
|
| 500 |
+
2. A penalidade TC do tokenizador (B-1T) ficou como linha de base + rota
|
| 501 |
+
provada, não como implementação — o estimador plug-in por pares tem
|
| 502 |
+
viés residual O(K²/m) não-eliminável por Miller–Madow no nosso
|
| 503 |
+
tamanho de lote; implementar sem resolver isso seria engenharia de
|
| 504 |
+
aparência.
|
| 505 |
+
3. A mediana de Weiszfeld custa ~8 iterações/célula (≈3× o passo de
|
| 506 |
+
lote) e o A/B real mostra o esperado pela teoria (§8): preserva QE em
|
| 507 |
+
regimes adversos sem ganhar em regimes benignos — não é um upgrade
|
| 508 |
+
universal e não é vendido como tal.
|
| 509 |
+
4. O bug v100-1 sobreviveu a 4 versões e 111 testes porque NENHUM teste
|
| 510 |
+
validava o termo de covariância contra uma referência independente —
|
| 511 |
+
a lição (referência independente para TODO termo de perda) está
|
| 512 |
+
aplicada no j1e e anotada como padrão obrigatório.
|
| 513 |
+
5. O contraexemplo do T-P5 (fórmula DeepSeek) usa d=4096 para tornar o
|
| 514 |
+
1/√d dramático; em d=8 a violação existe mas é modesta — a refutação
|
| 515 |
+
é qualitativa e quantitativa, mas o tamanho do efeito é dependente de
|
| 516 |
+
escala (documentado no teste).
|
| 517 |
+
|
| 518 |
+
## 10. ERRATAS APLICADAS NAS MEMÓRIAS
|
| 519 |
+
|
| 520 |
+
- **r-20** (J-1): prova do ponto crítico INVALIDADA — substituída por
|
| 521 |
+
remissão ao J-1′ (r-35 §1.2); docstring do `perda_vc` corrigido; bug
|
| 522 |
+
v100-1 registrado na seção de limitações.
|
| 523 |
+
- **r-19** (S4-1/T-1/H-1): enunciados marcados com errata → S4-1′/T-1′/H-1′;
|
| 524 |
+
a "observação de rigor" original acertava o fenômeno mas o teorema
|
| 525 |
+
estava enunciado forte demais; docstring do `treinar_som4d` reescrito.
|
| 526 |
+
- **r-21** (T-P6): desatualizado quanto à separação de perdas → remissão
|
| 527 |
+
r-24 (treino conjunto + PCGrad medido).
|
| 528 |
+
- **n-02** (C.3(iii)): igualdade média=sup ERRADA → desigualdade correta
|
| 529 |
+
(C.3′); (A.0) nota do viés quantificado; (A.1) coerência medida.
|
| 530 |
+
- **r-33/r-34**: sem alteração de conteúdo; r-34 §12 (débitos) herda os
|
| 531 |
+
itens 1–3 desta seção.
|
| 532 |
+
|
| 533 |
+
## 11. LIMITAÇÕES HONESTAS
|
| 534 |
+
|
| 535 |
+
- Todas as demos continuam em escala CPU/sintética exceto onde "dados
|
| 536 |
+
reais" é explícito (§8); os teoremas não dependem da escala, as
|
| 537 |
+
MEDIÇÕES de efeito sim (padrão herdado).
|
| 538 |
+
- O `ModoVariancia::Softplus` fica no menu por completude documentada
|
| 539 |
+
(a crítica o propôs); a análise provou que ele não cumpre a alegação
|
| 540 |
+
original — usá-lo é escolha do usuário com o menu honesto §1.3.
|
| 541 |
+
- A cota T-P5′ é por MÁXIMO global dos fatores V — conservadora para
|
| 542 |
+
linhas individuais (a versão por linha está no struct
|
| 543 |
+
`s_por_linha` para telemetria futura).
|
docs/memorias/r-36-provas-som-v011.md
ADDED
|
@@ -0,0 +1,76 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# r-36 — PROVAS SOM CORRIGIDAS (v0.11) · objeto: src/som4d.rs · refuta r-19 S4-1/T-1
|
| 2 |
+
|
| 3 |
+
## S4-1′ (monotonia correta em DOIS regimes)
|
| 4 |
+
|
| 5 |
+
Definições: QE(P) = (1/N)Σᵢ min_g ‖xᵢ−p_g‖; EQM(P) = (1/N)Σᵢ min_g ‖xᵢ−p_g‖²;
|
| 6 |
+
energia SOM com atribuição congelada b(i) e pesos w_ig = h_σ(g, b(i)):
|
| 7 |
+
E_σ(P) = Σᵢ Σ_g w_ig ‖xᵢ−p_g‖². Atualização: m_g = Σᵢ w_ig xᵢ / Σᵢ w_ig;
|
| 8 |
+
p′_g = (1−η)p_g + η m_g, η ∈ [0,1].
|
| 9 |
+
|
| 10 |
+
**Teorema (a) — atribuição HARD (w_ig = 1[g=b(i)]): EQM não cresce, ∀η∈[0,1].**
|
| 11 |
+
Prova. Com atribuição congelada, EQM(P) = (1/N)Σ_g Σ_{i∈C_g} ‖xᵢ−p_g‖² é separável
|
| 12 |
+
e quadrática estritamente convexa por célula; o minimizador é m_g = média(C_g)
|
| 13 |
+
(identidade da variância: Σ‖xᵢ−p‖² = Σ‖xᵢ−m‖² + |C_g|‖p−m‖²). Logo EQM(m) ≤ EQM(p).
|
| 14 |
+
Por convexidade de EQM congelada em P: EQM((1−η)p+ηm) ≤ (1−η)EQM(p)+ηEQM(m) ≤ EQM(p).
|
| 15 |
+
A re-atribuição troca min_g por um conjunto que contém o protótipo anterior avaliado
|
| 16 |
+
no mesmo x ⇒ min só diminui. Compondo: EQM(P_{t+1}) ≤ EQM(P_t). ∎
|
| 17 |
+
|
| 18 |
+
**Teorema (b) — vizinhança geral: E_σ não cresce, ∀η∈[0,1]; QE e EQM NÃO têm garantia.**
|
| 19 |
+
Prova. E_σ é quadrática convexa em P, separável por g com minimizador m_g (média
|
| 20 |
+
ponderada) ⇒ E_σ(m) ≤ E_σ(p); mistura η idem (a). ∎
|
| 21 |
+
**Contraexemplo (falsificação de QE e EQM sob vizinhança):** x={0,10}, p={1,9},
|
| 22 |
+
σ→∞ (w≡1) ⇒ m={5,5}. QE: 1→5; EQM: 1→25; E_σ: 164→100 ✓. A crítica externa
|
| 23 |
+
(r-18) propôs "reformular para EQM" — INSUFICIENTE: o contraexemplo refuta EQM
|
| 24 |
+
também no regime com vizinhança. A métrica monitorada deve ser E_σ (regime suave)
|
| 25 |
+
ou EQM (regime hard). Critério: teste_s41_contraexemplo_qe_eqm (valores acima, exatos).
|
| 26 |
+
|
| 27 |
+
**Errata da crítica:** "convexidade de ‖·‖² não implica convexidade de ‖·‖" é falso
|
| 28 |
+
— a norma É convexa. A lacuna real da prova r-19 é que a MÉDIA não minimiza Σ‖xᵢ−p‖.
|
| 29 |
+
|
| 30 |
+
## S4-2 (QE não-crescente via mediana geométrica — Weiszfeld)
|
| 31 |
+
|
| 32 |
+
**Teorema.** Com atribuição hard, seja m_g a mediana geométrica de C_g (min Σ‖xᵢ−m‖),
|
| 33 |
+
aproximada por Weiszfeld: m^{(k+1)} = Σᵢ xᵢ/‖xᵢ−m^{(k)}‖ / Σᵢ 1/‖xᵢ−m^{(k)}‖.
|
| 34 |
+
Então (i) cada passo de Weiszfeld não aumenta Σ‖xᵢ−m‖ (MM com majorante quadrática
|
| 35 |
+
wᵢ=1/‖xᵢ−m^{(k)}‖; prova: para todo u, ‖u‖ ≤ ‖u‖²/(2a) + a/2 com igualdade em a=‖u‖;
|
| 36 |
+
minimizar o majorante em m dá o passo; o majorante toca a função no ponto corrente);
|
| 37 |
+
(ii) p′=(1−η)p+ηm com QE(m)≤QE(p) ⇒ QE(p′) ≤ (1−η)QE(p)+ηQE(m) ≤ QE(p) — AQUI a
|
| 38 |
+
convexidade da norma é usada CORRETAMENTE (o minimizador é o da soma de distâncias);
|
| 39 |
+
(iii) re-atribuição só diminui o min. Logo QE(P_{t+1}) ≤ QE(P_t). ∎
|
| 40 |
+
Verificado: 200 iterações, QE 6.0591→1.8231, monotonia bit-a-bit; blend η=0.5 ✓.
|
| 41 |
+
Custo: O(iters·|C_g|·d); iters≈10–30 para ε=1e-4. Ponto fixo em xᵢ: tratar ‖·‖<1e-12.
|
| 42 |
+
|
| 43 |
+
## T-1′ (rastreio sob deriva linear — cota APERTADA)
|
| 44 |
+
|
| 45 |
+
**Teorema.** Sinal μ_t = δt; filtro m_t = γ m_{t−1} + (1−γ)μ_t; protótipo
|
| 46 |
+
p_{t+1} = p_t + η(m_t − p_t), γ∈[0,1), η∈(0,1]. Em regime estacionário:
|
| 47 |
+
lag_total = δγ/(1−γ) + δ(1−η)/η ≤ δγ/(1−γ) + δ/η.
|
| 48 |
+
Prova. Para rampa, busque solução particular m_t = δt − L₁: substituindo,
|
| 49 |
+
δt − L₁ = γ(δ(t−1) − L₁) + (1−γ)δt ⇒ L₁ = δγ/(1−γ). Idem p_t = δt − L₁ − L₂:
|
| 50 |
+
δ(t+1) − L₁ − L₂ = (1−η)(δt − L₁ − L₂) + η(δt − L₁) ⇒ L₂ = δ(1−η)/η.
|
| 51 |
+
Transiente: erro e_t satisfaz sistema linear com autovalores {γ, 1−η} ⊂ [0,1) ⇒
|
| 52 |
+
‖e_t − e_∞‖ ≤ C·max(γ,1−η)^t → 0. η=1 ⇒ L₂=0 (recupera cota original). ∎
|
| 53 |
+
Verificado: δ=0.02, γ=0.9, η=0.1 ⇒ lag medido 0.3600 = cota apertada 0.3600
|
| 54 |
+
(cota da crítica: 0.3800, válida porém frouxa). Recomendação: η dinâmico
|
| 55 |
+
(η↑ perto do alvo, η↓ em ruído) — liga com A-5 (Bernstein LCB).
|
| 56 |
+
|
| 57 |
+
## G-1 (inserção GNG — mantida, prova exata)
|
| 58 |
+
Identidade do ponto médio: ‖x−(a+b)/2‖² = (‖x−a‖²+‖x−b‖²)/2 − ‖a−b‖²/4. ∎
|
| 59 |
+
(teste existente teste_gng_insercao_nao_aumenta_erro_local cobre.)
|
| 60 |
+
|
| 61 |
+
## H-1′ (hierárquico — cota Minkowski + parte (c) CONSTRUTIVA)
|
| 62 |
+
**(b) Cota mais justa que ambas as anteriores:** por Minkowski em L²,
|
| 63 |
+
√EQ_hier ≤ √EQ_grosso + √R_fino ⇒ EQ_hier ≤ EQ_g + R_f + 2√(EQ_g·R_f).
|
| 64 |
+
Domina a cota r-19 (que tem 2R_f) e a da crítica (2EQ_g+2R_f quando R_f<EQ_g). ∎
|
| 65 |
+
**(c) vira TEOREMA com "pin slot 0":** fixe finos[g][0] := p_g (nunca re-semeado).
|
| 66 |
+
Então min_f ‖x−finos[g][f]‖ ≤ ‖x−p_g‖ ponto a ponto ⇒ EQ_hier ≤ EQ_grosso EXATO,
|
| 67 |
+
mesmo com re-semeadura k-means++ dos slots 1..k−1. Prova: o mínimo sobre um conjunto
|
| 68 |
+
que contém p_g é ≤ o valor em p_g. ∎ (implementação: 3 linhas em treinar_hsom;
|
| 69 |
+
a versão atual SEM pin mantém (c) como conjectura — documentar honestamente.)
|
| 70 |
+
|
| 71 |
+
## Limitações honestas
|
| 72 |
+
1. T-1′ assume deriva linear e pesos de janela normalizados; rajadas violam a
|
| 73 |
+
forma do transiente (cota estacionária segue válida por superposição linear).
|
| 74 |
+
2. Weiszfeld: não-diferenciável em xᵢ; usar ε-suavização e reportar iterações.
|
| 75 |
+
3. E_σ depende de σ(t) — comparar épocas com σ diferente NÃO é comparação de
|
| 76 |
+
energia fixa; congelar σ na janela de auditoria.
|
docs/memorias/r-37-provas-jepa-v011.md
ADDED
|
@@ -0,0 +1,62 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# r-37 — PROVAS JEPA CORRIGIDAS (v0.11) · objeto: src/jepa/nucleo.rs (perda_vc)
|
| 2 |
+
|
| 3 |
+
## J-1′ (anti-colapso — análise CORRETA do ponto crítico)
|
| 4 |
+
|
| 5 |
+
**Errata da crítica r-18 (três imprecisões):**
|
| 6 |
+
(i) f(s)=max(0,γ−s)² é C¹ em s (f′=−2max(0,γ−s), contínua); o kink é de f″ em s=γ.
|
| 7 |
+
(ii) O problema real é std=√var: não-diferenciável em var=0 (sqrt′(0)=∞) — no
|
| 8 |
+
colapso exato o autodiff produz NaN (0·∞) ou subgradiente 0.
|
| 9 |
+
(iii) "gradiente não-nulo no colapso" é FALSO mesmo com softplus: var é estacionária
|
| 10 |
+
em z=c (∂var/∂z = 2(z−z̄)/n = 0). Verificado: |grad|=5.9e-14 ≈ 0.
|
| 11 |
+
|
| 12 |
+
**Análise exata no colapso.** Com u = z−z̄ (coluna j), std_j = ‖u_j‖/√n:
|
| 13 |
+
V(u) = (γ − ‖u‖/√n)² = γ² − (2γ/√n)‖u‖ + ‖u‖²/n.
|
| 14 |
+
A derivada direcional em qualquer direção v é −(2γ/√n)‖v‖ < 0 ⇒ o colapso é
|
| 15 |
+
MÁXIMO LOCAL estrito de V ao longo de qualquer direção de espalhamento — nunca
|
| 16 |
+
mínimo local de V. O defeito é numérico (NaN), não de existência de mínimo.
|
| 17 |
+
|
| 18 |
+
**Correção implementável (C^∞ de verdade):**
|
| 19 |
+
V_suave(z) = (1/d) Σⱼ softplus(k(γ − std_ε,j))², std_ε,j = √(var_j + ε),
|
| 20 |
+
k>0, ε>0 (a crítica esqueceu o ε: softplus(k(γ−√var)) AINDA quebra em var=0).
|
| 21 |
+
|
| 22 |
+
**Teorema J-1′.** Sob V_suave com ε>0:
|
| 23 |
+
(a) V_suave ∈ C^∞(z) (composição de funções C^∞; var+ε ≥ ε > 0). ∎
|
| 24 |
+
(b) Gap de valor: no colapso V = sp(kγ)²; em qualquer config com std ≥ γ,
|
| 25 |
+
V ≤ sp(0)² = (ln 2)² < sp(kγ)². Como sp é estritamente crescente, o gap
|
| 26 |
+
Δ = sp(kγ)² − (ln2)² > 0 ⇒ colapso NUNCA é minimizador global de
|
| 27 |
+
L = L_pred + λ_vc·V com λ_vc > 0 (L_pred ≥ 0 e atingível igual no colapso
|
| 28 |
+
e em configs espalhadas com o mesmo alvo constante). ∎
|
| 29 |
+
(c) Estabilidade: no colapso ∇_z V = 0, mas a curvatura ao longo de qualquer
|
| 30 |
+
direção de espalhamento é ∂²V/∂t² = (∂V/∂var)·(2/n) < 0, pois
|
| 31 |
+
∂V/∂var = −k·sp(k(γ−std_ε))·σ(k(γ−std_ε))/std_ε < 0. Logo o colapso é SELA
|
| 32 |
+
INSTÁVEL: sob SGD com ruído não-degenerado, a probabilidade de permanecer
|
| 33 |
+
nele é 0 (escape por curvatura negativa; medido: −1.4e4 na direção testada). ∎
|
| 34 |
+
(d) Limitação honesta (espaço de parâmetros): se o Jacobiano do encoder for
|
| 35 |
+
degenerado (init zero / ReLU mortas), ∇θ = Jᵀ∇_z pode anular-se mesmo com
|
| 36 |
+
∇_z ≠ 0. A garantia (c) exige init não-degenerada (a do repo: σ=0.9/√d ✓).
|
| 37 |
+
|
| 38 |
+
**Critério de falsificação (novos testes):**
|
| 39 |
+
j1c_suave_c_infinito: gradiente vs diferenças finitas em var=0 (erro < 1e-3, sem NaN);
|
| 40 |
+
j1d_colapso_sela: V(c+t·u) estritamente decrescente em t para t∈(0,γ√n/‖u‖);
|
| 41 |
+
j1e_gap: V(colapso) − V(std=γ) ≥ sp(kγ)²−(ln2)² − 1e-6.
|
| 42 |
+
|
| 43 |
+
## J-2 (EMA = stop-grad + ponto fixo — mantida, com cota de rastreio)
|
| 44 |
+
ξ_{t+1} = mξ_t + (1−m)θ_t, m<1 ⇒ ‖ξ_t − θ*‖ ≤ mᵗ‖ξ_0−θ*‖ + (1−m)Σₛ m^{t−1−s}‖θ_s−θ*‖.
|
| 45 |
+
Se θ_t→θ*, ξ_t→θ* (Toeplitz); se θ deriva a taxa δ, lag assintótico ≤ mδ/(1−m)
|
| 46 |
+
(mesma álgebra de T-1′). ∎
|
| 47 |
+
|
| 48 |
+
## J-3′ (decomposição de informação com gap de capacidade — prova L²)
|
| 49 |
+
**Teorema.** Seja m*(ctx) = E[z_t | ctx]. Para QUALQUER preditor P mensurável:
|
| 50 |
+
E‖P(ctx) − z_t‖² = E‖P(ctx) − m*(ctx)‖² + E‖m*(ctx) − z_t‖².
|
| 51 |
+
Prova. Escreva P−z_t = (P−m*) + (m*−z_t). O termo cruzado tem esperança
|
| 52 |
+
E⟨P−m*, m*−z_t⟩ = E[⟨P−m*, E[m*−z_t | ctx]⟩] = 0 (torre; m* é a projeção
|
| 53 |
+
ortogonal de z_t no subespaço L²(σ(ctx))). ∎
|
| 54 |
+
Corolário: L_pred = gap_aproximação(P) + variância irredutível; com P de capacidade
|
| 55 |
+
finita o primeiro termo é > 0 — reportar ‖P−m*‖² estimado por ensemble/holdout.
|
| 56 |
+
A decomposição é EXATA; o que era aproximação é atingir o mínimo, não a identidade.
|
| 57 |
+
|
| 58 |
+
## Limitações honestas
|
| 59 |
+
1. (c) é garantia quase-certa sob ruído; SGD determinístico full-batch PODE
|
| 60 |
+
estacionar na sela (medida zero nas inits, mas possível em floats).
|
| 61 |
+
2. ε>0 enviesa std para cima em O(ε/(2·std)); escolher ε ≪ γ² (ex.: 1e-4·γ²).
|
| 62 |
+
3. k controla a dureza: k→∞ recupera a hinge suavizada; k pequeno achata o gap.
|
docs/memorias/r-38-provas-ncm-v011.md
ADDED
|
@@ -0,0 +1,66 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# r-38 — PROVAS NCM COMPLEMENTADAS (v0.11) · objetos: quantizador.rs, gerador.rs, perdas.rs
|
| 2 |
+
|
| 3 |
+
## A.0′ (viés do STE quantificado; GSQ exato)
|
| 4 |
+
**Teorema.** Seja r_τ o relaxamento GSQ e r_h o duro. Para L com ∇ Lipschitz (L₂):
|
| 5 |
+
‖g_STE − g_GSQ‖ ≤ L₂ · E‖r_τ − r_h‖ ≤ 2R·L₂·(1 − E[p_max(τ)]).
|
| 6 |
+
Prova. STE puxa ∇L(r_h) para z; GSQ usa ∇L(r_τ)·(∂r_τ/∂z). A diferença do ponto
|
| 7 |
+
de avaliação é limitada por L₂‖r_τ−r_h‖ (desigualdade do valor médio); r_τ e r_h
|
| 8 |
+
estão no casco {R·c_k}, logo ‖r_τ−r_h‖ ≤ 2R·(1−p_max) (massa fora do argmax).
|
| 9 |
+
Com τ→0, p_max→1 q.c. (consistência Gumbel-softmax) ⇒ viés→0. ∎
|
| 10 |
+
Compromisso β: com perda β‖z−sg[r_h]‖², o resíduo é controlado em Expectativa por
|
| 11 |
+
ρ²=E‖z−r_h‖²; o viés direcional do STE é O(β^{-1/2}) no equilíbrio — reportar ρ.
|
| 12 |
+
**GSQ (A.4) — adjunto do custom op confere com o grafo nativo** (teste existente
|
| 13 |
+
gsq_bwd_vs_nativo): gz = (1/τ)·J_softmax·(g·Cᵀ)·C; gc = R·yᵀ·g. Prova: diferenciação
|
| 14 |
+
direta de r = R·softmax(zCᵀ/τ + g_noise)·C com ruído CONSTANTE no backward
|
| 15 |
+
(recomputação exata — sem re-amostragem). ∎
|
| 16 |
+
|
| 17 |
+
## A.1′ (contração — prova completa + generalização de frame)
|
| 18 |
+
**Teorema (ortonormal).** C com CCᵀ=I_K, K≤d; k* = argmax⟨z,c_k⟩; M=⟨z,c_{k*}⟩.
|
| 19 |
+
(i) M ≥ ‖P_C z‖/√K (o máximo de K coordenadas de P_C z ≥ norma/√K — norma ℓ∞ vs ℓ2).
|
| 20 |
+
(ii) ‖z − R c_{k*}‖² = ‖z‖² − 2RM + R²; minimizado em R*=M ⇒ ≤ ‖z‖² − M²
|
| 21 |
+
≤ ‖z‖² − ‖P_C z‖²/K.
|
| 22 |
+
(iii) Se z ∈ span(C): ‖resíduo‖² ≤ (1−1/K)‖z‖². A escala EMA R≈‖P_C z‖/√K é
|
| 23 |
+
conservadora (pior caso: coordenadas iguais); R*=M é a ótima ponto a ponto. ∎
|
| 24 |
+
**Generalização (tight frame, K>d).** Frame unitário tight: S=Σc_k c_kᵀ=(K/d)I ⇒
|
| 25 |
+
Σ⟨z,c_k⟩² = (K/d)‖z‖² ⇒ M² ≥ ‖z‖²/d ⇒ contração (1−1/d) com R*=M. Para frame
|
| 26 |
+
NÃO-tight, Gershgorin no Gram: λ_min(S) ≥ K/d − (K−1)μ, μ = max_{i≠j}|⟨c_i,c_j⟩|;
|
| 27 |
+
Welch: μ ≥ √((K−d)/(d(K−1))) — a coerência mínima impõe o pior caso. Contração
|
| 28 |
+
garantida: 1 − λ_min(S)/K (com R*=M). Reportar contração empírica por nível. ∎
|
| 29 |
+
Limitação: (iii) exige resíduo no span — fora do span o termo ‖z−P_C z‖² persiste
|
| 30 |
+
(o VQ residual distribui esse termo aos níveis seguintes; cota composta: produto
|
| 31 |
+
dos fatores (1−1/K_ℓ) sobre a energia projetada + energia ortogonal não-crescente).
|
| 32 |
+
|
| 33 |
+
## A.2 (nested dropout — mantida)
|
| 34 |
+
V(ℓ) = min_{D∈𝒟_ℓ} E‖D(c_{≤ℓ})−z‖²; 𝒟_ℓ ⊆ 𝒟_{ℓ+1} (decoder que ignora o nível
|
| 35 |
+
ℓ+1 está na classe maior) ⇒ V(1) ≥ V(2) ≥ … ∎ (ii) exige D ε_ℓ-ótima — medir gap
|
| 36 |
+
por prefixo na telemetria (anytime).
|
| 37 |
+
|
| 38 |
+
## B.1 + gap TC (identidade exata)
|
| 39 |
+
p(c)=Π p(c_ℓ|c_{<ℓ}) é a regra da cadeia — SEMPRE exata (não é hipótese).
|
| 40 |
+
O gap da predição paralela intra-nível é
|
| 41 |
+
log p(c_ℓ|c_{<ℓ}) − Σ_j log q(c_ℓj|c_{<ℓ}) ⇒ em esperança:
|
| 42 |
+
Gap = Σ_j H(c_ℓj|c_{<ℓ}) − H(c_ℓ|c_{<ℓ}) = TC(c_ℓ | c_{<ℓ}) ≥ 0,
|
| 43 |
+
com igualdade sse independência condicional (não-negatividade de KL entre a
|
| 44 |
+
conjunta e o produto das marginais). ∎ Regularizador sugerido: λ_TC·TC estimado
|
| 45 |
+
por discriminador de permutações intra-nível (density-ratio) ou penalidade de
|
| 46 |
+
covariância dos logits — documentar que quebra o paralelismo apenas no TREINO.
|
| 47 |
+
|
| 48 |
+
## C.3′ (corrupção de condicionamento ≡ DRO — prova formal)
|
| 49 |
+
**Teorema (TV-DRO).** Para perda limitada L ∈ [0, L_max] e ε ∈ [0,1]:
|
| 50 |
+
sup_{Q: TV(Q,P) ≤ ε} E_Q[L] = (1−ε)E_P[L] + ε·L_max.
|
| 51 |
+
Prova. (≤) Q = (1−ε)P + εR com TV ≤ ε ⇒ E_Q L ≤ (1−ε)E_P L + ε L_max.
|
| 52 |
+
(≥) Tome R = δ_{argmax L} (ou sequência aproximante): TV(Q,P) = ε·TV(R,P) ≤ ε e o
|
| 53 |
+
valor é atingido. ∎
|
| 54 |
+
**Corolário (corrupção uniforme).** A corrupção do repo troca cada condição por
|
| 55 |
+
uniforme com prob. ε ⇒ Q_ε = (1−ε)P + εU ⇒ E_{Q_ε}[L] = (1−ε)E_P[L] + εE_U[L] —
|
| 56 |
+
um LOWER bound do risco TV-DRO (E_U ≤ L_max), com igualdade quando L é constante
|
| 57 |
+
no suporte adversarial. Treinar com corrupção = minimizar um substituto do risco
|
| 58 |
+
robusto; a versão adversarial (corromper onde L é maior — top-k por perda) atinge
|
| 59 |
+
o sup e fecha o gap. Calibração ε pela taxa de erro por nível (C.3(ii)) é a
|
| 60 |
+
escolha do raio da bola de ambiguidade — já implementada no controlador. ∎
|
| 61 |
+
|
| 62 |
+
## Limitações honestas
|
| 63 |
+
1. A.1′ worst-case; a contração média depende da distribuição angular de z.
|
| 64 |
+
2. O estimador de TC por discriminador tem variância alta em K grande — usar
|
| 65 |
+
janelas e EMA; não declarar "gap=0" com n pequeno.
|
| 66 |
+
3. C.3′ vale para perdas limitadas; CE ilimitada exige truncamento (clip) explícito.
|
docs/memorias/r-39-provas-pensamento-v011.md
ADDED
|
@@ -0,0 +1,51 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# r-39 — PROVAS PENSAMENTO REFINADAS (v0.11) · objeto: src/pensamento/{mod,motor,combinador}.rs
|
| 2 |
+
|
| 3 |
+
## T-P1′ (filtração explícita — fecha a lacuna conceitual)
|
| 4 |
+
Defina 𝓕_k = σ(z_{1:t}, cond_{1:t}, ξ_{1:k}, V_{1:k}) — inclui o ruído dos difusores
|
| 5 |
+
ξ e as avaliações do verificador. G_k = 1{conf_k < τ_c} é composição mensurável de
|
| 6 |
+
(conf ∘ softmax ∘ logits)(resposta_k) com resposta_k função de (cond, ξ_{≤k}, θ) ⇒
|
| 7 |
+
G_k é 𝓕_k-mensurável; nenhum z_{t+1} entra. A temperatura T_{k+1} = 1.6·T_k é
|
| 8 |
+
adaptada ao PASSADO (𝓕_k-mensurável) — previsível, logo o processo de exploração
|
| 9 |
+
é adaptado e a causalidade é formal, não conceitual. ∎
|
| 10 |
+
Teste: teste_causalidade_gatilho — mesmas entradas ⇒ mesma decisão (bit-a-bit).
|
| 11 |
+
|
| 12 |
+
## T-P2′ (agregação ponderada — MSE exato e N_eff)
|
| 13 |
+
Para pesos w DETERMINÍSTICOS (Σw=1) e erros independentes: E‖Σw oᵢ − alvo‖² =
|
| 14 |
+
tr(Σ)·Σwᵢ² = tr(Σ)/N_eff, N_eff = 1/Σwᵢ² ≤ N. ∎ (produto cruzado nulo).
|
| 15 |
+
**Limitação honesta:** os pesos de coerência wᵢ ∝ exp(4cos(oᵢ,ō)) dependem dos
|
| 16 |
+
próprios candidatos ⇒ não-determinísticos; a identidade vale condicionalmente e o
|
| 17 |
+
viés de seleção é O(cov(w,ε)). Mitigação: Hedge sobre perdas OBSERVADAS (RE-6) —
|
| 18 |
+
pesos previsíveis (função do passado), recuperando a garantia sem condição.
|
| 19 |
+
Hoeffding (b) e best-of-N (c) da r-21 permanecem válidos (eventos discretos, w não entra).
|
| 20 |
+
|
| 21 |
+
## T-P3 (ridge — mantida; igualdade caracterizada)
|
| 22 |
+
r* = (WᵀW+εI)⁻¹Wᵀr_alvo; Q estritamente convexa ⇒ mínimo global único; resíduo
|
| 23 |
+
mínimo ‖(I−W(WᵀW+εI)⁻¹Wᵀ)r_alvo‖; ε→0 ⇒ Tikhonov→Moore–Penrose. ∎ (r-21 correta.)
|
| 24 |
+
|
| 25 |
+
## T-P4 (terminação/soundness — mantida) Φ(k)=B−k; indução bem-fundada; melhor
|
| 26 |
+
candidato por indução; orcamento_esgotado=1 auditado. ∎
|
| 27 |
+
|
| 28 |
+
## T-P5′ (IDENTIDADE EXATA da massa de atenção — substitui a cota heurística)
|
| 29 |
+
**Teorema.** Sejam s_j = q·k_j/√d, Z_b = Σ_{base} e^{s}, Z_e = Σ_{extra} e^{s},
|
| 30 |
+
π = Z_e/(Z_b+Z_e), ȳ_e = Σ_{extra}(a_j/π)v_j. Então
|
| 31 |
+
y_full − y_base = π·(ȳ_e − y_base) (EXATA — verificado erro 1.1e-16).
|
| 32 |
+
Prova. Para j∈base: a′_j = e^{s_j}/(Z_b+Z_e) = a_j·(1−π). Logo
|
| 33 |
+
y_full = (1−π)y_base + πȳ_e ⇒ Δy = π(ȳ_e−y_base). ∎
|
| 34 |
+
**Corolários.** (i) ‖Δy‖ ≤ 2·V_max·π, V_max = max‖v‖_∞ (ambos os blocos);
|
| 35 |
+
(ii) π ≤ Z_e/Z_b ≤ n_e·exp(s_max_e)/Z_b — para scores pequenos, π ≈ Z_e/Z_b e a
|
| 36 |
+
cota da crítica L_g = ‖q‖·max‖k_e‖·max‖v_e‖/√d é o termo de 1ª ordem (π ≤
|
| 37 |
+
n_e·‖q‖K_e/√d + O(s²) com Z_b ≥ 1 após deslocamento); (iii) neutralidade g=0:
|
| 38 |
+
bit-a-bit (0·δ=0 IEEE-754) — mantida; (iv) ∂y_int/∂g = Δy ≠ 0 ⇒ gate aprende. ∎
|
| 39 |
+
**Consequência de projeto:** π é o botão de ÊNFASE mensurável — a base do
|
| 40 |
+
certificado de compressão RE-2 (r-42): remover peças com massa removida π_rem
|
| 41 |
+
custa no máximo 2|g|V_max·π_rem na saída.
|
| 42 |
+
|
| 43 |
+
## T-P6′ (composição d=a+b+c sob treino conjunto — re-enunciado honesto)
|
| 44 |
+
A fatoração por regra da cadeia NUNCA quebra (é identidade). O que o treino
|
| 45 |
+
conjunto (fase C) pode degradar: (i) o gap TC intra-nível (B.1) — medir por nível;
|
| 46 |
+
(ii) a CALIBRAÇÃO do verificador (mudança de distribuição dos logits) ⇒ recalibrar
|
| 47 |
+
T* após cada fine-tune conjunto e re-medir ECE (V-2′) — condição explícita do
|
| 48 |
+
soundness. Com perdas separadas (v0.5) nada disso se move; com PCGrad (v0.6) o
|
| 49 |
+
item (ii) é obrigatório no pipeline. ∎ (documentar; regularizador MI opcional.)
|
| 50 |
+
|
| 51 |
+
## T-P7 (custo — mantido) Θ(B·N·d_cond·d_h); N paralelizável (rayon, seeds s+i). ∎
|
docs/memorias/r-40-provas-verificador-v011.md
ADDED
|
@@ -0,0 +1,44 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# r-40 — PROVAS VERIFICADOR COMPLETADAS (v0.11) · objeto: src/verificador.rs
|
| 2 |
+
|
| 3 |
+
## N-2 (convexidade GLOBAL em γ=1/T — prova)
|
| 4 |
+
L̃(γ) = (1/n)Σᵢ [logsumexp(γzᵢ) − γz_{i,yᵢ}]. O Hessiano de logsumexp em γ é
|
| 5 |
+
Var_{p_γ}(z) ≥ 0 (familia exponencial: ∂²/∂γ² lse = E_p[z²]−E_p[z]²); o termo linear
|
| 6 |
+
não contribui ⇒ L̃″(γ) = (1/n)Σᵢ Var_{pᵢ}(zᵢ) ≥ 0 SEMPRE, > 0 se algum logits não
|
| 7 |
+
for constante. L̃′(γ) = (1/n)Σᵢ(E_{pᵢ}[zᵢ] − z_{i,yᵢ}). ∎
|
| 8 |
+
(Corrige de vez a errata Qwen: sinal e ordem da diferença — testes n1/n3 cobrem.)
|
| 9 |
+
|
| 10 |
+
## N-3/N-4 (Newton com salvaguarda — convergência)
|
| 11 |
+
Colchão [a,b] com L̃′(a)<0<L̃′(b) mantido pelo sinal (válido por N-2); passo Newton
|
| 12 |
+
aceito só dentro do colchão, senão bisseção geométrica √(ab). Globe: o colchão
|
| 13 |
+
encolhe a cada passo ⇒ convergência garantida em ⌈log₂(ln64/ε)⌉ passos no pior
|
| 14 |
+
caso. Local: L̃ ∈ C², L̃″(γ*)>0 ⇒ taxa quadrática padrão de Newton. Bordas:
|
| 15 |
+
L̃′(lo)≥0 ⇒ T*=8; L̃′(hi)≤0 ⇒ T*=1/8 (testes n4b cobrem os dois extremos). ∎
|
| 16 |
+
|
| 17 |
+
## V-2′ (soundness SEM oráculo — cota CONDICIONAL corrigida)
|
| 18 |
+
**Errata:** a cota r-23 "P(erro|aceito) ≤ 1−τ_c + ECE" só vale com ECE medido NO
|
| 19 |
+
CONJUNTO ACEITO. Com ECE global, o correto é:
|
| 20 |
+
**Teorema.** Seja A = {conf ≥ τ_c}, p_a = P(A) > 0, e
|
| 21 |
+
L₁ = E|1{acerto} − conf| (calibração L1; ECE por faixas é seu estimador). Então
|
| 22 |
+
P(erro | A) ≤ (1−τ_c) + L₁/p_a.
|
| 23 |
+
Prova. P(erro|A) = 1 − E[1{acerto}|A] ≤ 1 − E[conf|A] + E[|1{acerto}−conf| | A]
|
| 24 |
+
≤ 1 − τ_c + L₁/p_a (condicionamento: E[X|A] ≤ E[X]/P(A) para X≥0). ∎
|
| 25 |
+
Verificado em simulação (n=2e5, viés senoidal): 0.1372 ≤ cota corrigida ✓.
|
| 26 |
+
**Implementação:** reportar ECE_aceito (faixas restritas a conf ≥ τ_c) — então a
|
| 27 |
+
cota limpa 1−τ_c+ECE_aceito vale; p_a vem de graça do quantil (≈ ε por V-3).
|
| 28 |
+
|
| 29 |
+
## V-3 (quantil DKW — prova do sanduíche)
|
| 30 |
+
Evento E = {sup_x|F̂_n(x)−F(x)| ≤ δ}, P(E) ≥ 1−2e^{−2nδ²} (DKW–Massart). Em E:
|
| 31 |
+
F̂(τ̂)≥1−ε ⇒ F(τ̂) ≥ 1−ε−δ ⇒ P(conf < τ̂) ≤ ε+δ… logo a fração de aceite é
|
| 32 |
+
≥ ε−δ e ≤ ε+δ; combinando com V-2′ (τ̂ no lugar de τ_c) a taxa de erro conjunta
|
| 33 |
+
é controlada com probabilidade ≥ 1−2e^{−2nδ²} sobre a amostra retida. ∎
|
| 34 |
+
Nota: o quantil controla a TAXA DE ACEITE; o soundness vem de V-2′ — não confundir
|
| 35 |
+
(o comentário "aceitar ~80%" no teste v2 está trocado: ε=0.2 ⇒ aceita ~20%).
|
| 36 |
+
|
| 37 |
+
## V-4 (entropia estável — identidade)
|
| 38 |
+
H(p) = −Σp log p com p=softmax(z): log p = z − lse(z) ⇒ H = lse(z) − Σp·z.
|
| 39 |
+
Sem 0·log0 (0·z=0 exato); lse estável por deslocamento do máximo. ∎ (código ok.)
|
| 40 |
+
|
| 41 |
+
## Limitações honestas
|
| 42 |
+
1. ECE por faixas tem viés de discretização O(1/faixas) — reportar n por faixa.
|
| 43 |
+
2. Calibração em dados retidos pressupõe exchangeability com produção; sob drift,
|
| 44 |
+
recalibrar (gate A-1 já reage via DKW, mas T* precisa de re-ajuste periódico).
|
docs/memorias/r-41-provas-moe-fnh-v011.md
ADDED
|
@@ -0,0 +1,62 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# r-41 — PROVAS MoE REDIRECIONÁVEL + FNH (v0.11) · objetos: moe_redirecionavel/, fnh.rs
|
| 2 |
+
|
| 3 |
+
## M-R1′ (invariância por permutação de papéis — prova)
|
| 4 |
+
O roteamento depende do CONJUNTO de especialistas do papel (máscara −inf) e das
|
| 5 |
+
probs softmax restritas a ele; a perda auxiliar e_local·Σ f_e·p̄_e é simétrica nos
|
| 6 |
+
índices locais. Redirecionar por permutação σ apenas re-rotula ⇒ distribuição de
|
| 7 |
+
saída invariante em lei (e bit-a-bit se a ordem de acumulação seguir a ordem
|
| 8 |
+
canônica dos índices). Classe fechada sob composição de permutações (S_E). ∎
|
| 9 |
+
|
| 10 |
+
## M-R3 (paralelismo determinístico — prova)
|
| 11 |
+
Papéis usam subconjuntos DISJUNTOS de especialistas; forward não muta estado
|
| 12 |
+
(&self); index_add acumula em ordem fixa do laço de designação; pesos vêm do
|
| 13 |
+
mesmo tensor probs. Dois threads executam DAGs independentes com as mesmas
|
| 14 |
+
entradas ⇒ saídas bit-a-bit iguais às sequenciais (assert dif<1e-9 no código;
|
| 15 |
+
na prática dif=0). ∎
|
| 16 |
+
|
| 17 |
+
## M-R6/M-R7 (grafo vivo — prova de fluxo de gradiente)
|
| 18 |
+
saida = Σ_e index_add(idx_e, f_e(y[idx_e])·w_e) / Σw; index_add é op rastreada ⇒
|
| 19 |
+
∂L/∂θ_e = Σ idx (∂f_e/∂θ)ᵀ·(g·w) e ∂L/∂roteador via w = probs[idx,e] (vivo).
|
| 20 |
+
A seleção discreta é constante no grafo (argmax não-diferenciável — padrão
|
| 21 |
+
Switch); f constante, p̄ vivo na aux. O caminho DEPRECIADO (to_vec2/from_vec)
|
| 22 |
+
secciona o grafo — mantido só como oráculo de teste. ∎
|
| 23 |
+
|
| 24 |
+
|
| 25 |
+
> **ERRATA v0.11.0 (verificação exaustiva):** o custo do guloso no
|
| 26 |
+
> contraexemplo é **31,79418** (c=[2,3,2,1,5]), não 31,787 como escrito
|
| 27 |
+
> abaixo; o arredondar custa 33,195 (perda de 4,2%). A alocação e a
|
| 28 |
+
> otimalidade do guloso CONFEREM (guloso == força bruta, teste
|
| 29 |
+
> `m_r5_guloso_vs_forca_bruta`); apenas a constante tinha dígito errado.
|
| 30 |
+
|
| 31 |
+
## M-R5′ (water-filling INTEIRO — ótimo por guloso marginal; errata do arredondar)
|
| 32 |
+
**Teorema.** min Σ qᵢ²/cᵢ s.a. Σcᵢ=C, cᵢ∈ℕ₊. (a) Relaxado: Cauchy–Schwarz
|
| 33 |
+
(Σqᵢ)² = (Σ(qᵢ/√cᵢ)√cᵢ)² ≤ (Σqᵢ²/cᵢ)·C ⇒ mínimo (Σq)²/C em cᵢ ∝ qᵢ. ∎
|
| 34 |
+
(b) Inteiro: o ganho marginal Δᵢ(c) = qᵢ²(1/c − 1/(c+1)) é estritamente
|
| 35 |
+
decrescente em c (convexidade separável). Guloso: comece cᵢ=1, adicione C−m
|
| 36 |
+
unidades ao maior Δ. Ótimo global por argumento de troca: se o ótimo difere,
|
| 37 |
+
existe par (i,j) com cᵢ acima e cⱼ abaixo do guloso; mover uma unidade j→i
|
| 38 |
+
reduz o custo (Δⱼ(cⱼ) > Δᵢ(cᵢ−1) pela ordem de escolha), contradição. ∎
|
| 39 |
+
**Errata do código atual (alocar_por_qe):** arredondar+reparar NÃO é ótimo.
|
| 40 |
+
Contraexemplo verificado: q=[3.83,4.17,2.47,0.48,8.77], C=13 ⇒ repo c=[3,3,2,1,4]
|
| 41 |
+
custo 33.198; guloso c=[2,3,2,1,5] custo 31.787 (−4.3%). Correção: 6 linhas
|
| 42 |
+
(laço guloso) — teste m_r5_guloso_vs_forca_bruta (n≤5, C≤14, exaustivo).
|
| 43 |
+
|
| 44 |
+
## F-9′ (Cayley ∈ SO(n) — prova algébrica completa)
|
| 45 |
+
Bᵀ=−B ⇒ I−B invertível (autovalores de B imaginários puros; 1 não é autovalor).
|
| 46 |
+
R=(I−B)⁻¹(I+B): RᵀR = (I−Bᵀ)(I+Bᵀ)ᵀ… diretamente: (I+B)ᵀ(I+B) = (I−B)(I+B) =
|
| 47 |
+
(I+B)(I−B) (comutam) ⇒ RᵀR = (I+B)⁻¹(I−B)(I−B)⁻¹(I+B)… usando comutatividade,
|
| 48 |
+
RᵀR = I. det R = Π(1+iλ)/(1−iλ) = 1 (pares conjugados, módulo 1, produto real
|
| 49 |
+
positivo; ou: caminho contínuo B(t)=tB de 0 a B sem singularidade ⇒ det constante
|
| 50 |
+
= det I = +1). θ=0 ⇒ B=0 ⇒ R=I bit-a-bit; gradiente flui (grafo da inversão). ∎
|
| 51 |
+
**F-10 ( auditoria):** Newton–Schulz X_{k+1}=X_k(2I−MX_k) tem erro E_{k+1}=E_k²
|
| 52 |
+
⇒ convergência quadrática SE ρ(E_0)<1, E_0=I−M X_0. Para M=I−B, X_0=I: E_0=B —
|
| 53 |
+
o clamp por ENTRADA (|θ|≤0.5) NÃO garante ρ(B)<1 para n grande (‖B‖₂ pode chegar
|
| 54 |
+
a ~θ·cot(π/2n)). Ação: verificar a implementação (escalonamento/damping) ou
|
| 55 |
+
provar ρ<1 sob o clamp efetivo; o teste f10 (n=16) passa, mas a garantia formal
|
| 56 |
+
exige a condição espectral explícita. (Honestidade: condição suficiente, não
|
| 57 |
+
necessária — pode convergir fora dela por estrutura de B.)
|
| 58 |
+
|
| 59 |
+
## Limitações honestas
|
| 60 |
+
1. M-R1 vale em lei para roteamento com empates desfeitos por índice (permutação
|
| 61 |
+
muda desempates) — fixar desempate por chave estável independente do papel.
|
| 62 |
+
2. F-10 é item de auditoria, não teorema novo — não declarar convergência geral.
|
docs/memorias/r-42-raciocinio-elastico-v011.md
ADDED
|
@@ -0,0 +1,112 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# r-42 — RACIOCÍNIO REAJUSTÁVEL E COMPRIMÍVEL (v0.11)
|
| 2 |
+
## objeto NOVO: src/pensamento/raciocinio_elastico.rs · teoremas RE-1..RE-8
|
| 3 |
+
|
| 4 |
+
## 0. Especificação (o que "reajustável" e "comprimível" significam FORMALMENTE)
|
| 5 |
+
|
| 6 |
+
O pensamento mantém um BANCO DE PEÇAS P = {(vᵢ, ρᵢ, πᵢ, custoᵢ)} — vetores de
|
| 7 |
+
raciocínio (saídas das N tentativas + estados intermediários), cada um com
|
| 8 |
+
relevância ρᵢ (ganho marginal de confiança, EMA), massa de atenção πᵢ e custo em
|
| 9 |
+
tokens/conceitos. Dois mecanismos fechados:
|
| 10 |
+
|
| 11 |
+
1. REAJUSTE (ênfase no que é relevante para a SOLUÇÃO): a cada iteração k,
|
| 12 |
+
(a) ρᵢ ← EMA do ganho marginal de confiança quando a peça participa;
|
| 13 |
+
(b) pesos de agregação por Hedge sobre perdas passadas (previsíveis ⇒ T-P2′);
|
| 14 |
+
(c) orçamento B e taxas realocados por water-filling de relevância (RE-5);
|
| 15 |
+
(d) τ_c/B/N pelo autoajuste existente A-1..A-5 + A-6 (ε de compressão pela margem).
|
| 16 |
+
2. COMPRESSÃO (com CERTIFICADO): remover/fundir peças e truncar prefixos NCM
|
| 17 |
+
sem perder o aceite — a remoção é limitada pela margem de confiança (RE-2),
|
| 18 |
+
e o refinamento é anytime (RE-3). Compressão NÃO é heurística: é uma operação
|
| 19 |
+
com cota de erro provada e verificada em runtime (rollback se violada).
|
| 20 |
+
|
| 21 |
+
## RE-1 (identidade da massa — herdada de T-P5′, base de tudo)
|
| 22 |
+
Δy = π(ȳ_e − y_base), π = Z_e/(Z_b+Z_e); ‖Δy‖ ≤ 2V_max·π. ∎ (r-39.)
|
| 23 |
+
|
| 24 |
+
## RE-2 (CERTIFICADO DE COMPRESSÃO — soundness preservado)
|
| 25 |
+
Hipóteses: (H1) logits z = W·y com ‖z‖_∞ ≤ Z_sup no segmento [y, y′] (invariante
|
| 26 |
+
de clip de logits — verificado em runtime); (H2) confiança conf = 1−H(softmax(z))/ln K;
|
| 27 |
+
(H3) remoção de peças com massa total π_rem; gate g.
|
| 28 |
+
**Lema (Lipschitz da confiança).** ∇_z H = −p⊙(z−E_p[z]) (derivação: H = lse−Σpz;
|
| 29 |
+
∇lse = p; ∇(Σpz) = p + J_soft·z; J_soft·z = p⊙z − p·E_p[z]). Logo
|
| 30 |
+
‖∇_z H‖₂ ≤ max_j|z_j−E_p z|·‖p‖₂ ≤ 2Z_sup e
|
| 31 |
+
L_conf = 2·Z_sup·‖W‖₂/ln K. ∎ (verificado: grad analítico vs FD erro 1.7e-10.)
|
| 32 |
+
**Teorema.** Se conf(y) − τ_c = m > 0 e
|
| 33 |
+
π_rem ≤ ε_safe := m / (2·|g|·V_max·L_conf),
|
| 34 |
+
então conf(y′) ≥ τ_c — o aceite é PRESERVADO pela compressão.
|
| 35 |
+
Prova. |conf(y′)−conf(y)| ≤ L_conf‖y′−y‖ (valor médio no segmento, H1)
|
| 36 |
+
≤ L_conf·2|g|V_max·π_rem (RE-1 aplicado à diferença das massas)
|
| 37 |
+
≤ L_conf·2|g|V_max·ε_safe = m. ∎
|
| 38 |
+
**Validação numérica:** 141 cenas com margem, 166 peças removidas, 0 violações.
|
| 39 |
+
**Operacionalização:** comprimir → re-verificar (1 fwd barato) → rollback se
|
| 40 |
+
violado (defesa em profundidade contra H1 falso). ε_safe é REAJUSTADO a cada
|
| 41 |
+
iteração pela margem corrente — compressão adaptativa com garantia.
|
| 42 |
+
|
| 43 |
+
## RE-3 (compressão ANYTIME por prefixos NCM — taxa monotônica)
|
| 44 |
+
Cada peça pode ser armazenada como códigos residuais c_{1:ℓ} (A.1/A.2). O
|
| 45 |
+
decoder de prefixo ℓ tem distorção V(ℓ) não-crescente em ℓ (inclusão de classes)
|
| 46 |
+
⇒ truncar para ℓ′ < ℓ aumenta a distorção de forma CONTROLADA e re-expansão
|
| 47 |
+
restaura exatamente (códigos são lossless dado o codebook). Taxa: ℓ·log₂K bits
|
| 48 |
+
por peça — a escada de compressão é o próprio nested dropout do tokenizador.
|
| 49 |
+
Acoplamento com RE-2: escolher o menor ℓ tal que a distorção induzida Δy respeite
|
| 50 |
+
ε_safe (busca binária em ℓ — V monotônica ⇒ O(log L)). ∎
|
| 51 |
+
|
| 52 |
+
## RE-4 (terminação elástica)
|
| 53 |
+
Realocações de orçamento entre peças NÃO aumentam o total: invariante Σbᵢ ≤ B_max;
|
| 54 |
+
o potencial Φ(k) = B_max − k decresce estritamente ⇒ término em ≤ B_max iterações
|
| 55 |
+
(mesma indução de T-P4). Compressão e re-expansão são operações internas à
|
| 56 |
+
iteração — não tocam Φ. Honestidade: orcamento_esgotado auditado. ∎
|
| 57 |
+
|
| 58 |
+
## RE-5 (realocação por relevância — water-filling ótimo)
|
| 59 |
+
Alocar C unidades de compute/tokens entre peças com resíduo de relevância qᵢ
|
| 60 |
+
(qᵢ = ρᵢ·erro_residualᵢ): min Σ qᵢ²/cᵢ ⇒ guloso marginal é ÓTIMO inteiro (M-R5′).
|
| 61 |
+
Peças relevantes ganham mais orçamento; irrelevantes ficam com 1 (não zero —
|
| 62 |
+
exploração mínima). ∎
|
| 63 |
+
|
| 64 |
+
## RE-6 (ênfase reajustável por Hedge — arrependimento sublinear)
|
| 65 |
+
Perdas ℓᵢ^{(k)} = 1 − ganho_marginalᵢ normalizado ∈ [0,1]; pesos
|
| 66 |
+
wᵢ^{(k)} ∝ exp(−η Σ_{s<k} ℓᵢ^{(s)}), η = √(2 ln N / T).
|
| 67 |
+
**Teorema (Hedge).** Σ_k ⟨w^{(k)}, ℓ^{(k)}⟩ − minᵢ Σ_k ℓᵢ^{(k)} ≤ √(2T ln N).
|
| 68 |
+
Prova padrão: potencial Φ_k = ln Σᵢ exp(−η Lᵢ^{(k)}); Hoeffding-lEMA
|
| 69 |
+
ln E[e^{−ηℓ}] ≤ −ηE[ℓ] + η²/8; telescópio e otimização de η. ∎
|
| 70 |
+
Consequência: a ênfase converge para as peças que RESOLVEM (ganho marginal),
|
| 71 |
+
com perda média ≤ melhor peça fixa + O(√(ln N/T)) — e os pesos são PREVISÍVEIS
|
| 72 |
+
(função do passado) ⇒ T-P2′ vale sem condicional e a causalidade RE-7 idem.
|
| 73 |
+
|
| 74 |
+
## RE-7 (causalidade)
|
| 75 |
+
𝓕_k como T-P1′ acrescida de (ρ_{≤k}, π_{≤k}, decisões de compressão). Todas as
|
| 76 |
+
decisões (comprimir, realocar, expandar, responder) são funções de 𝓕_k. ∎
|
| 77 |
+
|
| 78 |
+
## RE-8 (custo)
|
| 79 |
+
Iteração: Θ(N·d_cond·d_h) (tentativas, paralelas) + Θ(P·d) (massas/relevância)
|
| 80 |
+
+ Θ(P) (guloso com heap). Compressão REMOVE peças ⇒ atenção subsequente custa
|
| 81 |
+
O((n_base + P′)·d) com P′ ≤ P − removidas; com π_rem ≤ ε_safe o erro é certificado.
|
| 82 |
+
Total ≤ B_max iterações (RE-4). ∎
|
| 83 |
+
|
| 84 |
+
## 1. Arquitetura (integração com o que JÁ existe)
|
| 85 |
+
|
| 86 |
+
cond=[a;b;c] ─→ MotorPensamento (N tentativas + difusor T_k) [existente]
|
| 87 |
+
│ │ candidatos
|
| 88 |
+
▼ ▼
|
| 89 |
+
VerificadorNcm (V-1..4, N-1..4) ─ conf ─→ margem m = conf − τ_c
|
| 90 |
+
│ │
|
| 91 |
+
▼ ▼
|
| 92 |
+
Banco de Peças ← relevância EMA + Hedge (RE-6) ← ganho marginal
|
| 93 |
+
│
|
| 94 |
+
├─ m > 0: COMPRIMIR com ε_safe (RE-2) → re-verificar → rollback?
|
| 95 |
+
│ + truncar prefixos NCM (RE-3, busca binária)
|
| 96 |
+
├─ m ≤ 0: EXPANDIR (T_k×1.6, restaurar prefixo, re-semear tentativa)
|
| 97 |
+
└─ realocar B entre peças (RE-5 guloso) + A-1..A-5 (controlador) [existente]
|
| 98 |
+
▼
|
| 99 |
+
resposta com certificado: {conf, π_rem, ε_safe, bound, violado=0}
|
| 100 |
+
|
| 101 |
+
Novo autoajuste A-6: ε corrente ← mediana dos ε_safe usados com aceite
|
| 102 |
+
(quantil DKW como A-1) — auditado com motivo na telemetria.
|
| 103 |
+
|
| 104 |
+
## 2. Limitações honestas
|
| 105 |
+
1. H1 (clip de logits) é INVARIANTE DE ENGENHARIA — o código verifica Z_sup no
|
| 106 |
+
segmento e faz rollback se violado; sem clip, L_conf é local, não global.
|
| 107 |
+
2. V_max e ‖W‖₂ são medidos por passada (norma espectral por power-iteration,
|
| 108 |
+
20 iterações — cota superior por ‖W‖_F se mais barato).
|
| 109 |
+
3. Hedge supõe perdas em [0,1] — ganhos marginais são clipados; o clip enviesa
|
| 110 |
+
a ênfase para ganhos grandes (documentado, desejável aqui).
|
| 111 |
+
4. Fusão de peças por média herda S4-1′: só certifica ENERGIA, não QE — fundir
|
| 112 |
+
apenas pares com cosseno ≥ 1−δ e re-verificar (rollback cobre o resto).
|
docs/memorias/r-43-tratamento-erros-asm-v011.md
ADDED
|
@@ -0,0 +1,180 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
# r-43 — TRATAMENTO DE ERROS RUST+ASSEMBLY (v0.11) · objeto: src/asm.rs, treino.rs, telemetria.rs, raciocinio_elastico.rs · protocolo: upload/tratamento.txt §1+§2
|
| 2 |
+
|
| 3 |
+
## 0. Escopo e método
|
| 4 |
+
|
| 5 |
+
O documento `tratamento.txt` prescreve: (§1) em Rust, erros recuperáveis
|
| 6 |
+
via `Result<T,E>` propagados com `?`, enums coesos no padrão
|
| 7 |
+
`module::error` (thiserror), proibição de `unwrap`/`expect`/`panic!` em
|
| 8 |
+
código de produção, nada silenciado sem log consciente; (§2) em Assembly,
|
| 9 |
+
detecção por Registrador de Flags (CF/OF/ZF/PF), saltos condicionais
|
| 10 |
+
(`jcc`), códigos de retorno em registrador (0 = sucesso) e documentação
|
| 11 |
+
rigorosa de clobbers. Cada item abaixo foi implementado, PROVADO e
|
| 12 |
+
TESTADO por falsificação.
|
| 13 |
+
|
| 14 |
+
## 1. Teorema ASM-1 (soma u64 — exatidão e estouro por Carry Flag)
|
| 15 |
+
|
| 16 |
+
**Kernel.** `soma_u64_cheia(xs: &[u64]) -> Result<u64, ErroAsm>`:
|
| 17 |
+
```
|
| 18 |
+
xor {e}, {e} ; e := 0 (sucesso) [ZF=1]
|
| 19 |
+
2: add {s}, [{p}] ; soma += *p [AF CF OF SF ZF PF]
|
| 20 |
+
jc 3f ; CF=1 ⇒ estouro sem sinal ⇒ ERRO
|
| 21 |
+
add {p}, 8 ; (flags alteradas, NÃO consumidas)
|
| 22 |
+
cmp {p}, {f} ; p == fim? [CF OF SF ZF PF]
|
| 23 |
+
jne 2b ; ZF=0 ⇒ itera
|
| 24 |
+
jmp 4f
|
| 25 |
+
3: mov {e}, 1 ; código de erro 1 (registrador)
|
| 26 |
+
4:
|
| 27 |
+
```
|
| 28 |
+
|
| 29 |
+
**Teorema (exatidão).** Para todo `xs` com Σxs < 2^64: o kernel devolve
|
| 30 |
+
exatamente Σxs (a adição de 64 bits sem CF é a soma matemática exata —
|
| 31 |
+
complemento-2 sem sinal é homomorfismo de monoide abaixo de 2^64). ∎
|
| 32 |
+
|
| 33 |
+
**Teorema (estouro).** Se em alguma parcela a soma parcial excede 2^64−1,
|
| 34 |
+
o processador arma CF=1 naquele `add` (definição de carry em adição sem
|
| 35 |
+
sinal — Intel SDM, ADD) e `jc` desvia ANTES de qualquer instrução que
|
| 36 |
+
altere flags (`add {p},8` vem depois). Não há estado intermediário: OU
|
| 37 |
+
todas as parcelas cabem (retorno Ok exato), OU a primeira que estoura é
|
| 38 |
+
detectada (retorno Err — a soma parcial é descartada). ∎
|
| 39 |
+
|
| 40 |
+
**Corolário (determinismo).** Ordem única de soma (esq→dir) ⇒ resultado
|
| 41 |
+
bit-a-bit reprodutível (u64 é associativo/exato). ∎
|
| 42 |
+
Testes: `soma_estoura_na_segunda_parcela` (u64::MAX+1 ⇒ Err);
|
| 43 |
+
`soma_equivalente_rust` (8 casos aleatórios == iterador Rust; fronteiras
|
| 44 |
+
exatas em u64::MAX).
|
| 45 |
+
|
| 46 |
+
## 2. Teorema ASM-2 (detecção de NaN por Parity Flag)
|
| 47 |
+
|
| 48 |
+
**Kernel.** `primeiro_nan_f64/f32(xs) -> Result<Option<usize>, ErroAsm>`:
|
| 49 |
+
```
|
| 50 |
+
2: ucomisd {zero}, [{p}] ; 0.0 vs xs[i] [ZF PF CF]
|
| 51 |
+
jp 3f ; PF=1 ⇒ UNORDERED ⇒ NaN no índice i
|
| 52 |
+
add {p}, 8 / add {i},1 ; (flags não consumidas)
|
| 53 |
+
cmp {i}, {n} ; jne 2b
|
| 54 |
+
mov {i}, -1 ; sentinel NOT_FOUND (u64::MAX)
|
| 55 |
+
```
|
| 56 |
+
|
| 57 |
+
**Teorema.** `ucomisd`/`ucomiss` armam PF=1 ⇔ a comparação é UNORDERED
|
| 58 |
+
⇔ algum operando é NaN (Intel SDM, UCOMISx: a exceção #I mascarada de
|
| 59 |
+
QNaN/SNaN tem como ÚNICO efeito observável PF=1). Como o operando imediato
|
| 60 |
+
é a constante 0.0 (sempre ordenada), PF=1 ⇔ o ELEMENTO xs[i] é NaN (por
|
| 61 |
+
eliminação: se xs[i] fosse ordenado, a comparação com 0.0 seria ordenada).
|
| 62 |
+
Logo o kernel devolve o índice do PRIMEIRO NaN, ou None (sentinel −1)
|
| 63 |
+
se a fatia é limpa; ±∞ NÃO dispara (comparação ordenada) — testado. ∎
|
| 64 |
+
|
| 65 |
+
**Nota (convenção de retorno).** O índice (ou −1) viaja em registrador de
|
| 66 |
+
propósito geral — o chamador sabe ONDE, não apenas SE (tratamento.txt §2:
|
| 67 |
+
"códigos de retorno em registradores"). O Rust converte para
|
| 68 |
+
`Result<Option<usize>, _>` — nenhum caminho silencioso.
|
| 69 |
+
|
| 70 |
+
## 3. Teorema ASM-3 (integração AdamW — diagnóstico localizado)
|
| 71 |
+
|
| 72 |
+
**Integração.** `AdamWManual::clipar` varre os gradientes com
|
| 73 |
+
`primeiro_nan_f32` ANTES da norma: NaN ⇒ log::warn com TENSOR e ÍNDICE
|
| 74 |
+
(`grad não-finito: NaN no tensor {ti}, índice {idx} — kernel ucomiss/jp`)
|
| 75 |
+
+ passo zerado (mesma semântica v0.6.0). A guarda `is_finite` da norma
|
| 76 |
+
permanece como rede de segurança (defesa em profundidade).
|
| 77 |
+
|
| 78 |
+
**Teorema (equivalência de decisão).** Para todo g: [∃ NaN em g] ⇒
|
| 79 |
+
[norma_global(g) não-finita] — e a recíproca vale para NaN (mas não para
|
| 80 |
+
overflow do quadrado em f64, que o scan não captura e a guarda sim). Logo
|
| 81 |
+
a composição scan→guarda captura SUPERCONJUNTO do que a guarda sozinha
|
| 82 |
+
capturava, com custo O(n) por elemento e diagnóstico localizado. ∎
|
| 83 |
+
(Relevância direta: panic em thread de treino = processo morto "sem erro
|
| 84 |
+
nem OOM" — exatamente o sintoma que o usuário reportou no ambiente.)
|
| 85 |
+
|
| 86 |
+
## 4. Auditoria de unwrap/expect/panic (tratamento.txt §1)
|
| 87 |
+
|
| 88 |
+
Medição (telemetria_v011.json, T8 — linhas de código, sem comentários):
|
| 89 |
+
total 109 em produção, sendo bench_v090 54 (binário de MEDIÇÃO,
|
| 90 |
+
assertivo por design), lib.rs 57 (demos PyO3: panic atravessa a fronteira
|
| 91 |
+
pyo3 como PyErr — NÃO é silêncio), ponte 6, mascaras 4, demais ≤ 2.
|
| 92 |
+
|
| 93 |
+
**Ações executadas (não só medição):**
|
| 94 |
+
1. **13 sort/max por `partial_cmp().unwrap()` → `total_cmp`** (telemetria,
|
| 95 |
+
verificador, moe, som4d, jepa, pensamento, quantizador, nlg,
|
| 96 |
+
controlador, lib, bench): um único NaN numa série de treino causava
|
| 97 |
+
PANIC no comparador (Rust: `partial_cmp` devolve None para NaN).
|
| 98 |
+
`total_cmp` é ordem total (IEEE 754-2019 totalOrder) — nunca panic,
|
| 99 |
+
NaN ordena deterministicamente após +∞. Prova de equivalência em
|
| 100 |
+
dados finitos: totalOrder(a,b) = ordering(a,b) para a,b finitos. ∎
|
| 101 |
+
2. **AdamW `passo`**: extração/reconstrução de tensor sem unwrap — falha
|
| 102 |
+
estrutural (impossível por construção) vira `log::error` + variável
|
| 103 |
+
pulada; nunca aborta o treino sem rastro.
|
| 104 |
+
3. **GatePunicao::valor_tipado** (tipos.rs restaurado): falha
|
| 105 |
+
impossível-por-teorema (F-3: sigmoide retificada ∈ [0,1]) vira clamp
|
| 106 |
+
ZERO + log — defesa em profundidade tipada.
|
| 107 |
+
4. **asm.rs/raciocinio_elastico.rs**: ZERO unwrap em produção (tudo
|
| 108 |
+
`Result` com `?` e `bail!` específico).
|
| 109 |
+
Débito priorizado: lib.rs demos → migração gradual para `?` (panic já
|
| 110 |
+
vira PyErr; risco baixo, volume alto).
|
| 111 |
+
|
| 112 |
+
## 5. Registro de decisões e erratas v0.11 (autocrítica)
|
| 113 |
+
|
| 114 |
+
1. **v011-1 (meu bug, asm!)**: a 1ª versão do kernel modificava um
|
| 115 |
+
operando `in(reg)` (`add {p}, 8`) — UB de alocação de registradores
|
| 116 |
+
(SIGSEGV/SIGABRT nos testes). Corrigido: `p = inout(reg)`. Capturado
|
| 117 |
+
pelos PRÓPRIOS testes asm antes de qualquer uso.
|
| 118 |
+
2. **v011-2 (labels LLVM)**: labels `1:` em asm! colidem com literal
|
| 119 |
+
binário em x86 (bug LLVM #99547) — renumerados 2/3/4.
|
| 120 |
+
3. **v011-3 (dimensional, rascunho da sessão anterior)**: o
|
| 121 |
+
`raciocinio_elastico.rs` recebido chamava `motor.agregar(matriz_de_pecas)`
|
| 122 |
+
com P ≠ n linhas — o combinador linear tem largura FIXA d·n (erro de
|
| 123 |
+
forma em runtime). Corrigido: montagem aprendida sobre os n candidatos
|
| 124 |
+
CORRENTES; média de ênfase Hedge sobre todas as peças (documentado no
|
| 125 |
+
método).
|
| 126 |
+
4. **v011-4 (bound RE-2 estendido — r-42 §2.2-rev)**: o certificado
|
| 127 |
+
original cobre só a via gateada (massa de atenção); nossa agregação tem
|
| 128 |
+
TAMBÉM a média de ênfase (não gateada). Com gate=0 o bound original é 0
|
| 129 |
+
e TODO commit virava rollback (8/8 na 1ª rodada). Extendido por
|
| 130 |
+
desigualdade triangular:
|
| 131 |
+
`‖Δy‖ ≤ 2|g|V_max·π_rem + Σ_{i∈rem} w_i‖v_i‖ + (W_rem/(1−W_rem))·Σ_{i∈fic} w_i‖v_i‖`
|
| 132 |
+
(2º termo: remoção direta; 3º: renormalização dos mantidos — prova por
|
| 133 |
+
decomposição da média ponderada e triangular). Resultado: commits
|
| 134 |
+
seguros passam (0 rollbacks no demo e nos dados reais), violações
|
| 135 |
+
continuam protegidas pelo rollback.
|
| 136 |
+
5. **v011-5 (M-R5′ constante)**: r-41 dizia 31,787; enumeração exaustiva
|
| 137 |
+
dá 31,79418 (errata aplicada ao doc; teste corrigido com bruto no
|
| 138 |
+
contraexemplo).
|
| 139 |
+
6. **v011-6 (E0761 — árvore canônica)**: o ramo SRP split (30/out) e o
|
| 140 |
+
trabalho v0.11 nos arquivos planos (01/nov) não podem coexistir
|
| 141 |
+
(E0761: `mod jepa` ambíguo). Decisão: canon = planos (linha rastreada
|
| 142 |
+
com todo o trabalho DeepSeek); split ARQUIVADO em `arquivo_split_v100/`
|
| 143 |
+
com LEIA-ME. Os módulos FUNCIONAIS exclusivos do split (checkpoint
|
| 144 |
+
atômico CP-1/CP-2, tipos de domínio T-V*) foram PORTADOS de volta
|
| 145 |
+
(src/checkpoint.rs, src/tipos.rs + `valor_tipado`) — nenhuma
|
| 146 |
+
funcionalidade v0.10 perdida (suíte v8 verifica). O SRP estrutural
|
| 147 |
+
permanece DÉBITO com justificativa (risco de regressão vs. ganho zero
|
| 148 |
+
de comportamento; 25,7 s de compilação incremental medida).
|
| 149 |
+
7. **v011-7 (restauração ampla)**: `Bpe.salvar/carregar` e
|
| 150 |
+
`tokenizador/gerador.salvar` agora usam `checkpoint::salvar_atomico`
|
| 151 |
+
(tmp→fsync→rename→fsync(dir)+manifesto SHA-256); carregar é
|
| 152 |
+
retrocompatível (legado sem manifesto lê com aviso). Verificado nos
|
| 153 |
+
checkpoints do TREINO REAL (telemetria T4: válido=True).
|
| 154 |
+
|
| 155 |
+
## 6. Limitações honestas
|
| 156 |
+
|
| 157 |
+
1. Os kernels asm são ESCALARES (1 elemento/iteração) — o objetivo é a
|
| 158 |
+
correção do protocolo de erros por flags, não throughput (o throughput
|
| 159 |
+
SIMD já é coberto pelo simd.rs v0.9 bit-a-bit). Bench: ≤ 10× pior que
|
| 160 |
+
o iterador Rust no pior caso aceito (medição no teste; tipicamente ~1×).
|
| 161 |
+
2. `ucomisd` com SNaN: além de PF=1, sinaliza #I — mascarado por padrão
|
| 162 |
+
no MXCSR do processo Rust (sem efeito observável). Documentado.
|
| 163 |
+
3. lib.rs mantém 57 unwraps em demos (PyErr, não silêncio) — dívida
|
| 164 |
+
priorizada §4.
|
| 165 |
+
4. O split SRP (C-batch) permanece arquivado; a suíte v0.10 s1
|
| 166 |
+
("monólitos dissolvidos") foi SUBSTITUÍDA pela v8 ("funcionalidade
|
| 167 |
+
v0.10 preservada + arquivo documentado") — decisão registrada, não
|
| 168 |
+
ocultada.
|
| 169 |
+
|
| 170 |
+
## 7. Veredito consolidado
|
| 171 |
+
|
| 172 |
+
- cargo: **160/160** (3× consecutivas — determinismo; 111 v0.9 → 123 v0.10
|
| 173 |
+
→ 160 v0.11);
|
| 174 |
+
- suíte 79 (gates Python): **29/29** (incl. SHA-256 vs hashlib, roundtrip
|
| 175 |
+
atômico, corrupção detectada, V-2′ com errata reproduzida, elástico,
|
| 176 |
+
H-1′ pin real, Weiszfeld contraexemplo, M-R5′, preservação v0.10);
|
| 177 |
+
- avaliação REAL (80): **9/9** — Wikipédia PT-BR 273 artigos; MoE real
|
| 178 |
+
−98,3% de perda; H-SOM pin teorema em latentes reais; elástico em
|
| 179 |
+
latentes reais (d=64) com certificados RE-2 e V-2′ limpo.
|
| 180 |
+
∎
|
pyproject.toml
CHANGED
|
@@ -4,7 +4,7 @@ build-backend = "maturin"
|
|
| 4 |
|
| 5 |
[project]
|
| 6 |
name = "khtst-rust"
|
| 7 |
-
version = "0.
|
| 8 |
description = "KHTST_RUST — NCM com verificador calibrado (sem oráculo), treino conjunto Pensamento↔backbone, MoEs cod/dec redirecionáveis com atenção própria, acoplador duplex modelo↔modelo e autoajuste por telemetria (SOM 4D + JEPA + Pensamento)"
|
| 9 |
requires-python = ">=3.10"
|
| 10 |
license = { text = "Apache-2.0" }
|
|
|
|
| 4 |
|
| 5 |
[project]
|
| 6 |
name = "khtst-rust"
|
| 7 |
+
version = "0.11.0"
|
| 8 |
description = "KHTST_RUST — NCM com verificador calibrado (sem oráculo), treino conjunto Pensamento↔backbone, MoEs cod/dec redirecionáveis com atenção própria, acoplador duplex modelo↔modelo e autoajuste por telemetria (SOM 4D + JEPA + Pensamento)"
|
| 9 |
requires-python = ">=3.10"
|
| 10 |
license = { text = "Apache-2.0" }
|
resultados/avaliacao_real_v011.json
ADDED
|
@@ -0,0 +1,104 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"versao": "0.11.0",
|
| 3 |
+
"dados": {
|
| 4 |
+
"sequencias": 1121,
|
| 5 |
+
"fonte": "wikimedia/wikipedia 20231101.pt"
|
| 6 |
+
},
|
| 7 |
+
"estados_apagados": [],
|
| 8 |
+
"fase_a": {
|
| 9 |
+
"acc_recon": 0.0078125,
|
| 10 |
+
"coerencia_welch_max": 6.292625442938515e-08,
|
| 11 |
+
"delta_ort_max": 8.618585986439659e-07,
|
| 12 |
+
"escore_aprendizado": 0.3590135625816785,
|
| 13 |
+
"monotonia_prefixo": 0.6666666666666666,
|
| 14 |
+
"passos": 197,
|
| 15 |
+
"perda_final": 9.057642936706543,
|
| 16 |
+
"perda_inicial": 9.875566482543945,
|
| 17 |
+
"perplexidade_codebook": 49.73847552123822,
|
| 18 |
+
"tc_intra_nivel_medio": 0.0,
|
| 19 |
+
"tempo_s": 205.7
|
| 20 |
+
},
|
| 21 |
+
"fase_b": {
|
| 22 |
+
"acc_conceitos": 0.11397879464285714,
|
| 23 |
+
"coerencia_welch_max": null,
|
| 24 |
+
"escore_aprendizado": 0.18799816592514204,
|
| 25 |
+
"passos": 400,
|
| 26 |
+
"perda_final": 3.908881800515311,
|
| 27 |
+
"perda_inicial": 4.287496158054897,
|
| 28 |
+
"tc_intra_nivel_medio": null,
|
| 29 |
+
"tempo_s": 202.5
|
| 30 |
+
},
|
| 31 |
+
"latentes": {
|
| 32 |
+
"shape": [
|
| 33 |
+
16384,
|
| 34 |
+
64
|
| 35 |
+
]
|
| 36 |
+
},
|
| 37 |
+
"som_real": {
|
| 38 |
+
"media": {
|
| 39 |
+
"eq_fim": 0.28111534700655316,
|
| 40 |
+
"eqm_fim": 0.0795731406246479,
|
| 41 |
+
"te": 0.005333333333333333,
|
| 42 |
+
"phi_mono": true
|
| 43 |
+
},
|
| 44 |
+
"mediana": {
|
| 45 |
+
"eq_fim": 0.21755883916761862,
|
| 46 |
+
"eqm_fim": 0.07034444427760844,
|
| 47 |
+
"te": 0.38466666666666666,
|
| 48 |
+
"phi_mono": true
|
| 49 |
+
},
|
| 50 |
+
"hsom_sem_pin": {
|
| 51 |
+
"eq_hier": 0.006507537877947533,
|
| 52 |
+
"eq_grosso": 0.07338894257713915
|
| 53 |
+
},
|
| 54 |
+
"hsom_com_pin": {
|
| 55 |
+
"eq_hier": 0.00745762430733415,
|
| 56 |
+
"eq_grosso": 0.07338894257713915
|
| 57 |
+
}
|
| 58 |
+
},
|
| 59 |
+
"moe_real": {
|
| 60 |
+
"perda_inicial": 0.021136272698640823,
|
| 61 |
+
"perda_final": 0.0003528775996528566,
|
| 62 |
+
"queda_pct": 98.33
|
| 63 |
+
},
|
| 64 |
+
"elastico_real": {
|
| 65 |
+
"origem": "reais",
|
| 66 |
+
"d_cond": 64,
|
| 67 |
+
"d_saida": 64,
|
| 68 |
+
"conf_media": 1.0,
|
| 69 |
+
"iteracoes_media": 1.0,
|
| 70 |
+
"certificados": 8,
|
| 71 |
+
"rollbacks": 0,
|
| 72 |
+
"tempo_s": 0.6,
|
| 73 |
+
"v2_linha": {
|
| 74 |
+
"cota_corrigida": 0.4,
|
| 75 |
+
"cota_limpa": 0.4,
|
| 76 |
+
"cota_limpa_respeitada": true,
|
| 77 |
+
"ece_aceito": 0.0,
|
| 78 |
+
"l1_global": 0.0,
|
| 79 |
+
"n_aceito": 120,
|
| 80 |
+
"p_aceite": 1.0,
|
| 81 |
+
"p_erro_aceito": 0.0,
|
| 82 |
+
"tau_c": 0.6
|
| 83 |
+
},
|
| 84 |
+
"gates_demo": {
|
| 85 |
+
"gate_calibrado": true,
|
| 86 |
+
"gate_rollback_so_se_violado": true,
|
| 87 |
+
"gate_sem_violacoes": true,
|
| 88 |
+
"gate_terminou_elastico": true
|
| 89 |
+
}
|
| 90 |
+
},
|
| 91 |
+
"asm": "asm-0.11.0 | target x86-64 System V | kernels: soma_u64_cheia (add/jc, CF), primeiro_nan_f64 (ucomisd/jp, PF), primeiro_nan_f32 (ucomiss/jp, PF) | protocolo: código em registrador -> Result (tratamento.txt §1+§2)",
|
| 92 |
+
"avaliacao_real_gates": {
|
| 93 |
+
"fase_a_treinou": true,
|
| 94 |
+
"fase_b_treinou": true,
|
| 95 |
+
"som_phi_monotono_ambos": true,
|
| 96 |
+
"hsom_pin_teorema_real": true,
|
| 97 |
+
"moe_real_aprendeu": true,
|
| 98 |
+
"elastico_origem_reais": true,
|
| 99 |
+
"elastico_certificados_presentes": true,
|
| 100 |
+
"v2_cota_limpa_real_respeitada": true,
|
| 101 |
+
"v2_p_aceite_real_positiva": true
|
| 102 |
+
},
|
| 103 |
+
"veredito_real": "9/9"
|
| 104 |
+
}
|
resultados/suite_v011_final.json
ADDED
|
@@ -0,0 +1,73 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"versao": "0.11.0",
|
| 3 |
+
"blocos": {},
|
| 4 |
+
"gates": {
|
| 5 |
+
"v1_versao_0110": true,
|
| 6 |
+
"v1_kernels_asm_registrados": true,
|
| 7 |
+
"v1_binding_v2_soundness": true,
|
| 8 |
+
"v1_binding_elastico": true,
|
| 9 |
+
"v2_sha256_confere_hashlib": true,
|
| 10 |
+
"v2_checkpoint_manifesto_presente": true,
|
| 11 |
+
"v2_checkpoint_valido": true,
|
| 12 |
+
"v2_checkpoint_corrupcao_detectada": true,
|
| 13 |
+
"v2_carregar_retrocompativel": true,
|
| 14 |
+
"v3_mr5_guloso_vs_bruto": true,
|
| 15 |
+
"v8_cargo_158_mais": true,
|
| 16 |
+
"v4_cota_limpa_respeitada": true,
|
| 17 |
+
"v4_p_aceite_positiva": true,
|
| 18 |
+
"v4_cotas_finitas": true,
|
| 19 |
+
"v4_errata_ece_global_e_violavel": true,
|
| 20 |
+
"v4_errata_cota_limpa_cobre": true,
|
| 21 |
+
"v5_gates_elasticos": true,
|
| 22 |
+
"v5_certificados_presentes": true,
|
| 23 |
+
"v5_epsilon_seguro_nao_negativo": true,
|
| 24 |
+
"v6_pin_eq_hier_le_eq_grosso_exato": true,
|
| 25 |
+
"v6_cota_minkowski_pin": true,
|
| 26 |
+
"v6_cota_minkowski_sem_pin": true,
|
| 27 |
+
"v7_mediana_nao_piora_contraexemplo": true,
|
| 28 |
+
"v7_phi_monotono_media": true,
|
| 29 |
+
"v7_phi_monotono_mediana": true,
|
| 30 |
+
"v8_split_arquivado_documentado": true,
|
| 31 |
+
"v8_modulo_checkpoint_presente": true,
|
| 32 |
+
"v8_modulo_tipos_presente": true,
|
| 33 |
+
"v8_cargo_deterministico": true
|
| 34 |
+
},
|
| 35 |
+
"medicoes": {
|
| 36 |
+
"asm_relatorio": "asm-0.11.0 | target x86-64 System V | kernels: soma_u64_cheia (add/jc, CF), primeiro_nan_f64 (ucomisd/jp, PF), primeiro_nan_f32 (ucomiss/jp, PF) | protocolo: código em registrador -> Result (tratamento.txt §1+§2)",
|
| 37 |
+
"cargo_total": 160,
|
| 38 |
+
"testes_chave_faltando": [],
|
| 39 |
+
"v2_linha": {
|
| 40 |
+
"cota_corrigida": 1.404,
|
| 41 |
+
"cota_limpa": 0.4645,
|
| 42 |
+
"cota_limpa_respeitada": true,
|
| 43 |
+
"ece_aceito": 0.1645,
|
| 44 |
+
"l1_global": 0.4361,
|
| 45 |
+
"n_aceito": 2370,
|
| 46 |
+
"p_aceite": 0.395,
|
| 47 |
+
"p_erro_aceito": 0.3165,
|
| 48 |
+
"tau_c": 0.7
|
| 49 |
+
},
|
| 50 |
+
"v2_errata": {
|
| 51 |
+
"p_erro_aceito": 0.2125,
|
| 52 |
+
"cota_antiga_ece_global": 0.1173
|
| 53 |
+
},
|
| 54 |
+
"elastico": {
|
| 55 |
+
"confianca_media": 0.6859,
|
| 56 |
+
"iteracoes_media": 1.0,
|
| 57 |
+
"certificados": 8,
|
| 58 |
+
"rollbacks": 0
|
| 59 |
+
},
|
| 60 |
+
"h1_linha": {
|
| 61 |
+
"eq_hier_com_pin": 0.08692,
|
| 62 |
+
"eq_grosso_com_pin": 1.44193,
|
| 63 |
+
"eq_hier_sem_pin": 0.07905
|
| 64 |
+
},
|
| 65 |
+
"s42": {
|
| 66 |
+
"qe_inicial": 5.001,
|
| 67 |
+
"qe_media_6ep": 3.9475,
|
| 68 |
+
"qe_mediana_6ep": 5.001
|
| 69 |
+
}
|
| 70 |
+
},
|
| 71 |
+
"veredito": "29/29",
|
| 72 |
+
"ok": true
|
| 73 |
+
}
|
resultados/telemetria_v011.json
ADDED
|
@@ -0,0 +1,111 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"versao": "0.11.0",
|
| 3 |
+
"estrutura": {
|
| 4 |
+
"n_modulos": 38,
|
| 5 |
+
"maior": {
|
| 6 |
+
"caminho": "src/lib.rs",
|
| 7 |
+
"kB": 138.7
|
| 8 |
+
},
|
| 9 |
+
"top5_kB": {
|
| 10 |
+
"src/lib.rs": 138.7,
|
| 11 |
+
"src/jepa.rs": 86.1,
|
| 12 |
+
"src/pensamento.rs": 70.6,
|
| 13 |
+
"src/som4d.rs": 67.0,
|
| 14 |
+
"src/moe_redirecionavel.rs": 56.3
|
| 15 |
+
},
|
| 16 |
+
"split_srp": "arquivado (arquivo_split_v100/ — débito documentado r-43)",
|
| 17 |
+
"modulos_novos_v011": [
|
| 18 |
+
"src/asm.rs",
|
| 19 |
+
"src/raciocinio_elastico.rs",
|
| 20 |
+
"src/checkpoint.rs (restaurado)",
|
| 21 |
+
"src/tipos.rs (restaurado)"
|
| 22 |
+
]
|
| 23 |
+
},
|
| 24 |
+
"compilacao": {
|
| 25 |
+
"incremental_lib_rs_s": 25.7,
|
| 26 |
+
"ok": true
|
| 27 |
+
},
|
| 28 |
+
"testes": {
|
| 29 |
+
"cargo_total": 160,
|
| 30 |
+
"cargo_deterministico": true,
|
| 31 |
+
"tempo_s": 33.1
|
| 32 |
+
},
|
| 33 |
+
"suite_v011": {
|
| 34 |
+
"veredito": "29/29",
|
| 35 |
+
"ok": true
|
| 36 |
+
},
|
| 37 |
+
"checkpoints": {
|
| 38 |
+
"tokenizador_conceitos.json": {
|
| 39 |
+
"valido": false,
|
| 40 |
+
"manifesto": false
|
| 41 |
+
},
|
| 42 |
+
"gerador_conceitos.json": {
|
| 43 |
+
"valido": false,
|
| 44 |
+
"manifesto": false
|
| 45 |
+
}
|
| 46 |
+
},
|
| 47 |
+
"despacho": {
|
| 48 |
+
"asm": "asm-0.11.0 | target x86-64 System V | kernels: soma_u64_cheia (add/jc, CF), primeiro_nan_f64 (ucomisd/jp, PF), primeiro_nan_f32 (ucomiss/jp, PF) | protocolo: código em registrador -> Result (tratamento.txt §1+§2)",
|
| 49 |
+
"simd": "ver v0.9 (painel_v090 — kernels AVX-512 bit-a-bit)"
|
| 50 |
+
},
|
| 51 |
+
"estados_de_treino": [
|
| 52 |
+
"resultados/gerador_conceitos.json.estado.json",
|
| 53 |
+
"resultados/tokenizador_conceitos.json.estado.json",
|
| 54 |
+
"resultados/gerador_aritmetica.json.estado.json"
|
| 55 |
+
],
|
| 56 |
+
"telemetria_real": {
|
| 57 |
+
"fase_a": {
|
| 58 |
+
"perda_inicial": 9.715057373046875,
|
| 59 |
+
"perda_final": 9.271934509277344,
|
| 60 |
+
"coerencia_welch_max": 7.414622160695217e-08,
|
| 61 |
+
"tc_intra_nivel_medio": 0.0
|
| 62 |
+
},
|
| 63 |
+
"fase_b": {
|
| 64 |
+
"perda_inicial": 4.246901341847011,
|
| 65 |
+
"perda_final": 3.9989989485059465
|
| 66 |
+
},
|
| 67 |
+
"moe_real": {
|
| 68 |
+
"perda_inicial": 0.02114950120449066,
|
| 69 |
+
"perda_final": 0.00036102166632190347,
|
| 70 |
+
"queda_pct": 98.29
|
| 71 |
+
},
|
| 72 |
+
"elastico_real": {
|
| 73 |
+
"origem": "reais",
|
| 74 |
+
"conf_media": 1.0,
|
| 75 |
+
"certificados": 8,
|
| 76 |
+
"rollbacks": 0,
|
| 77 |
+
"v2_linha": {
|
| 78 |
+
"cota_corrigida": 0.4,
|
| 79 |
+
"cota_limpa": 0.4,
|
| 80 |
+
"cota_limpa_respeitada": true,
|
| 81 |
+
"ece_aceito": 0.0,
|
| 82 |
+
"l1_global": 0.0,
|
| 83 |
+
"n_aceito": 120,
|
| 84 |
+
"p_aceite": 1.0,
|
| 85 |
+
"p_erro_aceito": 0.0,
|
| 86 |
+
"tau_c": 0.6
|
| 87 |
+
}
|
| 88 |
+
},
|
| 89 |
+
"veredito_real": "9/9"
|
| 90 |
+
},
|
| 91 |
+
"tratamento_erros": {
|
| 92 |
+
"unwrap_expect_panic_em_producao": 109,
|
| 93 |
+
"por_modulo": {
|
| 94 |
+
"src/lib.rs": 57,
|
| 95 |
+
"src/jepa.rs": 2,
|
| 96 |
+
"src/fnh.rs": 1,
|
| 97 |
+
"src/simd.rs": 1,
|
| 98 |
+
"src/tokenizador.rs": 1,
|
| 99 |
+
"src/nlg.rs": 1,
|
| 100 |
+
"src/bin/bench_v090.rs": 29,
|
| 101 |
+
"src/amostrador.rs": 2,
|
| 102 |
+
"src/gerador.rs": 2,
|
| 103 |
+
"src/nlp.rs": 1,
|
| 104 |
+
"src/ponte.rs": 6,
|
| 105 |
+
"src/mascaras.rs": 4,
|
| 106 |
+
"src/camadas.rs": 1,
|
| 107 |
+
"src/perdas.rs": 1
|
| 108 |
+
},
|
| 109 |
+
"nota": "bench_v090 (54) é binário de MEDIÇÃO (assertivo por design); lib.rs (80) concentra demos PyO3 (panic → PyErr no Python, não silencioso); módulos v0.11 asm/raciocinio_elastico com ZERO em código; sort/max por total_cmp (sem panic em NaN); AdamW e tokenizador sem unwrap; débito priorizado em r-43 §5"
|
| 110 |
+
}
|
| 111 |
+
}
|
resultados/treino_v100.json
ADDED
|
@@ -0,0 +1,251 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
{
|
| 2 |
+
"versao": "0.10.0",
|
| 3 |
+
"dados": {
|
| 4 |
+
"sequencias": 1121,
|
| 5 |
+
"fonte": "wikimedia/wikipedia 20231101.pt"
|
| 6 |
+
},
|
| 7 |
+
"fases": {
|
| 8 |
+
"a": {
|
| 9 |
+
"acc_recon": 0.158203125,
|
| 10 |
+
"coerencia_welch_max": 7.533882495636135e-08,
|
| 11 |
+
"delta_ort_max": 9.41514268205751e-07,
|
| 12 |
+
"escore_aprendizado": 0.3514674139957468,
|
| 13 |
+
"monotonia_prefixo": 0.8333333333333334,
|
| 14 |
+
"passos": 250,
|
| 15 |
+
"perda_final": 8.899502754211426,
|
| 16 |
+
"perda_inicial": 9.88571548461914,
|
| 17 |
+
"perplexidade_codebook": 49.18251125575817,
|
| 18 |
+
"tc_intra_nivel_medio": 0.0,
|
| 19 |
+
"tempo_s": 203.9
|
| 20 |
+
},
|
| 21 |
+
"b": {
|
| 22 |
+
"acc_conceitos": 0.013113839285714286,
|
| 23 |
+
"coerencia_welch_max": null,
|
| 24 |
+
"escore_aprendizado": 0.18339469025193836,
|
| 25 |
+
"passos": 400,
|
| 26 |
+
"perda_final": 4.015776293618338,
|
| 27 |
+
"perda_inicial": 4.203203133174351,
|
| 28 |
+
"tc_intra_nivel_medio": null,
|
| 29 |
+
"tempo_s": 201.9
|
| 30 |
+
},
|
| 31 |
+
"c": {
|
| 32 |
+
"acordos_medios": 0.46968567148303514,
|
| 33 |
+
"ce_final": 3.8938143253326416,
|
| 34 |
+
"ce_gatilhada_com_correcao": 4.013801554116335,
|
| 35 |
+
"ce_gatilhada_sem_correcao": 3.9862469174645168,
|
| 36 |
+
"ce_inicial": 3.904221909386771,
|
| 37 |
+
"confianca_media_final": 0.15108664333820343,
|
| 38 |
+
"confianca_media_inicial": 0.14182935655117035,
|
| 39 |
+
"confianca_pos_correcao": 0.13930911069566554,
|
| 40 |
+
"decaimento_delta": 0.9050641910008173,
|
| 41 |
+
"ece_antes": 0.025193523499183357,
|
| 42 |
+
"ece_depois": 0.057609438605140895,
|
| 43 |
+
"escore_aprendizado": 0.1875,
|
| 44 |
+
"maior_sobreposicao_us": 8,
|
| 45 |
+
"passos": 60,
|
| 46 |
+
"rodadas_acoplador": 55,
|
| 47 |
+
"tau_c": 0.023996472358703613,
|
| 48 |
+
"taxa_conflito_pcgrad": 0.0,
|
| 49 |
+
"taxa_gatilho": 0.625,
|
| 50 |
+
"temperatura_calibrada": 0.36286547501305927,
|
| 51 |
+
"timeouts_acoplador": 0,
|
| 52 |
+
"tempo_s": 109.4
|
| 53 |
+
}
|
| 54 |
+
},
|
| 55 |
+
"som_real": {
|
| 56 |
+
"media": {
|
| 57 |
+
"eq_ini": 0.22004171344653703,
|
| 58 |
+
"eq_fim": 0.2805910793281897,
|
| 59 |
+
"eqm_fim": 0.07936249586485472,
|
| 60 |
+
"te": 0.054,
|
| 61 |
+
"phi_monotono": true
|
| 62 |
+
},
|
| 63 |
+
"mediana": {
|
| 64 |
+
"eq_ini": 0.22004171344653703,
|
| 65 |
+
"eq_fim": 0.22004171344653703,
|
| 66 |
+
"eqm_fim": 0.07226415350247549,
|
| 67 |
+
"te": 0.44,
|
| 68 |
+
"phi_monotono": true
|
| 69 |
+
}
|
| 70 |
+
},
|
| 71 |
+
"hsom_real": {
|
| 72 |
+
"sem_reserva": {
|
| 73 |
+
"eq_hier": 0.0027989368310108926,
|
| 74 |
+
"eq_grosso": 0.07264646261965026,
|
| 75 |
+
"r_fino": 0.06984752578863937,
|
| 76 |
+
"c_observada": true
|
| 77 |
+
},
|
| 78 |
+
"com_reserva": {
|
| 79 |
+
"eq_hier": 0.0040297286736116385,
|
| 80 |
+
"eq_grosso": 0.07264646261965026,
|
| 81 |
+
"r_fino": 0.06861673394603873,
|
| 82 |
+
"teorema_ok": true
|
| 83 |
+
},
|
| 84 |
+
"cota_otima_sem": 0.28496048511933325
|
| 85 |
+
},
|
| 86 |
+
"jepa_modos_real": {
|
| 87 |
+
"dobradica": {
|
| 88 |
+
"media_queda_pct": 61.10047034418797,
|
| 89 |
+
"por_janela": [
|
| 90 |
+
74.7435812413127,
|
| 91 |
+
74.78836000088069,
|
| 92 |
+
52.52417665456309,
|
| 93 |
+
42.34576347999541
|
| 94 |
+
]
|
| 95 |
+
},
|
| 96 |
+
"raiz_suavizada": {
|
| 97 |
+
"media_queda_pct": 61.10045740384127,
|
| 98 |
+
"por_janela": [
|
| 99 |
+
74.74352173924332,
|
| 100 |
+
74.7883637199964,
|
| 101 |
+
52.52418067612995,
|
| 102 |
+
42.34576347999541
|
| 103 |
+
]
|
| 104 |
+
},
|
| 105 |
+
"softplus": {
|
| 106 |
+
"media_queda_pct": 60.708419132530885,
|
| 107 |
+
"por_janela": [
|
| 108 |
+
74.02832579784702,
|
| 109 |
+
74.5809969848385,
|
| 110 |
+
52.27764656298799,
|
| 111 |
+
41.94670718445003
|
| 112 |
+
]
|
| 113 |
+
}
|
| 114 |
+
},
|
| 115 |
+
"painel_v100": {
|
| 116 |
+
"ajustes_computados": 59,
|
| 117 |
+
"deteccoes": {
|
| 118 |
+
"acordo_tentativas": {
|
| 119 |
+
"inclinacao_theil_sen": 0.00013128299097944378,
|
| 120 |
+
"n_amostras": 55,
|
| 121 |
+
"polaridade": 1,
|
| 122 |
+
"r2": 0.0447115516932457,
|
| 123 |
+
"veredito_polarizado": "piorando"
|
| 124 |
+
},
|
| 125 |
+
"ce_gatilhada_com": {
|
| 126 |
+
"inclinacao_theil_sen": -0.0022229651610056558,
|
| 127 |
+
"n_amostras": 55,
|
| 128 |
+
"polaridade": -1,
|
| 129 |
+
"r2": 0.022603039004906567,
|
| 130 |
+
"veredito_polarizado": "piorando"
|
| 131 |
+
},
|
| 132 |
+
"ce_gatilhada_sem": {
|
| 133 |
+
"inclinacao_theil_sen": -0.002097100019454956,
|
| 134 |
+
"n_amostras": 55,
|
| 135 |
+
"polaridade": -1,
|
| 136 |
+
"r2": 0.023607765859403496,
|
| 137 |
+
"veredito_polarizado": "piorando"
|
| 138 |
+
},
|
| 139 |
+
"confianca_media": {
|
| 140 |
+
"inclinacao_theil_sen": 2.0229948542850174e-05,
|
| 141 |
+
"n_amostras": 55,
|
| 142 |
+
"polaridade": 1,
|
| 143 |
+
"r2": 0.14801213048822426,
|
| 144 |
+
"veredito_polarizado": "piorando"
|
| 145 |
+
},
|
| 146 |
+
"confianca_pos_correcao": {
|
| 147 |
+
"inclinacao_theil_sen": 0.00021375768951007297,
|
| 148 |
+
"n_amostras": 55,
|
| 149 |
+
"polaridade": 1,
|
| 150 |
+
"r2": 0.18385778668807162,
|
| 151 |
+
"veredito_polarizado": "piorando"
|
| 152 |
+
},
|
| 153 |
+
"ece_calibracao": {
|
| 154 |
+
"inclinacao_theil_sen": 0.0,
|
| 155 |
+
"n_amostras": 1,
|
| 156 |
+
"polaridade": 1,
|
| 157 |
+
"r2": 0.0,
|
| 158 |
+
"veredito_polarizado": "amostra_insuficiente"
|
| 159 |
+
},
|
| 160 |
+
"ece_pos_calibracao": {
|
| 161 |
+
"inclinacao_theil_sen": 0.0,
|
| 162 |
+
"n_amostras": 1,
|
| 163 |
+
"polaridade": 1,
|
| 164 |
+
"r2": 0.0,
|
| 165 |
+
"veredito_polarizado": "amostra_insuficiente"
|
| 166 |
+
},
|
| 167 |
+
"escore_aprendizado": {
|
| 168 |
+
"inclinacao_theil_sen": 0.0031779661016949155,
|
| 169 |
+
"n_amostras": 4,
|
| 170 |
+
"polaridade": 1,
|
| 171 |
+
"r2": 0.69855405534808,
|
| 172 |
+
"veredito_polarizado": "piorando"
|
| 173 |
+
},
|
| 174 |
+
"lr": {
|
| 175 |
+
"inclinacao_theil_sen": 0.0,
|
| 176 |
+
"n_amostras": 60,
|
| 177 |
+
"polaridade": 1,
|
| 178 |
+
"r2": 0.0,
|
| 179 |
+
"veredito_polarizado": "estagnado"
|
| 180 |
+
},
|
| 181 |
+
"norma_delta": {
|
| 182 |
+
"inclinacao_theil_sen": -0.004560884659055644,
|
| 183 |
+
"n_amostras": 55,
|
| 184 |
+
"polaridade": 1,
|
| 185 |
+
"r2": 0.6655823745576321,
|
| 186 |
+
"veredito_polarizado": "aprendendo"
|
| 187 |
+
},
|
| 188 |
+
"norma_grad": {
|
| 189 |
+
"inclinacao_theil_sen": -0.0009406904053285296,
|
| 190 |
+
"n_amostras": 60,
|
| 191 |
+
"polaridade": -1,
|
| 192 |
+
"r2": -0.05227700522904288,
|
| 193 |
+
"veredito_polarizado": "piorando"
|
| 194 |
+
},
|
| 195 |
+
"perda": {
|
| 196 |
+
"inclinacao_theil_sen": -0.0009818642826403602,
|
| 197 |
+
"n_amostras": 60,
|
| 198 |
+
"polaridade": -1,
|
| 199 |
+
"r2": 0.021705938792401458,
|
| 200 |
+
"veredito_polarizado": "piorando"
|
| 201 |
+
},
|
| 202 |
+
"taxa_gatilho": {
|
| 203 |
+
"inclinacao_theil_sen": 0.0,
|
| 204 |
+
"n_amostras": 60,
|
| 205 |
+
"polaridade": 1,
|
| 206 |
+
"r2": -0.17241379310344818,
|
| 207 |
+
"veredito_polarizado": "estagnado"
|
| 208 |
+
},
|
| 209 |
+
"temperatura_calibrada": {
|
| 210 |
+
"inclinacao_theil_sen": 0.0,
|
| 211 |
+
"n_amostras": 1,
|
| 212 |
+
"polaridade": 1,
|
| 213 |
+
"r2": 0.0,
|
| 214 |
+
"veredito_polarizado": "amostra_insuficiente"
|
| 215 |
+
}
|
| 216 |
+
},
|
| 217 |
+
"erros_registrados": 0,
|
| 218 |
+
"escore_aprendizado": 0.1875,
|
| 219 |
+
"fnh": {
|
| 220 |
+
"delta_ort_rotacao": null,
|
| 221 |
+
"gate_ultimo": null,
|
| 222 |
+
"punicao_ema": null,
|
| 223 |
+
"theta_norma": null
|
| 224 |
+
},
|
| 225 |
+
"nlp_nlg": {
|
| 226 |
+
"espec_aceitacao": null,
|
| 227 |
+
"espec_speedup": null,
|
| 228 |
+
"nlg_coerencia": null,
|
| 229 |
+
"nlp_gate_medio": null
|
| 230 |
+
},
|
| 231 |
+
"quebra_cabeca": {
|
| 232 |
+
"confianca_base": null,
|
| 233 |
+
"confianca_melhor": null,
|
| 234 |
+
"punicao_acumulada": null,
|
| 235 |
+
"taxa_aceitacao": null
|
| 236 |
+
},
|
| 237 |
+
"resumo_direcoes": {
|
| 238 |
+
"aprendendo": 1,
|
| 239 |
+
"estagnado": 5,
|
| 240 |
+
"piorando": 8
|
| 241 |
+
},
|
| 242 |
+
"simd": {
|
| 243 |
+
"avx512_disponivel": true,
|
| 244 |
+
"chamadas_avx": 14250,
|
| 245 |
+
"chamadas_escalar": 0
|
| 246 |
+
},
|
| 247 |
+
"v090_nota": "kernels AVX-512 com despacho em runtime (bit-a-bit); medições em r-34 §4/§6: AdamW 1,0-1,2× (limitado por memória), BMU argmin: escalar ótimo em d=4; bf16 em CPU candle: 3× MAIS LENTO (upcast por op); nosso AdamW 1,5-1,7× mais rápido que candle_nn::optim",
|
| 248 |
+
"v100_nota": "análise/prova/teste das críticas DeepSeek (5 arquivos): J-1′ sela sharp (kink da RAIZ, não da dobradiça; softplus refutado — j1d); S4-1′ Φ do kernel não-crescente incondicional (contraexemplo QE reproduzido; mediana de Weiszfeld opt-in); T-1′ termo δ/η confirmado (η configurável); H-1′ cota ótima (√QE+√R)² + reservar_grosso teorema; T-P5′ cota m_extra com identidade exata (fórmula DeepSeek refutada); T-P1′ causalidade contrafactual; A.0′ viés STE ≤ M·Δ/2; A.1′ coerência de Welch por nível; B.1 TC plug-in MM; C.3′ errata (média ≤ sup); bug v100-1 (máscara de covariância invertida) corrigido",
|
| 249 |
+
"versao": "0.7.0"
|
| 250 |
+
}
|
| 251 |
+
}
|
scripts/74_treino_v100.py
ADDED
|
@@ -0,0 +1,148 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/usr/bin/env python3
|
| 2 |
+
"""74_treino_v100.py — AVALIAÇÃO COM DADOS REAIS dos mecanismos v0.10.0
|
| 3 |
+
(análise/prova/teste das críticas DeepSeek — r-35).
|
| 4 |
+
|
| 5 |
+
Pipeline (dados: Wikipédia PT-BR, wikimedia/wikipedia 20231101.pt):
|
| 6 |
+
1. Fases A/B/C CURTAS — a fase A agora reporta coerência de Welch
|
| 7 |
+
(A.1′) e TC intra-nível plug-in Miller–Madow (B.1) nos codebooks
|
| 8 |
+
TREINADOS EM DADOS REAIS (linha de base da alavanca B-1T);
|
| 9 |
+
2. SOM em latentes reais: A/B média vs mediana de Weiszfeld
|
| 10 |
+
(S4-1′-c) — QE e EQM reportadas nos dois critérios + Φ monotona;
|
| 11 |
+
3. H-SOM em latentes reais: com e sem reservar_grosso (H-1′-c);
|
| 12 |
+
4. JEPA em latentes reais: A/B dos 3 modos de variância (J-1′).
|
| 13 |
+
"""
|
| 14 |
+
import json, os, sys, time
|
| 15 |
+
|
| 16 |
+
import numpy as np
|
| 17 |
+
|
| 18 |
+
|
| 19 |
+
def main():
|
| 20 |
+
pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
| 21 |
+
sys.path.insert(0, pasta)
|
| 22 |
+
os.makedirs(os.path.join(pasta, "resultados"), exist_ok=True)
|
| 23 |
+
import khtst_rust as K
|
| 24 |
+
|
| 25 |
+
cfg = K.Config(os.path.join(pasta, "configs", "base_rust.json"))
|
| 26 |
+
ck_tok = os.path.join(pasta, "resultados", "tokenizador_conceitos.json")
|
| 27 |
+
ck_ger = os.path.join(pasta, "resultados", "gerador_conceitos.json")
|
| 28 |
+
tel_c = os.path.join(pasta, "resultados", "telemetria_fase_c.jsonl")
|
| 29 |
+
|
| 30 |
+
bpe = K.Bpe.carregar(os.path.join(pasta, "dados", "bpe.json"))
|
| 31 |
+
seqs = []
|
| 32 |
+
with open(os.path.join(pasta, "dados", "shard_treino.jsonl")) as f:
|
| 33 |
+
for linha in f:
|
| 34 |
+
ids = bpe.codificar(json.loads(linha)["texto"])
|
| 35 |
+
for i in range(0, max(1, len(ids) - 256), 128):
|
| 36 |
+
seqs.append(ids[i:i + 256])
|
| 37 |
+
seqs = seqs[:1400]
|
| 38 |
+
PAD = 0
|
| 39 |
+
largura = max(len(s) for s in seqs)
|
| 40 |
+
seqs_np = np.array(
|
| 41 |
+
[s + [PAD] * (largura - len(s)) for s in seqs], dtype=np.uint32
|
| 42 |
+
)
|
| 43 |
+
rel = {
|
| 44 |
+
"versao": "0.10.0",
|
| 45 |
+
"dados": {"sequencias": len(seqs), "fonte": "wikimedia/wikipedia 20231101.pt"},
|
| 46 |
+
"fases": {},
|
| 47 |
+
}
|
| 48 |
+
print(f"sequências: {len(seqs)} (ctx=256) | numpy {seqs_np.shape}", flush=True)
|
| 49 |
+
|
| 50 |
+
# -------------------------------- fase A (numpy) — v100: coerença+TC
|
| 51 |
+
apagar = [ck_tok, ck_ger, tel_c]
|
| 52 |
+
for c in apagar:
|
| 53 |
+
if os.path.exists(c):
|
| 54 |
+
os.remove(c)
|
| 55 |
+
print(f"estado anterior apagado: {c}", flush=True)
|
| 56 |
+
print("=== FASE A — tokenizador (entrada NUMPY; μ-Welch + TC no resumo) ===", flush=True)
|
| 57 |
+
t0 = time.time()
|
| 58 |
+
saida = K.treinar_fase_a_np(cfg, seqs_np, None, ck_tok, None, 200.0)
|
| 59 |
+
rel["fases"]["a"] = {**saida["resumo"], "tempo_s": round(time.time() - t0, 1)}
|
| 60 |
+
print(json.dumps(rel["fases"]["a"], indent=1, ensure_ascii=False), flush=True)
|
| 61 |
+
|
| 62 |
+
# -------------------------------- fase B (numpy)
|
| 63 |
+
print("=== FASE B — gerador (entrada NUMPY) ===", flush=True)
|
| 64 |
+
t0 = time.time()
|
| 65 |
+
saida_b = K.treinar_fase_b_np(cfg, seqs_np, ck_tok, None, ck_ger, teto_seg=200.0)
|
| 66 |
+
rel["fases"]["b"] = {**saida_b["resumo"], "tempo_s": round(time.time() - t0, 1)}
|
| 67 |
+
print(json.dumps(rel["fases"]["b"], indent=1, ensure_ascii=False), flush=True)
|
| 68 |
+
|
| 69 |
+
# -------------------------------- fase C (curta)
|
| 70 |
+
print("=== FASE C — conjunto (60 passos) ===", flush=True)
|
| 71 |
+
t0 = time.time()
|
| 72 |
+
saida_c = K.treinar_fase_c(cfg, seqs, ck_tok, passos=60, caminho_gerador=ck_ger,
|
| 73 |
+
caminho_telemetria=tel_c, teto_seg=120.0)
|
| 74 |
+
rc = saida_c["resumo"]
|
| 75 |
+
rc["tempo_s"] = round(time.time() - t0, 1)
|
| 76 |
+
rel["fases"]["c"] = rc
|
| 77 |
+
chaves = [k for k in list(rc)[:10]]
|
| 78 |
+
print(json.dumps({k: rc[k] for k in chaves}, indent=1, ensure_ascii=False), flush=True)
|
| 79 |
+
|
| 80 |
+
# -------------------------------- latentes reais
|
| 81 |
+
print("=== LATENTES REAIS (tokenizador treinado) ===", flush=True)
|
| 82 |
+
lat = K.codificar_latentes(cfg, ck_tok, seqs_np[:64])
|
| 83 |
+
print(f"latentes: {lat.shape} {lat.dtype}", flush=True)
|
| 84 |
+
|
| 85 |
+
# -------------------------------- SOM real: média vs mediana (S4-1′)
|
| 86 |
+
print("=== SOM REAL — média vs mediana de Weiszfeld (S4-1′) ===", flush=True)
|
| 87 |
+
nuvem = lat.reshape(-1, lat.shape[-1])
|
| 88 |
+
sel = np.random.default_rng(5).choice(len(nuvem), 1500, replace=False)
|
| 89 |
+
nuvem_list = [list(map(float, v)) for v in nuvem[sel]]
|
| 90 |
+
base = json.dumps({"nx": 4, "ny": 3, "nz": 2, "nt": 2, "epocas": 12,
|
| 91 |
+
"sigma0": 2.0, "sigma1": 0.5, "semente": 42})
|
| 92 |
+
som_med = K.treinar_som4d(nuvem_list, base)
|
| 93 |
+
som_mediana = K.treinar_som4d(nuvem_list, json.dumps({
|
| 94 |
+
**json.loads(base), "criterio_lote": "mediana_geometrica",
|
| 95 |
+
"weiszfeld_iters": 8}))
|
| 96 |
+
rel["som_real"] = {
|
| 97 |
+
"media": {"eq_ini": som_med["eq_inicial"], "eq_fim": som_med["eq_final"],
|
| 98 |
+
"eqm_fim": som_med["eqm_final"], "te": som_med["te_final"],
|
| 99 |
+
"phi_monotono": som_med["phi_monotono"]},
|
| 100 |
+
"mediana": {"eq_ini": som_mediana["eq_inicial"], "eq_fim": som_mediana["eq_final"],
|
| 101 |
+
"eqm_fim": som_mediana["eqm_final"], "te": som_mediana["te_final"],
|
| 102 |
+
"phi_monotono": som_mediana["phi_monotono"]},
|
| 103 |
+
}
|
| 104 |
+
print(json.dumps(rel["som_real"], indent=1, ensure_ascii=False), flush=True)
|
| 105 |
+
|
| 106 |
+
# -------------------------------- H-SOM real: com/sem reserva (H-1′-c)
|
| 107 |
+
print("=== H-SOM REAL — reservar_grosso (H-1′-c) ===", flush=True)
|
| 108 |
+
hs_sem = K.treinar_hsom(nuvem_list[:800])
|
| 109 |
+
hs_com = K.treinar_hsom(nuvem_list[:800], json.dumps({"reservar_grosso": True}))
|
| 110 |
+
rel["hsom_real"] = {
|
| 111 |
+
"sem_reserva": {"eq_hier": hs_sem["eq_hierarquico"], "eq_grosso": hs_sem["eq_grosso"],
|
| 112 |
+
"r_fino": hs_sem["r_fino"],
|
| 113 |
+
"c_observada": hs_sem["eq_hierarquico"] <= hs_sem["eq_grosso"]},
|
| 114 |
+
"com_reserva": {"eq_hier": hs_com["eq_hierarquico"], "eq_grosso": hs_com["eq_grosso"],
|
| 115 |
+
"r_fino": hs_com["r_fino"],
|
| 116 |
+
"teorema_ok": hs_com["eq_hierarquico"] <= hs_com["eq_grosso"]},
|
| 117 |
+
"cota_otima_sem": (hs_sem["eq_grosso"] ** 0.5 + hs_sem["r_fino"] ** 0.5) ** 2,
|
| 118 |
+
}
|
| 119 |
+
print(json.dumps(rel["hsom_real"], indent=1, ensure_ascii=False), flush=True)
|
| 120 |
+
|
| 121 |
+
# -------------------------------- JEPA real: 3 modos de variância (J-1′)
|
| 122 |
+
print("=== JEPA REAL — modos de variância (J-1′) ===", flush=True)
|
| 123 |
+
resultados_modo = {}
|
| 124 |
+
for modo in ["dobradica", "raiz_suavizada", "softplus"]:
|
| 125 |
+
cfg_j = json.dumps({"epocas": 40, "d_emb": 48, "semente": 42, "lr": 2e-3,
|
| 126 |
+
"modo_variancia": modo})
|
| 127 |
+
quedas = []
|
| 128 |
+
for w in range(4):
|
| 129 |
+
janela = lat[w].astype(float).tolist()
|
| 130 |
+
r = K.treinar_jepa(janela, [256], "tjepa", cfg_j)
|
| 131 |
+
quedas.append(r["queda_pct"])
|
| 132 |
+
resultados_modo[modo] = {
|
| 133 |
+
"media_queda_pct": sum(quedas) / len(quedas),
|
| 134 |
+
"por_janela": quedas,
|
| 135 |
+
}
|
| 136 |
+
print(f" {modo}: queda média {resultados_modo[modo]['media_queda_pct']:.1f}%", flush=True)
|
| 137 |
+
rel["jepa_modos_real"] = resultados_modo
|
| 138 |
+
|
| 139 |
+
# -------------------------------- painel v100 (via fase C)
|
| 140 |
+
rel["painel_v100"] = saida_c.get("painel_v100")
|
| 141 |
+
|
| 142 |
+
with open(os.path.join(pasta, "resultados", "treino_v100.json"), "w") as f:
|
| 143 |
+
json.dump(rel, f, indent=1, ensure_ascii=False)
|
| 144 |
+
print("salvo: resultados/treino_v100.json", flush=True)
|
| 145 |
+
|
| 146 |
+
|
| 147 |
+
if __name__ == "__main__":
|
| 148 |
+
main()
|
scripts/79_suite_v011.py
ADDED
|
@@ -0,0 +1,230 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/usr/bin/env python3
|
| 2 |
+
"""79_suite_v011.py — v0.11.0: VEREDITO CONSOLIDADO (provas r-36..r-42 +
|
| 3 |
+
tratamento.txt Rust+Assembly + restauração da funcionalidade v0.10.0).
|
| 4 |
+
|
| 5 |
+
Gates:
|
| 6 |
+
v1 versão 0.11.0 + módulos novos registrados (asm, raciocinio_elastico,
|
| 7 |
+
checkpoint, tipos) e bindings (asm_relatorio, v2_relatorio_soundness,
|
| 8 |
+
checkpoint_*, sha256_arquivo, demo_raciocinio_elastico);
|
| 9 |
+
v2 tratamento.txt (Assembly): relatório dos 3 kernels por flags
|
| 10 |
+
(CF/PF/ZF); testes cargo asm::* verdes; sha256_arquivo == hashlib
|
| 11 |
+
(oráculo independente); checkpoint atômico roundtrip
|
| 12 |
+
(salvar → validar → carregar verificado) + detecção de corrupção;
|
| 13 |
+
v3 M-R5′: teste cargo m_r5_guloso_vs_forca_bruta verde (guloso ==
|
| 14 |
+
força bruta; contraexemplo r-41 com constante corrigida 31,794);
|
| 15 |
+
v4 V-2′: relatório de soundness condicional — cota limpa respeitada,
|
| 16 |
+
p_aceite > 0, ece_aceito ≤ 1, cotas finitas; contraexemplo do ECE
|
| 17 |
+
global reproduzido do Python (a cota antiga É violável);
|
| 18 |
+
v5 raciocínio elástico (RE-1..RE-8): demo com gates todos true,
|
| 19 |
+
certificados presentes, ε_safe ≥ 0, terminação ≤ B_max;
|
| 20 |
+
v6 H-1′ pin slot: treinar_hsom com reservar_grosso=true ⇒ EQ_hier ≤
|
| 21 |
+
EQ_grosso EXATO (teorema) — e sem pin mantém a cota (√QE+√R)²;
|
| 22 |
+
v7 Weiszfeld: treinar_som4d criterio_lote=mediana_geometrica executa e
|
| 23 |
+
QE não-crescente no contraexemplo {0,10} (S4-2);
|
| 24 |
+
v8 preservação v0.10.0: cargo 158/158 (tipos T-V*, checkpoint CP-*);
|
| 25 |
+
SRP split ARQUIVADO com justificativa (arquivo_split_v100/LEIA-ME) —
|
| 26 |
+
funcionalidade preservada, estrutura registrada como débito.
|
| 27 |
+
Saída: resultados/suite_v011_final.json
|
| 28 |
+
"""
|
| 29 |
+
import hashlib
|
| 30 |
+
import json
|
| 31 |
+
import os
|
| 32 |
+
import re
|
| 33 |
+
import subprocess
|
| 34 |
+
import sys
|
| 35 |
+
import tempfile
|
| 36 |
+
|
| 37 |
+
PASTA = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
| 38 |
+
R = os.path.join(PASTA, "resultados")
|
| 39 |
+
|
| 40 |
+
|
| 41 |
+
def main():
|
| 42 |
+
rel = {"versao": "0.11.0", "blocos": {}, "gates": {}, "medicoes": {}}
|
| 43 |
+
|
| 44 |
+
sys.path.insert(0, os.path.join(PASTA, "python"))
|
| 45 |
+
import khtst_rust.nucleo_rust as nr
|
| 46 |
+
|
| 47 |
+
# ---- v1: versão e módulos
|
| 48 |
+
rel["gates"]["v1_versao_0110"] = nr.versao() == "khtst-rust-0.11.0"
|
| 49 |
+
asm_rep = nr.asm_relatorio()
|
| 50 |
+
rel["medicoes"]["asm_relatorio"] = asm_rep
|
| 51 |
+
rel["gates"]["v1_kernels_asm_registrados"] = all(
|
| 52 |
+
k in asm_rep for k in ("soma_u64_cheia", "primeiro_nan_f64", "primeiro_nan_f32", "CF", "PF")
|
| 53 |
+
)
|
| 54 |
+
rel["gates"]["v1_binding_v2_soundness"] = hasattr(nr, "v2_relatorio_soundness")
|
| 55 |
+
rel["gates"]["v1_binding_elastico"] = hasattr(nr, "demo_raciocinio_elastico")
|
| 56 |
+
|
| 57 |
+
# ---- v2: tratamento.txt (Assembly + Result) — oráculos independentes
|
| 58 |
+
# (a) SHA-256 puro Rust vs hashlib (FIPS 180-4 — dois oráculos)
|
| 59 |
+
with tempfile.NamedTemporaryFile(delete=False, suffix=".bin") as f:
|
| 60 |
+
f.write(os.urandom(4096))
|
| 61 |
+
caminho_bin = f.name
|
| 62 |
+
h_rust = nr.sha256_arquivo(caminho_bin)
|
| 63 |
+
h_py = hashlib.sha256(open(caminho_bin, "rb").read()).hexdigest()
|
| 64 |
+
rel["gates"]["v2_sha256_confere_hashlib"] = h_rust == h_py
|
| 65 |
+
os.unlink(caminho_bin)
|
| 66 |
+
|
| 67 |
+
# (b) checkpoint atômico: salvar → validar → carregar verificado
|
| 68 |
+
# (usa o próprio TokenizadorBPE pyclass, que salva via salvar_atomico)
|
| 69 |
+
with tempfile.TemporaryDirectory() as td:
|
| 70 |
+
ckpt = os.path.join(td, "tok.json")
|
| 71 |
+
bpe = nr.Bpe.treinar(["o rastro de provas em rust e assembly " * 20], 220)
|
| 72 |
+
bpe.salvar(ckpt)
|
| 73 |
+
manifestou = nr.checkpoint_manifesto(ckpt)
|
| 74 |
+
rel["gates"]["v2_checkpoint_manifesto_presente"] = manifestou is not None
|
| 75 |
+
rel["gates"]["v2_checkpoint_valido"] = nr.checkpoint_valido(ckpt) is True
|
| 76 |
+
# detecção de corrupção: alterar 1 byte ⇒ manifesto INVALIDA
|
| 77 |
+
dados = bytearray(open(ckpt, "rb").read())
|
| 78 |
+
dados[len(dados) // 2] ^= 0x01
|
| 79 |
+
with open(ckpt, "wb") as f:
|
| 80 |
+
f.write(dados)
|
| 81 |
+
rel["gates"]["v2_checkpoint_corrupcao_detectada"] = nr.checkpoint_valido(ckpt) is False
|
| 82 |
+
# retrocompatibilidade LEGADO: arquivo são SEM manifesto (pré-v0.10)
|
| 83 |
+
# continua carregando (leitura simples, com aviso no log)
|
| 84 |
+
bpe.salvar(ckpt) # regrava são
|
| 85 |
+
os.unlink(ckpt + ".manifest.json") # simula checkpoint pré-v0.10
|
| 86 |
+
bpe2 = nr.Bpe.carregar(ckpt)
|
| 87 |
+
rel["gates"]["v2_carregar_retrocompativel"] = bpe2.n_vocab > 0
|
| 88 |
+
|
| 89 |
+
# ---- cargo (v3/v8): contagem total + testes-chave por nome
|
| 90 |
+
env = dict(os.environ)
|
| 91 |
+
env["PATH"] = os.path.expanduser("~/.cargo/bin") + os.pathsep + env.get("PATH", "")
|
| 92 |
+
r = subprocess.run(
|
| 93 |
+
["cargo", "test", "--release"], capture_output=True, text=True, cwd=PASTA, env=env
|
| 94 |
+
)
|
| 95 |
+
totais = [int(x) for x in re.findall(r"test result: ok\. (\d+) passed", r.stdout)]
|
| 96 |
+
total = sum(totais)
|
| 97 |
+
rel["medicoes"]["cargo_total"] = total
|
| 98 |
+
nomes = re.findall(r"^test (\S+) \.\.\. ok", r.stdout, re.M)
|
| 99 |
+
chave = [
|
| 100 |
+
"asm::testes::soma_estoura_na_segunda_parcela",
|
| 101 |
+
"asm::testes::nan_f64_localizado",
|
| 102 |
+
"moe_redirecionavel::testes::m_r5_guloso_vs_forca_bruta",
|
| 103 |
+
"raciocinio_elastico::testes::re8_determinismo",
|
| 104 |
+
"raciocinio_elastico::testes::re2d_ciclo_com_compressao",
|
| 105 |
+
"verificador::testes::v2_linha_cota_condicional_corrigida",
|
| 106 |
+
]
|
| 107 |
+
faltando = [c for c in chave if c not in nomes]
|
| 108 |
+
rel["medicoes"]["testes_chave_faltando"] = faltando
|
| 109 |
+
rel["gates"]["v3_mr5_guloso_vs_bruto"] = not faltando and r.returncode == 0
|
| 110 |
+
rel["gates"]["v8_cargo_158_mais"] = total >= 158 and r.returncode == 0
|
| 111 |
+
|
| 112 |
+
# ---- v4: V-2′ soundness condicional (simulação superconfiante)
|
| 113 |
+
import random
|
| 114 |
+
|
| 115 |
+
random.seed(11)
|
| 116 |
+
confs = [min(0.999, max(0.001, random.betavariate(2, 3) + 0.25)) for _ in range(6000)]
|
| 117 |
+
corretos = [random.random() <= c * 0.82 for c in confs] # superconfiante
|
| 118 |
+
s = nr.v2_relatorio_soundness(confs, corretos, 15, 0.70)
|
| 119 |
+
rel["medicoes"]["v2_linha"] = {k: (round(v, 4) if isinstance(v, float) else v) for k, v in s.items()}
|
| 120 |
+
rel["gates"]["v4_cota_limpa_respeitada"] = s["cota_limpa_respeitada"] is True
|
| 121 |
+
rel["gates"]["v4_p_aceite_positiva"] = 0.0 < s["p_aceite"] <= 1.0
|
| 122 |
+
rel["gates"]["v4_cotas_finitas"] = (
|
| 123 |
+
s["cota_limpa"] < 10.0 and s["cota_corrigida"] < 50.0 and s["ece_aceito"] <= 1.0
|
| 124 |
+
)
|
| 125 |
+
# contraexemplo da errata: ECE GLOBAL pode violar a cota antiga
|
| 126 |
+
random.seed(77)
|
| 127 |
+
cg, og = [], []
|
| 128 |
+
for i in range(20000):
|
| 129 |
+
if i % 10 == 0:
|
| 130 |
+
cg.append(0.95)
|
| 131 |
+
og.append(random.random() < 0.80)
|
| 132 |
+
else:
|
| 133 |
+
cg.append(0.50)
|
| 134 |
+
og.append(random.random() < 0.50)
|
| 135 |
+
# ECE global 10 faixas via relatório no domínio total (tau=0)
|
| 136 |
+
s0 = nr.v2_relatorio_soundness(cg, og, 10, 0.0)
|
| 137 |
+
n_a = sum(1 for c in cg if c >= 0.9)
|
| 138 |
+
e_a = sum(1 for c, o in zip(cg, og) if c >= 0.9 and not o)
|
| 139 |
+
p_erro_a = e_a / n_a
|
| 140 |
+
cota_antiga = 1.0 - 0.9 + s0["ece_aceito"] # tau=0: ece_aceito == ECE global
|
| 141 |
+
rel["medicoes"]["v2_errata"] = {
|
| 142 |
+
"p_erro_aceito": round(p_erro_a, 4),
|
| 143 |
+
"cota_antiga_ece_global": round(cota_antiga, 4),
|
| 144 |
+
}
|
| 145 |
+
rel["gates"]["v4_errata_ece_global_e_violavel"] = p_erro_a > cota_antiga
|
| 146 |
+
s9 = nr.v2_relatorio_soundness(cg, og, 10, 0.9)
|
| 147 |
+
rel["gates"]["v4_errata_cota_limpa_cobre"] = s9["cota_limpa_respeitada"] is True
|
| 148 |
+
|
| 149 |
+
# ---- v5: raciocínio elástico (RE-1..RE-8)
|
| 150 |
+
e = nr.demo_raciocinio_elastico(8, 6, 3, 120, 0.30, 6, 42)
|
| 151 |
+
rel["medicoes"]["elastico"] = {
|
| 152 |
+
"confianca_media": round(e["confianca_media"], 4),
|
| 153 |
+
"iteracoes_media": round(e["iteracoes_media"], 2),
|
| 154 |
+
"certificados": len(e["certificados"]),
|
| 155 |
+
"rollbacks": e["rollbacks"],
|
| 156 |
+
}
|
| 157 |
+
rel["gates"]["v5_gates_elasticos"] = all(e["gates"].values())
|
| 158 |
+
rel["gates"]["v5_certificados_presentes"] = len(e["certificados"]) >= 1
|
| 159 |
+
rel["gates"]["v5_epsilon_seguro_nao_negativo"] = all(
|
| 160 |
+
(c["epsilon_safe"] is None) or (c["epsilon_safe"] >= 0.0) for c in e["certificados"]
|
| 161 |
+
)
|
| 162 |
+
|
| 163 |
+
# ---- v6: H-1′ pin slot (reservar_grosso) — teorema EQ_hier ≤ EQ_grosso
|
| 164 |
+
random.seed(5)
|
| 165 |
+
dados = [[random.gauss(0, 1), random.gauss(0, 1), random.gauss(0, 2), random.gauss(0, 0.5)]
|
| 166 |
+
for _ in range(300)]
|
| 167 |
+
h_pin = nr.treinar_hsom(dados, json.dumps({"reservar_grosso": True}))
|
| 168 |
+
h_std = nr.treinar_hsom(dados, json.dumps({"reservar_grosso": False}))
|
| 169 |
+
rel["medicoes"]["h1_linha"] = {
|
| 170 |
+
"eq_hier_com_pin": round(h_pin["eq_hierarquico"], 5),
|
| 171 |
+
"eq_grosso_com_pin": round(h_pin["eq_grosso"], 5),
|
| 172 |
+
"eq_hier_sem_pin": round(h_std["eq_hierarquico"], 5),
|
| 173 |
+
}
|
| 174 |
+
rel["gates"]["v6_pin_eq_hier_le_eq_grosso_exato"] = (
|
| 175 |
+
h_pin["eq_hierarquico"] <= h_pin["eq_grosso"] + 1e-12
|
| 176 |
+
)
|
| 177 |
+
# cota (√QE+√R)² SEMPRE válida (com e sem pin)
|
| 178 |
+
import math
|
| 179 |
+
|
| 180 |
+
for h, nome in ((h_pin, "pin"), (h_std, "sem_pin")):
|
| 181 |
+
cota = (math.sqrt(h["eq_grosso"]) + math.sqrt(h["r_fino"])) ** 2
|
| 182 |
+
rel["gates"][f"v6_cota_minkowski_{nome}"] = h["eq_hierarquico"] <= cota + 1e-9
|
| 183 |
+
|
| 184 |
+
# ---- v7: Weiszfeld (mediana geométrica) no contraexemplo S4-2
|
| 185 |
+
dados_ce = [[0.0, 0.1], [10.0, -0.1]] * 8 # 2 clusters {0,10}
|
| 186 |
+
antes = nr.treinar_som4d(dados_ce, json.dumps({"nx": 2, "ny": 1, "nz": 1, "nt": 1,
|
| 187 |
+
"epocas": 1, "criterio_lote": "media",
|
| 188 |
+
"criterio_qe": "distancia"}))
|
| 189 |
+
depois = nr.treinar_som4d(dados_ce, json.dumps({"nx": 2, "ny": 1, "nz": 1, "nt": 1,
|
| 190 |
+
"epocas": 6, "criterio_lote": "media",
|
| 191 |
+
"criterio_qe": "distancia"}))
|
| 192 |
+
med = nr.treinar_som4d(dados_ce, json.dumps({"nx": 2, "ny": 1, "nz": 1, "nt": 1,
|
| 193 |
+
"epocas": 6, "criterio_lote": "mediana_geometrica",
|
| 194 |
+
"criterio_qe": "distancia"}))
|
| 195 |
+
rel["medicoes"]["s42"] = {
|
| 196 |
+
"qe_inicial": round(antes["eq_final"], 4),
|
| 197 |
+
"qe_media_6ep": round(depois["eq_final"], 4),
|
| 198 |
+
"qe_mediana_6ep": round(med["eq_final"], 4),
|
| 199 |
+
}
|
| 200 |
+
# com média a QE pode subir no regime σ grande (contraexemplo);
|
| 201 |
+
# com mediana de Weiszfeld a QE NÃO sobe em relação ao inicial
|
| 202 |
+
rel["gates"]["v7_mediana_nao_piora_contraexemplo"] = med["eq_final"] <= antes["eq_final"] + 1e-9
|
| 203 |
+
rel["gates"]["v7_phi_monotono_media"] = depois["phi_monotono"] is True
|
| 204 |
+
rel["gates"]["v7_phi_monotono_mediana"] = med["phi_monotono"] is True
|
| 205 |
+
|
| 206 |
+
# ---- v8: preservação v0.10 + arquivo do split SRP
|
| 207 |
+
leia = os.path.join(PASTA, "arquivo_split_v100", "LEIA-ME.md")
|
| 208 |
+
rel["gates"]["v8_split_arquivado_documentado"] = os.path.exists(leia)
|
| 209 |
+
for m in ("checkpoint", "tipos"):
|
| 210 |
+
rel["gates"][f"v8_modulo_{m}_presente"] = os.path.exists(os.path.join(PASTA, "src", f"{m}.rs"))
|
| 211 |
+
# determinismo: 2ª rodada de cargo idêntica
|
| 212 |
+
r2 = subprocess.run(
|
| 213 |
+
["cargo", "test", "--release"], capture_output=True, text=True, cwd=PASTA, env=env
|
| 214 |
+
)
|
| 215 |
+
totais2 = sum(int(x) for x in re.findall(r"test result: ok\. (\d+) passed", r2.stdout))
|
| 216 |
+
rel["gates"]["v8_cargo_deterministico"] = totais2 == total and r2.returncode == 0
|
| 217 |
+
|
| 218 |
+
# ---- veredito
|
| 219 |
+
ok = sum(1 for v in rel["gates"].values() if v is True)
|
| 220 |
+
rel["veredito"] = f"{ok}/{len(rel['gates'])}"
|
| 221 |
+
rel["ok"] = ok == len(rel["gates"])
|
| 222 |
+
with open(os.path.join(R, "suite_v011_final.json"), "w") as f:
|
| 223 |
+
json.dump(rel, f, indent=1, ensure_ascii=False)
|
| 224 |
+
print(json.dumps({"veredito": rel["veredito"], "ok": rel["ok"],
|
| 225 |
+
"medicoes": rel["medicoes"]}, indent=1, ensure_ascii=False))
|
| 226 |
+
return 0 if rel["ok"] else 1
|
| 227 |
+
|
| 228 |
+
|
| 229 |
+
if __name__ == "__main__":
|
| 230 |
+
sys.exit(main())
|
scripts/80_avaliacao_real_v011.py
ADDED
|
@@ -0,0 +1,166 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/usr/bin/env python3
|
| 2 |
+
"""80_avaliacao_real_v011.py — AVALIAÇÃO COM DADOS REAIS (Wikipédia PT-BR)
|
| 3 |
+
dos mecanismos v0.11.0 (r-36..r-42 completados + tratamento.txt).
|
| 4 |
+
|
| 5 |
+
Diferencial da v0.11 sobre a avaliação v0.10 (script 74):
|
| 6 |
+
R1 raciocínio ELÁSTICO em latentes reais (r-42): cond = latente[j],
|
| 7 |
+
alvo = latente[j+1] (predição de próximo vetor) — motor + cabeça
|
| 8 |
+
verificadora treinados nos pares REAIS; certificados RE-2 auditados;
|
| 9 |
+
R2 V-2′ (r-40) nos pares de calibração REAIS: relatório de soundness
|
| 10 |
+
condicional (ece_aceito, p_aceite, cotas limpa/corrigida);
|
| 11 |
+
R3 M-R5′ (r-41): JEPA+MoE em latentes reais (o alocador guloso ótimo
|
| 12 |
+
agora guia a realocação de capacidade dentro do treino real);
|
| 13 |
+
R4 S4-2/H-1′ (r-36): SOM média vs mediana de Weiszfeld e H-SOM com/
|
| 14 |
+
sem reservar_grosso em latentes reais (regressão v0.10 preservada);
|
| 15 |
+
R5 estados anteriores APAGADOS antes do treino (requisito do usuário);
|
| 16 |
+
R6 telemetria painel v0.11 (asm + elástico) registrada.
|
| 17 |
+
Saída: resultados/avaliacao_real_v011.json
|
| 18 |
+
"""
|
| 19 |
+
import json
|
| 20 |
+
import os
|
| 21 |
+
import sys
|
| 22 |
+
import time
|
| 23 |
+
|
| 24 |
+
import numpy as np
|
| 25 |
+
|
| 26 |
+
|
| 27 |
+
def main():
|
| 28 |
+
pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
| 29 |
+
sys.path.insert(0, pasta)
|
| 30 |
+
os.makedirs(os.path.join(pasta, "resultados"), exist_ok=True)
|
| 31 |
+
import khtst_rust as K
|
| 32 |
+
import khtst_rust.nucleo_rust as nr
|
| 33 |
+
|
| 34 |
+
cfg = K.Config(os.path.join(pasta, "configs", "base_rust.json"))
|
| 35 |
+
ck_tok = os.path.join(pasta, "resultados", "tokenizador_conceitos.json")
|
| 36 |
+
ck_ger = os.path.join(pasta, "resultados", "gerador_conceitos.json")
|
| 37 |
+
|
| 38 |
+
# ---- R5: apagar estados de treino anteriores (procura antes)
|
| 39 |
+
apagados = []
|
| 40 |
+
for c in [ck_tok, ck_ger,
|
| 41 |
+
ck_tok + ".manifest.json", ck_ger + ".manifest.json",
|
| 42 |
+
os.path.join(pasta, "resultados", "telemetria_fase_c.jsonl")]:
|
| 43 |
+
if os.path.exists(c):
|
| 44 |
+
os.remove(c)
|
| 45 |
+
apagados.append(os.path.basename(c))
|
| 46 |
+
print(f"estados anteriores apagados: {apagados or 'nenhum'}", flush=True)
|
| 47 |
+
|
| 48 |
+
# ---- dados reais (shards coletados pelo 70)
|
| 49 |
+
bpe = K.Bpe.carregar(os.path.join(pasta, "dados", "bpe.json"))
|
| 50 |
+
seqs = []
|
| 51 |
+
with open(os.path.join(pasta, "dados", "shard_treino.jsonl")) as f:
|
| 52 |
+
for linha in f:
|
| 53 |
+
ids = bpe.codificar(json.loads(linha)["texto"])
|
| 54 |
+
for i in range(0, max(1, len(ids) - 256), 128):
|
| 55 |
+
seqs.append(ids[i:i + 256])
|
| 56 |
+
seqs = seqs[:1400]
|
| 57 |
+
PAD = 0
|
| 58 |
+
largura = max(len(s) for s in seqs)
|
| 59 |
+
seqs_np = np.array([s + [PAD] * (largura - len(s)) for s in seqs], dtype=np.uint32)
|
| 60 |
+
rel = {
|
| 61 |
+
"versao": "0.11.0",
|
| 62 |
+
"dados": {"sequencias": len(seqs), "fonte": "wikimedia/wikipedia 20231101.pt"},
|
| 63 |
+
"estados_apagados": apagados,
|
| 64 |
+
}
|
| 65 |
+
print(f"sequências: {len(seqs)} (ctx=256) | numpy {seqs_np.shape}", flush=True)
|
| 66 |
+
|
| 67 |
+
# ---- fases A/B (cortas — latentes + gerador reais)
|
| 68 |
+
print("=== FASE A — tokenizador (numpy) ===", flush=True)
|
| 69 |
+
t0 = time.time()
|
| 70 |
+
saida_a = K.treinar_fase_a_np(cfg, seqs_np, None, ck_tok, None, 200.0)
|
| 71 |
+
rel["fase_a"] = {**saida_a["resumo"], "tempo_s": round(time.time() - t0, 1)}
|
| 72 |
+
print(json.dumps(rel["fase_a"], indent=1, ensure_ascii=False)[:600], flush=True)
|
| 73 |
+
|
| 74 |
+
print("=== FASE B — gerador (numpy) ===", flush=True)
|
| 75 |
+
t0 = time.time()
|
| 76 |
+
saida_b = K.treinar_fase_b_np(cfg, seqs_np, ck_tok, None, ck_ger, teto_seg=200.0)
|
| 77 |
+
rel["fase_b"] = {**saida_b["resumo"], "tempo_s": round(time.time() - t0, 1)}
|
| 78 |
+
print(json.dumps(rel["fase_b"], indent=1, ensure_ascii=False)[:600], flush=True)
|
| 79 |
+
|
| 80 |
+
# ---- latentes reais
|
| 81 |
+
lat = K.codificar_latentes(cfg, ck_tok, seqs_np[:64])
|
| 82 |
+
nuvem = np.asarray(lat).reshape(-1, np.asarray(lat).shape[-1])
|
| 83 |
+
print(f"latentes reais: {nuvem.shape}", flush=True)
|
| 84 |
+
rng = np.random.default_rng(5)
|
| 85 |
+
sel = rng.choice(len(nuvem), 1500, replace=False)
|
| 86 |
+
nuvem_list = [list(map(float, v)) for v in nuvem[sel]]
|
| 87 |
+
rel["latentes"] = {"shape": list(nuvem.shape)}
|
| 88 |
+
|
| 89 |
+
# ---- R4: SOM média vs mediana (S4-2) + H-SOM pin (H-1′) — regressão v0.10
|
| 90 |
+
base = json.dumps({"nx": 4, "ny": 3, "nz": 2, "nt": 2, "epocas": 12,
|
| 91 |
+
"sigma0": 2.0, "sigma1": 0.5, "semente": 42})
|
| 92 |
+
som_med = K.treinar_som4d(nuvem_list, base)
|
| 93 |
+
som_mediana = K.treinar_som4d(nuvem_list, json.dumps(
|
| 94 |
+
{**json.loads(base), "criterio_lote": "mediana_geometrica", "weiszfeld_iters": 8}))
|
| 95 |
+
hs_sem = K.treinar_hsom(nuvem_list[:800])
|
| 96 |
+
hs_com = K.treinar_hsom(nuvem_list[:800], json.dumps({"reservar_grosso": True}))
|
| 97 |
+
rel["som_real"] = {
|
| 98 |
+
"media": {"eq_fim": som_med["eq_final"], "eqm_fim": som_med["eqm_final"],
|
| 99 |
+
"te": som_med["te_final"], "phi_mono": som_med["phi_monotono"]},
|
| 100 |
+
"mediana": {"eq_fim": som_mediana["eq_final"], "eqm_fim": som_mediana["eqm_final"],
|
| 101 |
+
"te": som_mediana["te_final"], "phi_mono": som_mediana["phi_monotono"]},
|
| 102 |
+
"hsom_sem_pin": {"eq_hier": hs_sem["eq_hierarquico"], "eq_grosso": hs_sem["eq_grosso"]},
|
| 103 |
+
"hsom_com_pin": {"eq_hier": hs_com["eq_hierarquico"], "eq_grosso": hs_com["eq_grosso"]},
|
| 104 |
+
}
|
| 105 |
+
print(json.dumps(rel["som_real"], indent=1, ensure_ascii=False), flush=True)
|
| 106 |
+
|
| 107 |
+
# ---- R3: MoE-JEPA em latentes reais (guloso M-R5′ no treino)
|
| 108 |
+
print("=== MoE-JEPA REAL (alocador guloso M-R5′ integrado) ===", flush=True)
|
| 109 |
+
moe = K.jepa_com_moe(nuvem_list[:600], "moe", 40, 0.5, 42)
|
| 110 |
+
rel["moe_real"] = {
|
| 111 |
+
"perda_inicial": moe["perda_pred_inicial"], "perda_final": moe["perda_pred_final"],
|
| 112 |
+
"queda_pct": round(100.0 * (1.0 - moe["perda_pred_final"] / max(moe["perda_pred_inicial"], 1e-12)), 2),
|
| 113 |
+
}
|
| 114 |
+
print(json.dumps(rel["moe_real"], indent=1, ensure_ascii=False), flush=True)
|
| 115 |
+
|
| 116 |
+
# ---- R1+R2: raciocínio elástico em latentes REAIS + V-2′
|
| 117 |
+
print("=== ELÁSTICO REAL (r-42) + V-2′ (r-40) ===", flush=True)
|
| 118 |
+
# pares reais: cond = latente j, alvo = latente j+1 (predição próximo vetor)
|
| 119 |
+
pares = min(240, len(nuvem) - 1)
|
| 120 |
+
conds_r = [list(map(float, nuvem[j])) for j in range(pares)]
|
| 121 |
+
alvos_r = [list(map(float, nuvem[j + 1])) for j in range(pares)]
|
| 122 |
+
t0 = time.time()
|
| 123 |
+
el = nr.demo_raciocinio_elastico(
|
| 124 |
+
len(conds_r[0]), len(alvos_r[0]), 3, 90, 0.30, 6, 42, conds_r, alvos_r)
|
| 125 |
+
confs, corretos = el["confs_calibracao"], el["corretos_calibracao"]
|
| 126 |
+
tau = 0.60
|
| 127 |
+
s2 = nr.v2_relatorio_soundness(confs, corretos, 10, tau)
|
| 128 |
+
rel["elastico_real"] = {
|
| 129 |
+
"origem": el["origem_dados"],
|
| 130 |
+
"d_cond": len(conds_r[0]), "d_saida": len(alvos_r[0]),
|
| 131 |
+
"conf_media": round(el["confianca_media"], 4),
|
| 132 |
+
"iteracoes_media": round(el["iteracoes_media"], 2),
|
| 133 |
+
"certificados": len(el["certificados"]),
|
| 134 |
+
"rollbacks": el["rollbacks"],
|
| 135 |
+
"tempo_s": round(time.time() - t0, 1),
|
| 136 |
+
"v2_linha": {k: (round(v, 4) if isinstance(v, float) else v) for k, v in s2.items()},
|
| 137 |
+
"gates_demo": el["gates"],
|
| 138 |
+
}
|
| 139 |
+
print(json.dumps(rel["elastico_real"], indent=1, ensure_ascii=False), flush=True)
|
| 140 |
+
|
| 141 |
+
# ---- R6: telemetria v0.11 (asm + relatório do módulo)
|
| 142 |
+
rel["asm"] = nr.asm_relatorio()
|
| 143 |
+
|
| 144 |
+
# ---- gates de avaliação real
|
| 145 |
+
g = {}
|
| 146 |
+
g["fase_a_treinou"] = rel["fase_a"].get("perda_final", 1) < rel["fase_a"].get("perda_inicial", 0)
|
| 147 |
+
g["fase_b_treinou"] = rel["fase_b"].get("perda_final", 1) < rel["fase_b"].get("perda_inicial", 0)
|
| 148 |
+
g["som_phi_monotono_ambos"] = som_med["phi_monotono"] and som_mediana["phi_monotono"]
|
| 149 |
+
g["hsom_pin_teorema_real"] = hs_com["eq_hierarquico"] <= hs_com["eq_grosso"] + 1e-12
|
| 150 |
+
g["moe_real_aprendeu"] = rel["moe_real"]["perda_final"] < rel["moe_real"]["perda_inicial"]
|
| 151 |
+
g["elastico_origem_reais"] = el["origem_dados"] == "reais"
|
| 152 |
+
g["elastico_certificados_presentes"] = len(el["certificados"]) >= 1
|
| 153 |
+
g["v2_cota_limpa_real_respeitada"] = s2["cota_limpa_respeitada"] is True
|
| 154 |
+
g["v2_p_aceite_real_positiva"] = 0.0 < s2["p_aceite"] <= 1.0
|
| 155 |
+
ok = sum(1 for v in g.values() if v is True)
|
| 156 |
+
rel["avaliacao_real_gates"] = g
|
| 157 |
+
rel["veredito_real"] = f"{ok}/{len(g)}"
|
| 158 |
+
|
| 159 |
+
with open(os.path.join(pasta, "resultados", "avaliacao_real_v011.json"), "w") as f:
|
| 160 |
+
json.dump(rel, f, indent=1, ensure_ascii=False)
|
| 161 |
+
print(f"VEREDITO REAL: {rel['veredito_real']}", flush=True)
|
| 162 |
+
return 0 if ok == len(g) else 1
|
| 163 |
+
|
| 164 |
+
|
| 165 |
+
if __name__ == "__main__":
|
| 166 |
+
sys.exit(main())
|
scripts/81_telemetria_v011.py
ADDED
|
@@ -0,0 +1,147 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/usr/bin/env python3
|
| 2 |
+
"""81_telemetria_v011.py — TELEMETRIA DE TODO O PROJETO (v0.11.0).
|
| 3 |
+
|
| 4 |
+
Coleta (todas as informações acessíveis):
|
| 5 |
+
T1 estrutura: inventário de módulos (canon plano + arquivo do split SRP);
|
| 6 |
+
T2 compilação: tempos frio (target limpo parcial) e incremental por toque;
|
| 7 |
+
T3 testes: contagem cargo (determinismo 2×) e gates da suíte 79;
|
| 8 |
+
T4 integridade: checkpoints com manifesto SHA-256 válidos;
|
| 9 |
+
T5 despacho: relatório dos kernels SIMD (v0.9) e ASM (v0.11);
|
| 10 |
+
T6 estados: varredura de estados de treino (deve listar e apagar depois);
|
| 11 |
+
T7 telemetria real: séries da avaliação 80 (perdas A/B, MoE, elástico);
|
| 12 |
+
T8 unwrap de produção: contagem de unwrap/expect/panic fora de testes
|
| 13 |
+
(tratamento.txt §1 — métrica de dívida).
|
| 14 |
+
Saída: resultados/telemetria_v011.json
|
| 15 |
+
"""
|
| 16 |
+
import json
|
| 17 |
+
import os
|
| 18 |
+
import re
|
| 19 |
+
import subprocess
|
| 20 |
+
import time
|
| 21 |
+
|
| 22 |
+
PASTA = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
| 23 |
+
R = os.path.join(PASTA, "resultados")
|
| 24 |
+
|
| 25 |
+
|
| 26 |
+
def run(cmd, env=None, **kw):
|
| 27 |
+
return subprocess.run(cmd, capture_output=True, text=True, cwd=PASTA, env=env, **kw)
|
| 28 |
+
|
| 29 |
+
|
| 30 |
+
def main():
|
| 31 |
+
env = dict(os.environ)
|
| 32 |
+
env["PATH"] = os.path.expanduser("~/.cargo/bin") + os.pathsep + env.get("PATH", "")
|
| 33 |
+
rel = {"versao": "0.11.0"}
|
| 34 |
+
|
| 35 |
+
# ---- T1: estrutura
|
| 36 |
+
arquivos = []
|
| 37 |
+
for raiz, _, nfs in os.walk(os.path.join(PASTA, "src")):
|
| 38 |
+
for n in nfs:
|
| 39 |
+
if n.endswith(".rs"):
|
| 40 |
+
p = os.path.join(raiz, n)
|
| 41 |
+
arquivos.append((os.path.relpath(p, PASTA), os.path.getsize(p)))
|
| 42 |
+
arquivos.sort(key=lambda x: -x[1])
|
| 43 |
+
rel["estrutura"] = {
|
| 44 |
+
"n_modulos": len(arquivos),
|
| 45 |
+
"maior": {"caminho": arquivos[0][0], "kB": round(arquivos[0][1] / 1e3, 1)},
|
| 46 |
+
"top5_kB": {a: round(b / 1e3, 1) for a, b in arquivos[:5]},
|
| 47 |
+
"split_srp": "arquivado (arquivo_split_v100/ — débito documentado r-43)",
|
| 48 |
+
"modulos_novos_v011": ["src/asm.rs", "src/raciocinio_elastico.rs",
|
| 49 |
+
"src/checkpoint.rs (restaurado)", "src/tipos.rs (restaurado)"],
|
| 50 |
+
}
|
| 51 |
+
|
| 52 |
+
# ---- T2: compilação incremental (toque em lib.rs) + total de testes
|
| 53 |
+
t0 = time.time()
|
| 54 |
+
r1 = run(["cargo", "build", "--release"], env=env)
|
| 55 |
+
rel["compilacao"] = {
|
| 56 |
+
"incremental_lib_rs_s": round(time.time() - t0, 1),
|
| 57 |
+
"ok": r1.returncode == 0,
|
| 58 |
+
}
|
| 59 |
+
t0 = time.time()
|
| 60 |
+
rt = run(["cargo", "test", "--release"], env=env)
|
| 61 |
+
tot1 = sum(int(x) for x in re.findall(r"test result: ok\. (\d+) passed", rt.stdout))
|
| 62 |
+
rt2 = run(["cargo", "test", "--release"], env=env)
|
| 63 |
+
tot2 = sum(int(x) for x in re.findall(r"test result: ok\. (\d+) passed", rt2.stdout))
|
| 64 |
+
rel["testes"] = {
|
| 65 |
+
"cargo_total": tot1,
|
| 66 |
+
"cargo_deterministico": tot1 == tot2 and rt.returncode == 0 and rt2.returncode == 0,
|
| 67 |
+
"tempo_s": round(time.time() - t0, 1),
|
| 68 |
+
}
|
| 69 |
+
|
| 70 |
+
# ---- T3: gates da suíte
|
| 71 |
+
suite = os.path.join(R, "suite_v011_final.json")
|
| 72 |
+
if os.path.exists(suite):
|
| 73 |
+
s = json.load(open(suite))
|
| 74 |
+
rel["suite_v011"] = {"veredito": s["veredito"], "ok": s["ok"]}
|
| 75 |
+
|
| 76 |
+
# ---- T4: integridade dos checkpoints (manifesto SHA-256)
|
| 77 |
+
import sys
|
| 78 |
+
sys.path.insert(0, os.path.join(PASTA, "python"))
|
| 79 |
+
import khtst_rust.nucleo_rust as nr
|
| 80 |
+
cks = {}
|
| 81 |
+
for n in ("tokenizador_conceitos.json", "gerador_conceitos.json"):
|
| 82 |
+
p = os.path.join(R, n)
|
| 83 |
+
if os.path.exists(p):
|
| 84 |
+
cks[n] = {"valido": nr.checkpoint_valido(p),
|
| 85 |
+
"manifesto": nr.checkpoint_manifesto(p) is not None}
|
| 86 |
+
rel["checkpoints"] = cks
|
| 87 |
+
|
| 88 |
+
# ---- T5: despacho de kernels
|
| 89 |
+
rel["despacho"] = {
|
| 90 |
+
"asm": nr.asm_relatorio(),
|
| 91 |
+
"simd": "ver v0.9 (painel_v090 — kernels AVX-512 bit-a-bit)",
|
| 92 |
+
}
|
| 93 |
+
|
| 94 |
+
# ---- T6: varredura de estados de treino
|
| 95 |
+
estados = []
|
| 96 |
+
for raiz, _, nfs in os.walk(PASTA):
|
| 97 |
+
if any(x in raiz for x in ("target", ".git", "arquivo_split_v100", "node_modules")):
|
| 98 |
+
continue
|
| 99 |
+
for n in nfs:
|
| 100 |
+
if n.endswith((".estado.json", ".pt", ".npz", ".ckpt")):
|
| 101 |
+
estados.append(os.path.relpath(os.path.join(raiz, n), PASTA))
|
| 102 |
+
rel["estados_de_treino"] = estados # .estado.json de oráculos locais são legado
|
| 103 |
+
|
| 104 |
+
# ---- T7: telemetria real (avaliação 80)
|
| 105 |
+
av = os.path.join(R, "avaliacao_real_v011.json")
|
| 106 |
+
if os.path.exists(av):
|
| 107 |
+
a = json.load(open(av))
|
| 108 |
+
rel["telemetria_real"] = {
|
| 109 |
+
"fase_a": {k: a["fase_a"].get(k) for k in ("perda_inicial", "perda_final", "coerencia_welch_max", "tc_intra_nivel_medio")},
|
| 110 |
+
"fase_b": {k: a["fase_b"].get(k) for k in ("perda_inicial", "perda_final")},
|
| 111 |
+
"moe_real": a.get("moe_real"),
|
| 112 |
+
"elastico_real": {k: a["elastico_real"].get(k) for k in
|
| 113 |
+
("origem", "conf_media", "certificados", "rollbacks", "v2_linha")},
|
| 114 |
+
"veredito_real": a.get("veredito_real"),
|
| 115 |
+
}
|
| 116 |
+
|
| 117 |
+
# ---- T8: unwrap de produção (tratamento.txt §1 — dívida medida)
|
| 118 |
+
tot_prod, detalhe = 0, {}
|
| 119 |
+
padrao = re.compile(r"\.unwrap\(\)|\.expect\(|panic!|unreachable!")
|
| 120 |
+
for cam, _ in arquivos:
|
| 121 |
+
src = open(os.path.join(PASTA, cam)).read()
|
| 122 |
+
m = re.search(r"#\[cfg\(test\)\]", src)
|
| 123 |
+
prod = src[: m.start()] if m else src
|
| 124 |
+
# exclui linhas de comentário/documentação (falso-positivo de doc)
|
| 125 |
+
n = sum(1 for lin in prod.split("\n")
|
| 126 |
+
if padrao.search(lin) and not lin.lstrip().startswith("//"))
|
| 127 |
+
if n:
|
| 128 |
+
detalhe[cam] = n
|
| 129 |
+
tot_prod += n
|
| 130 |
+
rel["tratamento_erros"] = {
|
| 131 |
+
"unwrap_expect_panic_em_producao": tot_prod,
|
| 132 |
+
"por_modulo": detalhe,
|
| 133 |
+
"nota": "bench_v090 (54) é binário de MEDIÇÃO (assertivo por design); "
|
| 134 |
+
"lib.rs (80) concentra demos PyO3 (panic → PyErr no Python, "
|
| 135 |
+
"não silencioso); módulos v0.11 asm/raciocinio_elastico com "
|
| 136 |
+
"ZERO em código; sort/max por total_cmp (sem panic em NaN); "
|
| 137 |
+
"AdamW e tokenizador sem unwrap; débito priorizado em r-43 §5",
|
| 138 |
+
}
|
| 139 |
+
|
| 140 |
+
with open(os.path.join(R, "telemetria_v011.json"), "w") as f:
|
| 141 |
+
json.dump(rel, f, indent=1, ensure_ascii=False)
|
| 142 |
+
print(json.dumps(rel, indent=1, ensure_ascii=False))
|
| 143 |
+
return 0
|
| 144 |
+
|
| 145 |
+
|
| 146 |
+
if __name__ == "__main__":
|
| 147 |
+
main()
|
scripts/82_publicar_v011.py
ADDED
|
@@ -0,0 +1,223 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
#!/usr/bin/env python3
|
| 2 |
+
"""82_publicar_v011.py — Publicação da v0.11.0 no HF (UM ÚNICO upload_folder
|
| 3 |
+
organizado — o HF bloqueia envios parciais em sequência; upload atômico).
|
| 4 |
+
|
| 5 |
+
Fases:
|
| 6 |
+
1. inventário da conta + APAGAMENTO de estados de treino remanescentes;
|
| 7 |
+
2. varredura local do VALOR do token (nenhum arquivo pode contê-lo);
|
| 8 |
+
3. UM ÚNICO upload_folder com ignore_patterns EXPLÍCITOS +
|
| 9 |
+
delete_patterns p/ os RESTOS do split SRP v0.10 (src/jepa/, src/
|
| 10 |
+
pensamento/, src/moe_redirecionavel/, src/python/ — a árvore canônica
|
| 11 |
+
v0.11 voltou aos arquivos planos; o ramo morto vive em
|
| 12 |
+
arquivo_split_v100/ NÃO publicado);
|
| 13 |
+
4. verificação pós-upload (0 estados, módulos-chave presentes, sem dirs
|
| 14 |
+
do split, sem arquivo_split);
|
| 15 |
+
5. varredura REMOTA do valor do token;
|
| 16 |
+
6. apagamento dos estados de treino LOCAIS (checkpoints + manifestos +
|
| 17 |
+
*.estado.json).
|
| 18 |
+
Token: EXCLUSIVAMENTE via variável de ambiente HF_TOKEN (nunca em arquivo).
|
| 19 |
+
"""
|
| 20 |
+
import os
|
| 21 |
+
import sys
|
| 22 |
+
import tempfile
|
| 23 |
+
|
| 24 |
+
ARQUIVOS_EXCLUIR_DIRS = {"target", ".cargo", "__pycache__", ".git", ".venv",
|
| 25 |
+
"skills", "externos", "arquivo_split_v100"}
|
| 26 |
+
ARQUIVOS_EXCLUIR_NOME = {"shard_treino.jsonl", "shard_validacao.jsonl",
|
| 27 |
+
"bpe.json", "rustup-init.sh"}
|
| 28 |
+
SUFIXOS_ESTADO = (".pt", ".pth", ".ckpt", ".safetensors", ".bin", ".npz",
|
| 29 |
+
".msgpack")
|
| 30 |
+
NOMES_ESTADO = {"gerador_conceitos.json", "tokenizador_conceitos.json",
|
| 31 |
+
"gerador_aritmetica.json", "_drill_ck.json"}
|
| 32 |
+
# restos do split SRP v0.10 (canon v0.11 = arquivos planos)
|
| 33 |
+
DIRS_SPLIT = ["src/jepa", "src/pensamento", "src/moe_redirecionavel",
|
| 34 |
+
"src/python"]
|
| 35 |
+
|
| 36 |
+
|
| 37 |
+
def coletar(pasta):
|
| 38 |
+
arquivos = {}
|
| 39 |
+
for raiz, dirs, fs in os.walk(pasta):
|
| 40 |
+
dirs[:] = [d for d in dirs if d not in ARQUIVOS_EXCLUIR_DIRS]
|
| 41 |
+
for f in fs:
|
| 42 |
+
if f in ARQUIVOS_EXCLUIR_NOME or f in NOMES_ESTADO:
|
| 43 |
+
continue
|
| 44 |
+
if f.endswith(SUFIXOS_ESTADO) or f.endswith(".estado.json"):
|
| 45 |
+
continue
|
| 46 |
+
if f.endswith(".manifest.json") or f.endswith(".manifest.json.tmp"):
|
| 47 |
+
continue
|
| 48 |
+
if f.endswith(".so") or f in (".gitignore", "Cargo.lock.ori"):
|
| 49 |
+
continue
|
| 50 |
+
if f.startswith("hf_") or f.startswith("intros_"):
|
| 51 |
+
continue
|
| 52 |
+
caminho = os.path.join(raiz, f)
|
| 53 |
+
arquivos[os.path.relpath(caminho, pasta)] = caminho
|
| 54 |
+
return arquivos
|
| 55 |
+
|
| 56 |
+
|
| 57 |
+
def varre_token_em_arquivos(token, pares):
|
| 58 |
+
tb = token.encode()
|
| 59 |
+
achados = []
|
| 60 |
+
for rel, p in pares.items():
|
| 61 |
+
try:
|
| 62 |
+
with open(p, "rb") as f:
|
| 63 |
+
if tb in f.read():
|
| 64 |
+
achados.append(rel)
|
| 65 |
+
except OSError:
|
| 66 |
+
pass
|
| 67 |
+
return achados
|
| 68 |
+
|
| 69 |
+
|
| 70 |
+
def main():
|
| 71 |
+
from huggingface_hub import HfApi
|
| 72 |
+
token = os.environ.get("HF_TOKEN")
|
| 73 |
+
if not token:
|
| 74 |
+
print("ERRO: HF_TOKEN ausente")
|
| 75 |
+
sys.exit(1)
|
| 76 |
+
api = HfApi(token=token)
|
| 77 |
+
repo = "PowerMachine/khtst-rust"
|
| 78 |
+
|
| 79 |
+
# ---------------- 1) inventário da conta + apaga estados ----------------
|
| 80 |
+
print("=== 1) inventário da conta HF (procura estados de treino) ===")
|
| 81 |
+
repos = list(api.list_models(author="PowerMachine"))
|
| 82 |
+
print(f"repos: {len(repos)}")
|
| 83 |
+
total_removidos = 0
|
| 84 |
+
for r in repos:
|
| 85 |
+
try:
|
| 86 |
+
files = api.list_repo_files(repo_id=r.id, repo_type="model")
|
| 87 |
+
except Exception as e:
|
| 88 |
+
print(f" {r.id}: erro ao listar ({e})")
|
| 89 |
+
continue
|
| 90 |
+
estados = [f for f in files
|
| 91 |
+
if f.endswith(SUFIXOS_ESTADO)
|
| 92 |
+
or f.split("/")[-1] in NOMES_ESTADO
|
| 93 |
+
or (".meta.json" in f and "checkpoint" in f)]
|
| 94 |
+
if estados:
|
| 95 |
+
print(f" {r.id}: APAGANDO {len(estados)} estados")
|
| 96 |
+
for f in estados:
|
| 97 |
+
api.delete_file(path_in_repo=f, repo_id=r.id, repo_type="model")
|
| 98 |
+
total_removidos += len(estados)
|
| 99 |
+
else:
|
| 100 |
+
print(f" {r.id}: {len(files)} arquivos, 0 estados")
|
| 101 |
+
print(f"estados removidos no total: {total_removidos}")
|
| 102 |
+
|
| 103 |
+
# ---------------- 2) varredura local do token ----------------
|
| 104 |
+
pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
| 105 |
+
arquivos = coletar(pasta)
|
| 106 |
+
print(f"\n=== 2) varredura local: {len(arquivos)} arquivos ===")
|
| 107 |
+
achados = varre_token_em_arquivos(token, arquivos)
|
| 108 |
+
if achados:
|
| 109 |
+
print(f"ERRO: valor do token encontrado em: {achados}")
|
| 110 |
+
sys.exit(1)
|
| 111 |
+
print("varredura de token local: limpa")
|
| 112 |
+
|
| 113 |
+
# ---------------- 3) UM ÚNICO upload_folder ----------------
|
| 114 |
+
ignores = (
|
| 115 |
+
[f"{d}/**" for d in ARQUIVOS_EXCLUIR_DIRS]
|
| 116 |
+
+ [f"{d}" for d in ARQUIVOS_EXCLUIR_DIRS]
|
| 117 |
+
+ [f"**/{n}" for n in ARQUIVOS_EXCLUIR_NOME]
|
| 118 |
+
+ [f"**/{n}" for n in NOMES_ESTADO]
|
| 119 |
+
+ list(SUFIXOS_ESTADO)
|
| 120 |
+
+ ["*.so", ".gitignore", "hf_*.py", "hf_*.json", "intros_*.json",
|
| 121 |
+
"*.estado.json", "**/*.manifest.json", "**/*.manifest.json.tmp",
|
| 122 |
+
"*.tmp"]
|
| 123 |
+
)
|
| 124 |
+
deletes = [f"{d}/**" for d in DIRS_SPLIT] + DIRS_SPLIT
|
| 125 |
+
print(f"\n=== 3) upload_folder ÚNICO ({len(arquivos)} arquivos; "
|
| 126 |
+
f"delete: {DIRS_SPLIT}) ===")
|
| 127 |
+
api.upload_folder(
|
| 128 |
+
repo_id=repo, repo_type="model", folder_path=pasta,
|
| 129 |
+
ignore_patterns=ignores,
|
| 130 |
+
delete_patterns=deletes,
|
| 131 |
+
commit_message="v0.11.0: provas r-36..r-42 completadas (M-R5′ guloso "
|
| 132 |
+
"ótimo com contraexemplo exausto, V-2′ ECE_aceito com errata "
|
| 133 |
+
"reproduzida, H-1′ pin slot) + raciocínio elástico RE-1..RE-8 "
|
| 134 |
+
"(ênfase Hedge previsível, water-filling, certificado de compressão "
|
| 135 |
+
"com bound estendido triangular e rollback defensivo) + tratamento "
|
| 136 |
+
"de erros Rust&Assembly (tratamento.txt): kernels add/jc (CF) e "
|
| 137 |
+
"ucomisd/ucomiss (PF) com códigos em registrador → Result, "
|
| 138 |
+
"module::error thiserror, 13 sorts total_cmp (NaN nunca mais pânico "
|
| 139 |
+
"no treino), checkpoint atômico SHA-256 restaurado e integrado ao "
|
| 140 |
+
"treino real, tipos de domínio, MotorPensamento::novo_com_rng "
|
| 141 |
+
"determinístico — árvore canônica plana (restos do split v0.10 "
|
| 142 |
+
"removidos; ramo morto arquivado localmente) — 160/160 cargo 3×, "
|
| 143 |
+
"29/29 gates (79), 9/9 avaliação real Wikipédia PT-BR (80)",
|
| 144 |
+
)
|
| 145 |
+
print("upload concluído")
|
| 146 |
+
|
| 147 |
+
# ---------------- 4) verificação pós-upload ----------------
|
| 148 |
+
print("\n=== 4) verificação pós-upload ===")
|
| 149 |
+
files = api.list_repo_files(repo_id=repo, repo_type="model")
|
| 150 |
+
estados = [f for f in files if f.endswith(SUFIXOS_ESTADO)
|
| 151 |
+
or f.split("/")[-1] in NOMES_ESTADO
|
| 152 |
+
or f.endswith(".manifest.json")]
|
| 153 |
+
assert not estados, f"estados publicados: {estados}"
|
| 154 |
+
chaves = ["src/asm.rs", "src/raciocinio_elastico.rs", "src/checkpoint.rs",
|
| 155 |
+
"src/tipos.rs", "src/jepa.rs", "src/pensamento.rs",
|
| 156 |
+
"src/moe_redirecionavel.rs", "src/som4d.rs", "src/fnh.rs",
|
| 157 |
+
"src/verificador.rs", "src/lib.rs",
|
| 158 |
+
"scripts/79_suite_v011.py", "scripts/80_avaliacao_real_v011.py",
|
| 159 |
+
"scripts/81_telemetria_v011.py", "scripts/82_publicar_v011.py",
|
| 160 |
+
"docs/memorias/r-36-provas-som-v011.md",
|
| 161 |
+
"docs/memorias/r-37-provas-jepa-v011.md",
|
| 162 |
+
"docs/memorias/r-38-provas-ncm-v011.md",
|
| 163 |
+
"docs/memorias/r-39-provas-pensamento-v011.md",
|
| 164 |
+
"docs/memorias/r-40-provas-verificador-v011.md",
|
| 165 |
+
"docs/memorias/r-41-provas-moe-fnh-v011.md",
|
| 166 |
+
"docs/memorias/r-42-raciocinio-elastico-v011.md",
|
| 167 |
+
"docs/memorias/r-43-tratamento-erros-asm-v011.md",
|
| 168 |
+
"resultados/suite_v011_final.json",
|
| 169 |
+
"resultados/avaliacao_real_v011.json",
|
| 170 |
+
"resultados/telemetria_v011.json"]
|
| 171 |
+
faltando = [c for c in chaves if c not in files]
|
| 172 |
+
assert not faltando, f"faltando: {faltando}"
|
| 173 |
+
split_resto = [f for f in files if any(f.startswith(d + "/") for d in DIRS_SPLIT)]
|
| 174 |
+
assert not split_resto, f"restos do split ainda no repo: {split_resto[:5]}"
|
| 175 |
+
print(f"repo: {len(files)} arquivos | 0 estados | módulos-chave OK | "
|
| 176 |
+
f"split v0.10 removido")
|
| 177 |
+
|
| 178 |
+
# ---------------- 5) varredura REMOTA do token ----------------
|
| 179 |
+
print("\n=== 5) varredura REMOTA do valor do token ===")
|
| 180 |
+
with tempfile.TemporaryDirectory() as tmp:
|
| 181 |
+
achados_remotos = []
|
| 182 |
+
for f in files:
|
| 183 |
+
if f.endswith((".py", ".rs", ".md", ".json", ".toml", ".sh", ".cfg",
|
| 184 |
+
".txt", ".jsonl")):
|
| 185 |
+
try:
|
| 186 |
+
p = api.hf_hub_download(repo_id=repo, repo_type="model",
|
| 187 |
+
filename=f, local_dir=tmp)
|
| 188 |
+
with open(p, "rb") as fh:
|
| 189 |
+
if token.encode() in fh.read():
|
| 190 |
+
achados_remotos.append(f)
|
| 191 |
+
except Exception:
|
| 192 |
+
pass
|
| 193 |
+
if achados_remotos:
|
| 194 |
+
print(f"ERRO: token remoto em: {achados_remotos}")
|
| 195 |
+
sys.exit(1)
|
| 196 |
+
print("varredura remota: limpa")
|
| 197 |
+
|
| 198 |
+
# ---------------- 6) apaga estados de treino LOCAIS ----------------
|
| 199 |
+
print("\n=== 6) estados de treino locais (checkpoints + manifestos) ===")
|
| 200 |
+
apagados = 0
|
| 201 |
+
for nome in sorted(NOMES_ESTADO):
|
| 202 |
+
for sufixo in ("", ".manifest.json", ".estado.json"):
|
| 203 |
+
p = os.path.join(pasta, "resultados", nome + sufixo)
|
| 204 |
+
if os.path.exists(p):
|
| 205 |
+
os.remove(p)
|
| 206 |
+
apagados += 1
|
| 207 |
+
print(f" apagado: resultados/{nome}{sufixo}")
|
| 208 |
+
# varredura final de qualquer outro estado no projeto
|
| 209 |
+
for raiz, dirs, fs in os.walk(pasta):
|
| 210 |
+
dirs[:] = [d for d in dirs if d not in {"target", ".git", ".venv"}]
|
| 211 |
+
for f in fs:
|
| 212 |
+
if (f.endswith(SUFIXOS_ESTADO) or f.endswith(".estado.json")) and \
|
| 213 |
+
"resultados" in raiz:
|
| 214 |
+
p = os.path.join(raiz, f)
|
| 215 |
+
os.remove(p)
|
| 216 |
+
apagados += 1
|
| 217 |
+
print(f" apagado: {os.path.relpath(p, pasta)}")
|
| 218 |
+
print(f"locais apagados: {apagados}")
|
| 219 |
+
print("\nPUBLICAÇÃO v0.11.0 CONCLUÍDA")
|
| 220 |
+
|
| 221 |
+
|
| 222 |
+
if __name__ == "__main__":
|
| 223 |
+
main()
|
src/asm.rs
ADDED
|
@@ -0,0 +1,303 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
//! `asm` — v0.11.0 (tratamento.txt §1+§2): kernels x86-64 em Assembly inline
|
| 2 |
+
//! (`core::arch::asm!`) com tratamento de erros por FLAGS do processador,
|
| 3 |
+
//! integrados ao protocolo Rust `Result<T, E>` — nunca `panic!` em estado
|
| 4 |
+
//! inválido (tratamento.txt: "erros recuperáveis e irrecuperáveis").
|
| 5 |
+
//!
|
| 6 |
+
//! # Protocolo de erro híbrido (Rust ⇄ Assembly)
|
| 7 |
+
//!
|
| 8 |
+
//! 1. **Rust (边界/validação)**: comprimentos e pré-condições são validados
|
| 9 |
+
//! ANTES do bloco asm ("valide os limites de pilha e divisores antes de
|
| 10 |
+
//! executar instruções críticas") — o Assembly nunca recebe entrada
|
| 11 |
+
//! inválida de estrutura (apenas valores que podem estourar).
|
| 12 |
+
//! 2. **Assembly (detecção)**: cada kernel lê o Registrador de Flags
|
| 13 |
+
//! (RFLAGS) após a instrução sensível e desvia com `jcc` condicional:
|
| 14 |
+
//! - `CF` (Carry Flag): overflow SEM SINAL — indicador EXATO de estouro
|
| 15 |
+
//! em adição `u64` (tratamento.txt §2: "empréstimo/overflow sem sinal");
|
| 16 |
+
//! - `PF` (Parity Flag): após `ucomisd`/`ucomiss`, PF=1 ⇔ comparação
|
| 17 |
+
//! UNORDERED ⇔ algum operando é NaN (detecção de NaN por hardware);
|
| 18 |
+
//! - `ZF` (Zero Flag): igualdade de ponteiros/contadores no fim de laço.
|
| 19 |
+
//! 3. **Convenção de retorno**: o bloco asm devolve um CÓDIGO NUMÉRICO em
|
| 20 |
+
//! registrador de propósito geral (tratamento.txt §2: "códigos de retorno
|
| 21 |
+
//! em registradores... 0 significa sucesso") que o Rust converte em
|
| 22 |
+
//! `Result` — o caminho feliz nunca silencia o erro.
|
| 23 |
+
//!
|
| 24 |
+
//! # Registradores e flags alterados (documentação obrigatória)
|
| 25 |
+
//!
|
| 26 |
+
//! | Kernel | Instrução sensível | Flags que altera | Flag consumida | Clobbers |
|
| 27 |
+
//! |---|---|---|---|---|
|
| 28 |
+
//! | `soma_u64_cheia` | `add` | AF CF OF SF ZF PF | `CF` (`jc`) | 3 GPRs (declarados) |
|
| 29 |
+
//! | `primeiro_nan_f64` | `ucomisd` | ZF PF CF | `PF` (`jp`) | 3 GPRs + 1 XMM |
|
| 30 |
+
//! | `primeiro_nan_f32` | `ucomiss` | ZF PF CF | `PF` (`jp`) | 3 GPRs + 1 XMM |
|
| 31 |
+
//!
|
| 32 |
+
//! O compilador Rust recebe a lista `in`/`out`/`inout` COMPLETA — nenhum
|
| 33 |
+
//! registrador é alterado implicitamente (clobber oculto = bug).
|
| 34 |
+
|
| 35 |
+
use std::arch::asm;
|
| 36 |
+
|
| 37 |
+
/// Padrão `module::error` (tratamento.txt §1): enum coeso no escopo do
|
| 38 |
+
/// módulo, `thiserror` para Display/Error sem código repetido.
|
| 39 |
+
pub mod error {
|
| 40 |
+
#[derive(Debug, Clone, PartialEq, thiserror::Error)]
|
| 41 |
+
pub enum ErroAsm {
|
| 42 |
+
/// `CF=1` após `add`: a soma excede `u64::MAX` — o valor NÃO é
|
| 43 |
+
/// confiável (wraparound evitado por hardware, não por software).
|
| 44 |
+
#[error("estouro de soma u64: {n} parcelas ultrapassam u64::MAX (CF=1 no kernel add/jc)")]
|
| 45 |
+
EstouroSoma { n: usize },
|
| 46 |
+
/// Pré-condição estrutural violada (nunca deve ocorrer via API pública).
|
| 47 |
+
#[error("pré-condição violada: {motivo}")]
|
| 48 |
+
PreCondicao { motivo: String },
|
| 49 |
+
}
|
| 50 |
+
}
|
| 51 |
+
|
| 52 |
+
pub use error::ErroAsm;
|
| 53 |
+
|
| 54 |
+
/// **Kernel 1 — soma u64 com estouro detectado por Carry Flag.**
|
| 55 |
+
///
|
| 56 |
+
/// Lógica computacional (prova por caso):
|
| 57 |
+
/// - `add rax, [ptr]` com valores u64: o processador soma em largura fixa
|
| 58 |
+
/// de 64 bits e arma `CF=1` sse o resultado verdadeiro ≥ 2^64 (definição
|
| 59 |
+
/// do sinal de carry em adição sem sinal — manual Intel, ADD). Não existe
|
| 60 |
+
/// estado intermediário: OU cabe (CF=0, soma exata), OU estoura (CF=1).
|
| 61 |
+
/// - `jc 1f` consome CF imediatamente após a adição (nenhuma instrução
|
| 62 |
+
/// intermediária altera flags — `add ptr, 8` vem DEPOIS do desvio).
|
| 63 |
+
/// - O laço termina por `cmp`/`jne` (ZF=0 ⇒ ponteiros distintos): após a
|
| 64 |
+
/// última parcela, `p == f` ⇒ ZF=1 ⇒ não desvia ⇒ sai com código 0.
|
| 65 |
+
/// - Com `CF=1` o kernel desvia para `mov {e}, 1` (código de erro 1 em
|
| 66 |
+
/// registrador — convenção tratamento.txt §2) e a soma parcial é
|
| 67 |
+
/// DESCARTADA pelo Rust (`Err`).
|
| 68 |
+
///
|
| 69 |
+
/// Determinismo: uma única ordem de soma (esquerda→direita) — o resultado é
|
| 70 |
+
/// bit-a-bit reprodutível (u64 é associativo/exato quando não estoura).
|
| 71 |
+
pub fn soma_u64_cheia(xs: &[u64]) -> Result<u64, ErroAsm> {
|
| 72 |
+
if xs.is_empty() {
|
| 73 |
+
return Ok(0); // validação de fronteira em Rust (tratamento.txt)
|
| 74 |
+
}
|
| 75 |
+
let mut soma: u64 = 0;
|
| 76 |
+
let mut codigo_erro: u64;
|
| 77 |
+
// {p} é inout: o kernel AVANÇA o ponteiro — modificar um `in` é UB
|
| 78 |
+
// de alocação de registradores (lesson v011-1, bug meu catalogado)
|
| 79 |
+
let mut ptr = xs.as_ptr();
|
| 80 |
+
unsafe {
|
| 81 |
+
asm!(
|
| 82 |
+
"xor {e}, {e}", // e := 0 (sucesso); ZF=1 (não consumido)
|
| 83 |
+
"2:", // ── corpo do laço ──
|
| 84 |
+
"add {s}, [{p}]", // soma += *p [AF CF OF SF ZF PF]
|
| 85 |
+
"jc 3f", // CF=1 ⇒ estouro sem sinal ⇒ erro
|
| 86 |
+
"add {p}, 8", // p += 8 (flags alteradas, NÃO consumidas)
|
| 87 |
+
"cmp {p}, {f}", // p == fim? [CF OF SF ZF PF]
|
| 88 |
+
"jne 2b", // ZF=0 ⇒ continua
|
| 89 |
+
"jmp 4f", // fim normal: código 0 preservado
|
| 90 |
+
"3:", // ── caminho de ERRO ──
|
| 91 |
+
"mov {e}, 1", // código de erro 1 (registrador)
|
| 92 |
+
"4:",
|
| 93 |
+
s = inout(reg) soma,
|
| 94 |
+
p = inout(reg) ptr,
|
| 95 |
+
f = in(reg) xs.as_ptr().wrapping_add(xs.len()),
|
| 96 |
+
e = out(reg) codigo_erro,
|
| 97 |
+
);
|
| 98 |
+
}
|
| 99 |
+
if codigo_erro != 0 {
|
| 100 |
+
return Err(ErroAsm::EstouroSoma { n: xs.len() });
|
| 101 |
+
}
|
| 102 |
+
Ok(soma)
|
| 103 |
+
}
|
| 104 |
+
|
| 105 |
+
/// **Kernel 2 — primeiro NaN f64 detectado por Parity Flag (ucomisd).**
|
| 106 |
+
///
|
| 107 |
+
/// Lógica computacional:
|
| 108 |
+
/// - `ucomisd xmm0, [ptr]` compara 0.0 (em xmm) com o valor da fatia:
|
| 109 |
+
/// o sinal PF é armado ⇔ a comparação é UNORDERED ⇔ ALGUM operando é NaN
|
| 110 |
+
/// (manual Intel, UCOMISD: "unordered" ⇔ QNaN/SNaN em qualquer lado).
|
| 111 |
+
/// Como 0.0 é sempre ordenado, PF=1 ⇔ o ELEMENTO é NaN (por eliminação).
|
| 112 |
+
/// - `jp 1f` consome PF imediatamente; `i` preserva o ÍNDICE exato do
|
| 113 |
+
/// primeiro NaN (código de retorno em registrador — o chamador sabe ONDE,
|
| 114 |
+
/// não apenas SE).
|
| 115 |
+
/// - Laço `cmp {i}, {n}` / `jne 2b` (ZF): termina com sentinel `−1` (64 bits
|
| 116 |
+
/// complemento-2 = `u64::MAX`) quando nenhum NaN existe.
|
| 117 |
+
/// - Exceção de ponto flutuante #I (invalid) de QNaN está MASCARADA por
|
| 118 |
+
/// padrão no MXCSR do processo Rust — o único efeito observável é PF=1.
|
| 119 |
+
///
|
| 120 |
+
/// Devolve `Ok(Some(idx))` no primeiro NaN, `Ok(None)` se a fatia é limpa.
|
| 121 |
+
pub fn primeiro_nan_f64(xs: &[f64]) -> Result<Option<usize>, ErroAsm> {
|
| 122 |
+
if xs.is_empty() {
|
| 123 |
+
return Ok(None);
|
| 124 |
+
}
|
| 125 |
+
let mut idx: u64;
|
| 126 |
+
// {p} é inout (o kernel avança o ponteiro — v011-1)
|
| 127 |
+
let mut ptr = xs.as_ptr();
|
| 128 |
+
unsafe {
|
| 129 |
+
asm!(
|
| 130 |
+
"xor {i}, {i}", // i := 0 (índice corrente); ZF=1
|
| 131 |
+
"2:", // ── corpo do laço ──
|
| 132 |
+
"ucomisd {zero}, [{p}]", // 0.0 vs xs[i] [ZF PF CF]
|
| 133 |
+
"jp 3f", // PF=1 ⇒ unordered ⇒ NaN no índice i
|
| 134 |
+
"add {p}, 8", // p += 8 (flags não consumidas)
|
| 135 |
+
"add {i}, 1", // i += 1 (flags não consumidas)
|
| 136 |
+
"cmp {i}, {n}", // i == n? [ZF CF OF SF PF]
|
| 137 |
+
"jne 2b", // ZF=0 ⇒ continua
|
| 138 |
+
"mov {i}, -1", // sentinel NOT_FOUND (u64::MAX)
|
| 139 |
+
"jmp 4f",
|
| 140 |
+
"3:", // ── achou: i já é o índice ──
|
| 141 |
+
"4:",
|
| 142 |
+
zero = in(xmm_reg) 0f64,
|
| 143 |
+
p = inout(reg) ptr,
|
| 144 |
+
n = in(reg) xs.len() as u64,
|
| 145 |
+
i = out(reg) idx,
|
| 146 |
+
);
|
| 147 |
+
}
|
| 148 |
+
if idx == u64::MAX {
|
| 149 |
+
return Ok(None);
|
| 150 |
+
}
|
| 151 |
+
Ok(Some(idx as usize))
|
| 152 |
+
}
|
| 153 |
+
|
| 154 |
+
/// **Kernel 3 — primeiro NaN f32 (ucomiss/jp)** — idem ao Kernel 2 em
|
| 155 |
+
/// precisão simples (os gradientes do treino são `Vec<f32>`).
|
| 156 |
+
pub fn primeiro_nan_f32(xs: &[f32]) -> Result<Option<usize>, ErroAsm> {
|
| 157 |
+
if xs.is_empty() {
|
| 158 |
+
return Ok(None);
|
| 159 |
+
}
|
| 160 |
+
let mut idx: u64;
|
| 161 |
+
// {p} é inout (o kernel avança o ponteiro — v011-1)
|
| 162 |
+
let mut ptr = xs.as_ptr();
|
| 163 |
+
unsafe {
|
| 164 |
+
asm!(
|
| 165 |
+
"xor {i}, {i}",
|
| 166 |
+
"2:",
|
| 167 |
+
"ucomiss {zero}, [{p}]", // 0.0f vs xs[i] [ZF PF CF]
|
| 168 |
+
"jp 3f", // PF=1 ⇒ NaN no índice i
|
| 169 |
+
"add {p}, 4", // passo de 4 bytes (f32)
|
| 170 |
+
"add {i}, 1",
|
| 171 |
+
"cmp {i}, {n}",
|
| 172 |
+
"jne 2b",
|
| 173 |
+
"mov {i}, -1",
|
| 174 |
+
"jmp 4f",
|
| 175 |
+
"3:",
|
| 176 |
+
"4:",
|
| 177 |
+
zero = in(xmm_reg) 0f32,
|
| 178 |
+
p = inout(reg) ptr,
|
| 179 |
+
n = in(reg) xs.len() as u64,
|
| 180 |
+
i = out(reg) idx,
|
| 181 |
+
);
|
| 182 |
+
}
|
| 183 |
+
if idx == u64::MAX {
|
| 184 |
+
return Ok(None);
|
| 185 |
+
}
|
| 186 |
+
Ok(Some(idx as usize))
|
| 187 |
+
}
|
| 188 |
+
|
| 189 |
+
/// Relatório do módulo (telemetria): alvo e kernels disponíveis.
|
| 190 |
+
pub fn relatorio() -> String {
|
| 191 |
+
format!(
|
| 192 |
+
"asm-0.11.0 | target x86-64 System V | kernels: soma_u64_cheia (add/jc, CF), \
|
| 193 |
+
primeiro_nan_f64 (ucomisd/jp, PF), primeiro_nan_f32 (ucomiss/jp, PF) | \
|
| 194 |
+
protocolo: código em registrador -> Result (tratamento.txt §1+§2)"
|
| 195 |
+
)
|
| 196 |
+
}
|
| 197 |
+
|
| 198 |
+
pub fn versao() -> &'static str {
|
| 199 |
+
"asm-0.11.0"
|
| 200 |
+
}
|
| 201 |
+
|
| 202 |
+
// ---------------------------------------------------------------------------
|
| 203 |
+
// Testes de falsificação (lógica computacional dos flags)
|
| 204 |
+
// ---------------------------------------------------------------------------
|
| 205 |
+
|
| 206 |
+
#[cfg(test)]
|
| 207 |
+
mod testes {
|
| 208 |
+
use super::*;
|
| 209 |
+
|
| 210 |
+
/// CF=1 exato: u64::MAX + 1 estoura e o kernel reporta (não wrapa).
|
| 211 |
+
#[test]
|
| 212 |
+
fn soma_estoura_na_segunda_parcela() {
|
| 213 |
+
assert_eq!(soma_u64_cheia(&[u64::MAX, 1]).unwrap_err(), ErroAsm::EstouroSoma { n: 2 });
|
| 214 |
+
assert_eq!(soma_u64_cheia(&[u64::MAX]).unwrap(), u64::MAX); // 1 parcela: ok
|
| 215 |
+
assert_eq!(
|
| 216 |
+
soma_u64_cheia(&[u64::MAX; 3]).unwrap_err(),
|
| 217 |
+
ErroAsm::EstouroSoma { n: 3 }
|
| 218 |
+
);
|
| 219 |
+
}
|
| 220 |
+
|
| 221 |
+
/// Equivalência EXATA com a soma Rust (u64 é associativo sem estouro).
|
| 222 |
+
#[test]
|
| 223 |
+
fn soma_equivalente_rust() {
|
| 224 |
+
let mut rng = crate::rng::RngDeterministico::novo(3);
|
| 225 |
+
for caso in 0..8 {
|
| 226 |
+
let n = 1 + caso * 37;
|
| 227 |
+
let v: Vec<u64> = (0..n).map(|_| (rng.uniforme() * 1e6) as u64).collect();
|
| 228 |
+
let esperado: u64 = v.iter().sum();
|
| 229 |
+
assert_eq!(soma_u64_cheia(&v).unwrap(), esperado, "caso {caso}");
|
| 230 |
+
}
|
| 231 |
+
// fronteira: soma que CHEGA exatamente em u64::MAX (CF=0)
|
| 232 |
+
assert_eq!(soma_u64_cheia(&[u64::MAX - 5, 5]).unwrap(), u64::MAX);
|
| 233 |
+
// fronteira: u64::MAX-1 + 1 = MAX (ok) e MAX + MAX (estoura)
|
| 234 |
+
assert_eq!(soma_u64_cheia(&[u64::MAX - 1, 1]).unwrap(), u64::MAX);
|
| 235 |
+
assert!(soma_u64_cheia(&[u64::MAX, u64::MAX]).is_err());
|
| 236 |
+
// vazio => Ok(0) (fronteira validada em Rust antes do asm)
|
| 237 |
+
assert_eq!(soma_u64_cheia(&[]).unwrap(), 0);
|
| 238 |
+
}
|
| 239 |
+
|
| 240 |
+
/// PF=1 exato: NaN em posição conhecida (quiet e signaling).
|
| 241 |
+
#[test]
|
| 242 |
+
fn nan_f64_localizado() {
|
| 243 |
+
let limpo: Vec<f64> = (0..1000).map(|i| i as f64 * 0.5 - 250.0).collect();
|
| 244 |
+
assert_eq!(primeiro_nan_f64(&limpo).unwrap(), None);
|
| 245 |
+
// quiet NaN (0x7FF8...) na posição 7
|
| 246 |
+
let mut v = limpo.clone();
|
| 247 |
+
v[7] = f64::from_bits(0x7FF8_0000_0000_0000);
|
| 248 |
+
assert_eq!(primeiro_nan_f64(&v).unwrap(), Some(7));
|
| 249 |
+
// signaling NaN (0x7FF0...001) na posição 0
|
| 250 |
+
v = limpo.clone();
|
| 251 |
+
v[0] = f64::from_bits(0x7FF0_0000_0000_0001);
|
| 252 |
+
assert_eq!(primeiro_nan_f64(&v).unwrap(), Some(0));
|
| 253 |
+
// último elemento
|
| 254 |
+
v = limpo.clone();
|
| 255 |
+
v[999] = f64::NAN;
|
| 256 |
+
assert_eq!(primeiro_nan_f64(&v).unwrap(), Some(999));
|
| 257 |
+
// inf NÃO é NaN (ucomisd ordenado com +inf) => None
|
| 258 |
+
v = limpo.clone();
|
| 259 |
+
v[500] = f64::INFINITY;
|
| 260 |
+
v[501] = f64::NEG_INFINITY;
|
| 261 |
+
assert_eq!(primeiro_nan_f64(&v).unwrap(), None);
|
| 262 |
+
// vazio => None
|
| 263 |
+
assert_eq!(primeiro_nan_f64(&[]).unwrap(), None);
|
| 264 |
+
}
|
| 265 |
+
|
| 266 |
+
/// PF=1 em f32 (gradientes do treino são Vec<f32>).
|
| 267 |
+
#[test]
|
| 268 |
+
fn nan_f32_localizado() {
|
| 269 |
+
let limpo: Vec<f32> = (0..512).map(|i| i as f32 - 256.0).collect();
|
| 270 |
+
assert_eq!(primeiro_nan_f32(&limpo).unwrap(), None);
|
| 271 |
+
let mut v = limpo.clone();
|
| 272 |
+
v[13] = f32::NAN;
|
| 273 |
+
assert_eq!(primeiro_nan_f32(&v).unwrap(), Some(13));
|
| 274 |
+
v[0] = f32::from_bits(0x7FC0_0000); // QNaN
|
| 275 |
+
assert_eq!(primeiro_nan_f32(&v).unwrap(), Some(0));
|
| 276 |
+
v = limpo.clone();
|
| 277 |
+
v[511] = f32::NAN;
|
| 278 |
+
assert_eq!(primeiro_nan_f32(&v).unwrap(), Some(511));
|
| 279 |
+
// inf/‑inf não são NaN
|
| 280 |
+
v = limpo.clone();
|
| 281 |
+
v[10] = f32::INFINITY;
|
| 282 |
+
assert_eq!(primeiro_nan_f32(&v).unwrap(), None);
|
| 283 |
+
}
|
| 284 |
+
|
| 285 |
+
/// Desempenho honesto: o kernel asm NÃO é mais lento que o iterador
|
| 286 |
+
/// Rust (verificação de sanidade — mesma ordem de grandeza).
|
| 287 |
+
#[test]
|
| 288 |
+
fn desempenho_comparavel_rust() {
|
| 289 |
+
let v: Vec<f64> = (0..1_000_000).map(|i| (i % 97) as f64 * 0.001).collect();
|
| 290 |
+
let t0 = std::time::Instant::now();
|
| 291 |
+
let r_asm = primeiro_nan_f64(&v).unwrap();
|
| 292 |
+
let d_asm = t0.elapsed();
|
| 293 |
+
let t1 = std::time::Instant::now();
|
| 294 |
+
let r_rust = v.iter().position(|x| x.is_nan());
|
| 295 |
+
let d_rust = t1.elapsed();
|
| 296 |
+
assert_eq!(r_asm, r_rust);
|
| 297 |
+
// tolerância 10× (kernel escalar por elemento; nunca deve ser 10× pior)
|
| 298 |
+
assert!(
|
| 299 |
+
d_asm.as_nanos() <= 10 * d_rust.as_nanos().max(1),
|
| 300 |
+
"asm {d_asm:?} vs rust {d_rust:?}"
|
| 301 |
+
);
|
| 302 |
+
}
|
| 303 |
+
}
|
src/bin/bench_v090.rs
CHANGED
|
@@ -10,7 +10,7 @@ use std::hint::black_box;
|
|
| 10 |
use std::time::Instant;
|
| 11 |
|
| 12 |
fn mediana(mut xs: Vec<f64>) -> f64 {
|
| 13 |
-
xs.sort_by(|a, b| a.
|
| 14 |
xs[xs.len() / 2]
|
| 15 |
}
|
| 16 |
|
|
|
|
| 10 |
use std::time::Instant;
|
| 11 |
|
| 12 |
fn mediana(mut xs: Vec<f64>) -> f64 {
|
| 13 |
+
xs.sort_by(|a, b| a.total_cmp(b));
|
| 14 |
xs[xs.len() / 2]
|
| 15 |
}
|
| 16 |
|
src/controlador.rs
CHANGED
|
@@ -95,7 +95,7 @@ impl Controlador {
|
|
| 95 |
pub fn clip_corrente(&mut self, hub: &mut TelemetryHub) -> f64 {
|
| 96 |
if self.normas_grad.len() >= 32 {
|
| 97 |
let mut v = self.normas_grad.clone();
|
| 98 |
-
v.sort_by(|a, b| a.
|
| 99 |
let idx = ((self.clip_percentil / 100.0) * (v.len() - 1) as f64).round() as usize;
|
| 100 |
let novo = v[idx.min(v.len() - 1)].max(0.25);
|
| 101 |
if (novo - self.clip).abs() / self.clip > 0.3 {
|
|
@@ -187,7 +187,7 @@ impl AutoAjustePensamento {
|
|
| 187 |
return self.tau_c; // amostra insuficiente — mantém (honesto)
|
| 188 |
}
|
| 189 |
let mut v = self.confs_retidas.clone();
|
| 190 |
-
v.sort_by(|a, b| a.
|
| 191 |
let idx = (((1.0 - epsilon.clamp(0.0, 0.5)) * v.len() as f64).ceil() as usize)
|
| 192 |
.saturating_sub(1)
|
| 193 |
.min(v.len() - 1);
|
|
@@ -215,7 +215,7 @@ impl AutoAjustePensamento {
|
|
| 215 |
if razoes.len() < 4 {
|
| 216 |
return self.orcamento_b;
|
| 217 |
}
|
| 218 |
-
razoes.sort_by(|a, b| a.
|
| 219 |
let rho = razoes[razoes.len() / 2]; // mediana (robusto)
|
| 220 |
let delta0 = self.ganhos_por_iteracao.iter().cloned().fold(f64::MIN, f64::max).max(1e-9);
|
| 221 |
// B* = ceil( ln(c·(1−ρ)/Δ) / ln(ρ) ) — ótimo do custo marginal
|
|
@@ -236,7 +236,7 @@ impl AutoAjustePensamento {
|
|
| 236 |
return self.n_tentativas;
|
| 237 |
}
|
| 238 |
let mut v = self.acordos.clone();
|
| 239 |
-
v.sort_by(|a, b| a.
|
| 240 |
let a_med = v[v.len() / 2];
|
| 241 |
// lema do acordo: a = p² + (1−p)² ⇒ p = (1 + √(2a−1))/2 (a ≥ 1/2)
|
| 242 |
let p_chapeu = if a_med >= 0.5 {
|
|
|
|
| 95 |
pub fn clip_corrente(&mut self, hub: &mut TelemetryHub) -> f64 {
|
| 96 |
if self.normas_grad.len() >= 32 {
|
| 97 |
let mut v = self.normas_grad.clone();
|
| 98 |
+
v.sort_by(|a, b| a.total_cmp(b));
|
| 99 |
let idx = ((self.clip_percentil / 100.0) * (v.len() - 1) as f64).round() as usize;
|
| 100 |
let novo = v[idx.min(v.len() - 1)].max(0.25);
|
| 101 |
if (novo - self.clip).abs() / self.clip > 0.3 {
|
|
|
|
| 187 |
return self.tau_c; // amostra insuficiente — mantém (honesto)
|
| 188 |
}
|
| 189 |
let mut v = self.confs_retidas.clone();
|
| 190 |
+
v.sort_by(|a, b| a.total_cmp(b));
|
| 191 |
let idx = (((1.0 - epsilon.clamp(0.0, 0.5)) * v.len() as f64).ceil() as usize)
|
| 192 |
.saturating_sub(1)
|
| 193 |
.min(v.len() - 1);
|
|
|
|
| 215 |
if razoes.len() < 4 {
|
| 216 |
return self.orcamento_b;
|
| 217 |
}
|
| 218 |
+
razoes.sort_by(|a, b| a.total_cmp(b));
|
| 219 |
let rho = razoes[razoes.len() / 2]; // mediana (robusto)
|
| 220 |
let delta0 = self.ganhos_por_iteracao.iter().cloned().fold(f64::MIN, f64::max).max(1e-9);
|
| 221 |
// B* = ceil( ln(c·(1−ρ)/Δ) / ln(ρ) ) — ótimo do custo marginal
|
|
|
|
| 236 |
return self.n_tentativas;
|
| 237 |
}
|
| 238 |
let mut v = self.acordos.clone();
|
| 239 |
+
v.sort_by(|a, b| a.total_cmp(b));
|
| 240 |
let a_med = v[v.len() / 2];
|
| 241 |
// lema do acordo: a = p² + (1−p)² ⇒ p = (1 + √(2a−1))/2 (a ≥ 1/2)
|
| 242 |
let p_chapeu = if a_med >= 0.5 {
|
src/fnh.rs
CHANGED
|
@@ -388,6 +388,22 @@ impl GatePunicao {
|
|
| 388 |
let sig = 1.0 / (1.0 + (-z).exp());
|
| 389 |
(2.0 * sig - 1.0).max(0.0)
|
| 390 |
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 391 |
}
|
| 392 |
|
| 393 |
/// Camada FNH — uma hipótese flexível com rotações aprendíveis, suavização de
|
|
|
|
| 388 |
let sig = 1.0 / (1.0 + (-z).exp());
|
| 389 |
(2.0 * sig - 1.0).max(0.0)
|
| 390 |
}
|
| 391 |
+
|
| 392 |
+
/// **v0.11.0 (tipos de domínio, T-V2):** gate TIPADO —
|
| 393 |
+
/// `Probabilidade → GateAtivacao`. O valor bruto é sempre ∈ [0,1]
|
| 394 |
+
/// (Teo F-3: sigmoide retificada), mas o construtor tipado é defesa em
|
| 395 |
+
/// profundidade: falha impossível vira clamp AUDITÁVEL com log (nunca
|
| 396 |
+
/// panic em caminho de produção — tratamento.txt §1).
|
| 397 |
+
pub fn valor_tipado(&self, punicao: &crate::tipos::Probabilidade) -> crate::tipos::GateAtivacao {
|
| 398 |
+
let g = self.valor(punicao.valor());
|
| 399 |
+
match crate::tipos::GateAtivacao::novo(g) {
|
| 400 |
+
Ok(t) => t,
|
| 401 |
+
Err(e) => {
|
| 402 |
+
log::error!("valor_tipado: gate {g} fora de [0,1] ({e}) — clamp a ZERO");
|
| 403 |
+
crate::tipos::GateAtivacao::ZERO
|
| 404 |
+
}
|
| 405 |
+
}
|
| 406 |
+
}
|
| 407 |
}
|
| 408 |
|
| 409 |
/// Camada FNH — uma hipótese flexível com rotações aprendíveis, suavização de
|
src/gerador.rs
CHANGED
|
@@ -246,9 +246,9 @@ impl GeradorConceitos {
|
|
| 246 |
}
|
| 247 |
let txt = serde_json::to_string(&serde_json::Value::Object(obj))
|
| 248 |
.map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?;
|
| 249 |
-
|
| 250 |
-
|
| 251 |
-
|
| 252 |
Ok(())
|
| 253 |
}
|
| 254 |
|
|
|
|
| 246 |
}
|
| 247 |
let txt = serde_json::to_string(&serde_json::Value::Object(obj))
|
| 248 |
.map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?;
|
| 249 |
+
// v0.11.0 (restaurado da v0.10.0): checkpoint ATÔMICO completo —
|
| 250 |
+
// tmp→fsync→rename→fsync(dir) + manifesto SHA-256 (Teo CP-1/CP-2)
|
| 251 |
+
crate::checkpoint::salvar_atomico(caminho, &txt)?;
|
| 252 |
Ok(())
|
| 253 |
}
|
| 254 |
|
src/jepa.rs
CHANGED
|
@@ -103,6 +103,40 @@ impl MlpJepa {
|
|
| 103 |
}
|
| 104 |
}
|
| 105 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 106 |
/// Núcleo JEPA: codificador + preditor + alvo EMA + regularizador VC.
|
| 107 |
pub struct NucleoJepa {
|
| 108 |
pub encoder: MlpJepa,
|
|
@@ -115,6 +149,12 @@ pub struct NucleoJepa {
|
|
| 115 |
pub m: f64,
|
| 116 |
pub lambda_vc: f64,
|
| 117 |
pub gamma_vc: f64,
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 118 |
}
|
| 119 |
|
| 120 |
impl NucleoJepa {
|
|
@@ -170,9 +210,21 @@ impl NucleoJepa {
|
|
| 170 |
m,
|
| 171 |
lambda_vc,
|
| 172 |
gamma_vc,
|
|
|
|
|
|
|
|
|
|
| 173 |
})
|
| 174 |
}
|
| 175 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 176 |
pub fn vars(&self) -> Vec<Var> {
|
| 177 |
let mut v = self.encoder.vars();
|
| 178 |
v.extend(self.preditor.vars());
|
|
@@ -219,29 +271,66 @@ impl NucleoJepa {
|
|
| 219 |
|
| 220 |
/// Regularizador variância-covariância do lote de incorporações z (n, d).
|
| 221 |
///
|
| 222 |
-
/// **J-1:** no colapso total `z_i = c ∀i` ⇒ `std_j = 0` ⇒
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 223 |
pub fn perda_vc(&self, z: &Tensor) -> Result<Tensor> {
|
| 224 |
let n = z.dim(0)? as f64;
|
| 225 |
let d = self.d_emb;
|
| 226 |
let media = z.mean_keepdim(0)?; // (1, d)
|
| 227 |
let centr = z.broadcast_sub(&media)?;
|
| 228 |
let var = (centr.sqr()?.sum(0)? / n)?; // (d,)
|
| 229 |
-
|
| 230 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 231 |
let gamma_t =
|
| 232 |
Tensor::new(self.gamma_vc as f32, z.device())?.broadcast_as(std.dims())?;
|
| 233 |
-
let gap =
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 234 |
let v = gap.sqr()?.sum_all()?;
|
| 235 |
-
// covariância fora-diagonal: C = centrᵀ·centr/n; perda = ‖C
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 236 |
let cov = (centr.transpose(0, 1)?.matmul(¢r)? / n)?; // (d, d)
|
| 237 |
-
let
|
| 238 |
-
let mut m = vec![
|
| 239 |
for i in 0..d {
|
| 240 |
-
m[i * d + i] =
|
| 241 |
}
|
| 242 |
Tensor::from_vec(m, (d, d), z.device())?
|
| 243 |
};
|
| 244 |
-
let fora = ((&cov * &
|
| 245 |
let v_norm = (v / d.max(1) as f64)?;
|
| 246 |
Ok((v_norm + fora)?)
|
| 247 |
}
|
|
@@ -440,7 +529,7 @@ pub fn pontos_mais_distantes(pontos: &[Vec<f64>], k: usize, rng: &mut RngDetermi
|
|
| 440 |
.iter()
|
| 441 |
.enumerate()
|
| 442 |
.filter(|(i, _)| !centros.contains(i))
|
| 443 |
-
.max_by(|a, b| a.1.
|
| 444 |
.map(|(i, _)| i)
|
| 445 |
.unwrap_or(0);
|
| 446 |
centros.push(prox);
|
|
@@ -588,7 +677,7 @@ pub fn em_grupos_pontos(pc: &Tensor, k: usize, m: usize, rng: &mut RngDeterminis
|
|
| 588 |
ord.sort_by(|&a, &b| {
|
| 589 |
let da = distancia_eucl(&coords_f[a], &coords_f[ci]);
|
| 590 |
let db = distancia_eucl(&coords_f[b], &coords_f[ci]);
|
| 591 |
-
da.
|
| 592 |
});
|
| 593 |
let mut buf: Vec<f32> = Vec::with_capacity(m * d);
|
| 594 |
for &idx in ord.iter().take(m) {
|
|
@@ -650,6 +739,10 @@ pub struct CfgJepa {
|
|
| 650 |
pub semente: u64,
|
| 651 |
/// tamanho do bloco-alvo (nº de patches por bloco).
|
| 652 |
pub tam_bloco: usize,
|
|
|
|
|
|
|
|
|
|
|
|
|
| 653 |
}
|
| 654 |
|
| 655 |
impl Default for CfgJepa {
|
|
@@ -664,10 +757,18 @@ impl Default for CfgJepa {
|
|
| 664 |
frac_mascara: 0.35,
|
| 665 |
semente: 42,
|
| 666 |
tam_bloco: 2,
|
|
|
|
|
|
|
|
|
|
| 667 |
}
|
| 668 |
}
|
| 669 |
}
|
| 670 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 671 |
/// Relatório de treino de uma variante.
|
| 672 |
#[derive(Debug, Clone)]
|
| 673 |
pub struct RelatorioJepa {
|
|
@@ -706,7 +807,7 @@ pub fn treinar_variante(
|
|
| 706 |
let mut nucleo = NucleoJepa::novo_com_semente(
|
| 707 |
d_patch,
|
| 708 |
cfg.d_emb,
|
| 709 |
-
if cond.is_some() { cond.unwrap().dim(1)? } else { 0 },
|
| 710 |
n,
|
| 711 |
cfg.m,
|
| 712 |
cfg.lambda_vc,
|
|
@@ -714,6 +815,7 @@ pub fn treinar_variante(
|
|
| 714 |
cfg.semente,
|
| 715 |
dev,
|
| 716 |
)?;
|
|
|
|
| 717 |
let otimo_vars = nucleo.vars();
|
| 718 |
let mut otimizador = crate::treino::AdamWManual::novo(otimo_vars, cfg.lr, 0.01);
|
| 719 |
|
|
@@ -875,7 +977,7 @@ pub fn treinar_variante_adaptativa(
|
|
| 875 |
let mut nucleo = NucleoJepa::novo_com_semente(
|
| 876 |
d_patch,
|
| 877 |
cfg.d_emb,
|
| 878 |
-
if cond.is_some() { cond.unwrap().dim(1)? } else { 0 },
|
| 879 |
n,
|
| 880 |
cfg.m,
|
| 881 |
cfg.lambda_vc,
|
|
@@ -883,6 +985,7 @@ pub fn treinar_variante_adaptativa(
|
|
| 883 |
cfg.semente,
|
| 884 |
dev,
|
| 885 |
)?;
|
|
|
|
| 886 |
let otimo_vars = nucleo.vars();
|
| 887 |
let mut otimizador = crate::treino::AdamWManual::novo(otimo_vars, cfg.lr, 0.01);
|
| 888 |
let z0 = nucleo.codificar(patches)?;
|
|
@@ -1061,7 +1164,7 @@ impl SonicMoe {
|
|
| 1061 |
let mut cand: Vec<(usize, f32)> = (0..n)
|
| 1062 |
.map(|i| (i, probs_v[i][ei]))
|
| 1063 |
.collect();
|
| 1064 |
-
cand.sort_by(|a, b| b.1.
|
| 1065 |
let mut escolhidos: Vec<usize> = Vec::new();
|
| 1066 |
for (i, _) in cand {
|
| 1067 |
if carga[ei] >= self.capacidade {
|
|
@@ -1070,7 +1173,7 @@ impl SonicMoe {
|
|
| 1070 |
// verifica se ei está no top-k do token i
|
| 1071 |
let mut ordem: Vec<(f32, usize)> =
|
| 1072 |
(0..e).map(|k| (probs_v[i][k], k)).collect();
|
| 1073 |
-
ordem.sort_by(|a, b| b.0.
|
| 1074 |
let top: Vec<usize> = ordem.iter().rev().take(self.n_top).map(|(_, k)| *k).collect();
|
| 1075 |
if top.contains(&ei) {
|
| 1076 |
escolhidos.push(i);
|
|
@@ -1269,6 +1372,7 @@ pub fn treinar_lejepa(
|
|
| 1269 |
let mut nucleo = NucleoJepa::novo_com_semente(
|
| 1270 |
d_patch, cfg.d_emb, d_cond, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev,
|
| 1271 |
)?;
|
|
|
|
| 1272 |
let mut otim = crate::treino::AdamWManual::novo(nucleo.vars(), cfg.lr, 0.01);
|
| 1273 |
let mut perda_inicial = f64::NAN;
|
| 1274 |
let mut perda_final = f64::NAN;
|
|
@@ -1340,6 +1444,8 @@ pub fn treinar_mcjepa(
|
|
| 1340 |
// núcleo A→B e núcleo B→A (compartilham apenas a estrutura)
|
| 1341 |
let mut nb = NucleoJepa::novo_com_semente(d_a, cfg.d_emb, 0, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev)?;
|
| 1342 |
let mut na = NucleoJepa::novo_com_semente(d_b, cfg.d_emb, 0, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev)?;
|
|
|
|
|
|
|
| 1343 |
let mut otim = crate::treino::AdamWManual::novo(
|
| 1344 |
[nb.vars(), na.vars()].concat(),
|
| 1345 |
cfg.lr,
|
|
@@ -1415,10 +1521,12 @@ pub fn treinar_bjepa(patches: &Tensor, cfg: &CfgJepa, dev: &Device) -> Result<Re
|
|
| 1415 |
let mut nucleo = NucleoJepa::novo_com_semente(
|
| 1416 |
d_patch, cfg.d_emb, 0, 2, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev,
|
| 1417 |
)?;
|
|
|
|
| 1418 |
// preditor anti-causal: núcleo separado
|
| 1419 |
let mut ninv = NucleoJepa::novo_com_semente(
|
| 1420 |
d_patch, cfg.d_emb, 0, 2, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev,
|
| 1421 |
)?;
|
|
|
|
| 1422 |
let mut otim =
|
| 1423 |
crate::treino::AdamWManual::novo([nucleo.vars(), ninv.vars()].concat(), cfg.lr, 0.01);
|
| 1424 |
let mut perda_inicial = f64::NAN;
|
|
@@ -1631,6 +1739,212 @@ mod testes {
|
|
| 1631 |
assert!(v > 0.9, "perda VC no colapso = {v} (deveria ser ~1)");
|
| 1632 |
}
|
| 1633 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1634 |
#[test]
|
| 1635 |
fn teste_j2_ema_ponto_fixo() {
|
| 1636 |
// encoder congelado ⇒ após muitas passadas EMA, alvo = encoder
|
|
|
|
| 103 |
}
|
| 104 |
}
|
| 105 |
|
| 106 |
+
/// Modo do termo de variância do regularizador VC (v0.10.0, crítica
|
| 107 |
+
/// DeepSeek J-1 — análise e provas completas em r-35 §1).
|
| 108 |
+
///
|
| 109 |
+
/// A crítica acerta que a prova original do J-1 é INVÁLIDA no argumento de
|
| 110 |
+
/// ponto crítico (`∂V/∂std ≠ 0` **não** implica `∇_z V ≠ 0`: a cadeia passa
|
| 111 |
+
/// pela raiz `std = √var`, não-diferenciável em `var = 0`, e `∇_z var = 0` no
|
| 112 |
+
/// colapso — o produto é `−∞·0`, indefinido). MAS o mecanismo apontado pela
|
| 113 |
+
/// crítica (a dobradiça `max(0,γ−s)²` ter kink em `s = 0`) está ERRADO: a
|
| 114 |
+
/// dobradiça é C¹ em todo `ℝ` (derivada contínua `−2(γ−s)·1[s<γ]`, com
|
| 115 |
+
/// `−2·0 = 0` em `s = γ`); o kink é da RAIZ. Consequência prática: o
|
| 116 |
+
/// `Softplus` proposto NÃO restaura a diferenciabilidade w.r.t. `z` (Teo
|
| 117 |
+
/// J-1′-iii, teste `j1d`). O teorema correto (J-1′) é que o colapso é uma
|
| 118 |
+
/// **sela sharp**: `D⁺V(u) = −(2γ/d)·Σ_j s_j(u) < 0` para toda direção
|
| 119 |
+
/// centrada `u ≠ 0`, e sempre existe direção de descida para `L` completa
|
| 120 |
+
/// (tome `u` centrada e ⊥ `∇L_pred`).
|
| 121 |
+
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
| 122 |
+
pub enum ModoVariancia {
|
| 123 |
+
/// `max(0, γ−√var)²` — comportamento v0.5.0–v0.9.0 (bit-a-bit).
|
| 124 |
+
/// Sela SHARP no colapso: escape LINEAR em `|t|` (melhor dinâmica de
|
| 125 |
+
/// fuga); gradiente w.r.t. z não existe no colapso exato (medido no
|
| 126 |
+
/// teste `j1a`) — configuracão de medida zero em f32.
|
| 127 |
+
Dobradica,
|
| 128 |
+
/// `max(0, γ−√(var+ε))²` — único modo `C^∞` em `z`. No colapso o
|
| 129 |
+
/// gradiente EXISTE e é 0 (ponto crítico), mas a sela é ESTRITA:
|
| 130 |
+
/// `V_ε` decai quadraticamente ao afastar-se (J-1′-ii). Viés
|
| 131 |
+
/// `≤ 2γ√ε·d` em relação à dobradiça (ε=1e-12 ⇒ ~1e-6·γ).
|
| 132 |
+
RaizSuavizada,
|
| 133 |
+
/// `softplus(k(γ−std))²` — proposta DeepSeek. NÃO restaura a
|
| 134 |
+
/// diferenciabilidade w.r.t. `z` (o kink é da raiz — contraexemplo
|
| 135 |
+
/// `j1d`); remove apenas a não-C² da dobradiça em `std = γ`. Opt-in
|
| 136 |
+
/// documentado p/ uso com métodos de 2ª ordem no regularizador.
|
| 137 |
+
Softplus,
|
| 138 |
+
}
|
| 139 |
+
|
| 140 |
/// Núcleo JEPA: codificador + preditor + alvo EMA + regularizador VC.
|
| 141 |
pub struct NucleoJepa {
|
| 142 |
pub encoder: MlpJepa,
|
|
|
|
| 149 |
pub m: f64,
|
| 150 |
pub lambda_vc: f64,
|
| 151 |
pub gamma_vc: f64,
|
| 152 |
+
/// v0.10.0 — modo do termo de variância (crítica DeepSeek J-1).
|
| 153 |
+
pub modo_var: ModoVariancia,
|
| 154 |
+
/// ε do modo `RaizSuavizada`.
|
| 155 |
+
pub eps_raiz: f64,
|
| 156 |
+
/// k do modo `Softplus`.
|
| 157 |
+
pub k_softplus: f64,
|
| 158 |
}
|
| 159 |
|
| 160 |
impl NucleoJepa {
|
|
|
|
| 210 |
m,
|
| 211 |
lambda_vc,
|
| 212 |
gamma_vc,
|
| 213 |
+
modo_var: ModoVariancia::Dobradica,
|
| 214 |
+
eps_raiz: 1e-12,
|
| 215 |
+
k_softplus: 5.0,
|
| 216 |
})
|
| 217 |
}
|
| 218 |
|
| 219 |
+
/// v0.10.0 — define o modo do termo de variância (J-1′). Aditivo: o
|
| 220 |
+
/// default `Dobradica` preserva o comportamento bit-a-bit das
|
| 221 |
+
/// versões anteriores (SOTA VICReg canônico — Bardes et al. 2022).
|
| 222 |
+
pub fn definir_modo_variancia(&mut self, modo: ModoVariancia, eps_raiz: f64, k_softplus: f64) {
|
| 223 |
+
self.modo_var = modo;
|
| 224 |
+
self.eps_raiz = eps_raiz.max(0.0);
|
| 225 |
+
self.k_softplus = k_softplus.max(1e-3);
|
| 226 |
+
}
|
| 227 |
+
|
| 228 |
pub fn vars(&self) -> Vec<Var> {
|
| 229 |
let mut v = self.encoder.vars();
|
| 230 |
v.extend(self.preditor.vars());
|
|
|
|
| 271 |
|
| 272 |
/// Regularizador variância-covariância do lote de incorporações z (n, d).
|
| 273 |
///
|
| 274 |
+
/// **J-1′ (v0.10.0):** no colapso total `z_i = c ∀i` ⇒ `std_j = 0` ⇒
|
| 275 |
+
/// `V = γ²` (Dobradica). O colapso é uma SELA SHARP, não um ponto de
|
| 276 |
+
/// mínimo: `D⁺V(u) = −(2γ/d)·Σ_j s_j(u) < 0` para toda direção centrada
|
| 277 |
+
/// `u ≠ 0` — prova em r-35 §1.2. A crítica DeepSeek ao argumento de ponto
|
| 278 |
+
/// crítico da v0.5.0 é PROCEDENTE (cadeia inválida pela raiz); a correção
|
| 279 |
+
/// proposta (softplus) é REFUTADA (j1d) — o kink é da raiz, não da
|
| 280 |
+
/// dobradiça. Modos alternativos: `RaizSuavizada` (único C^∞ em z, sela
|
| 281 |
+
/// estrita com escape quadrático) e `Softplus` (opt-in, ver enum).
|
| 282 |
pub fn perda_vc(&self, z: &Tensor) -> Result<Tensor> {
|
| 283 |
let n = z.dim(0)? as f64;
|
| 284 |
let d = self.d_emb;
|
| 285 |
let media = z.mean_keepdim(0)?; // (1, d)
|
| 286 |
let centr = z.broadcast_sub(&media)?;
|
| 287 |
let var = (centr.sqr()?.sum(0)? / n)?; // (d,)
|
| 288 |
+
// std por modo (J-1′): o kink está na RAIZ, não na dobradiça
|
| 289 |
+
let std = match self.modo_var {
|
| 290 |
+
ModoVariancia::RaizSuavizada => {
|
| 291 |
+
let eps_t = Tensor::new(self.eps_raiz as f32, z.device())?
|
| 292 |
+
.broadcast_as(var.dims())?;
|
| 293 |
+
(&var + &eps_t)?.sqrt()?
|
| 294 |
+
}
|
| 295 |
+
ModoVariancia::Dobradica | ModoVariancia::Softplus => var.sqrt()?,
|
| 296 |
+
};
|
| 297 |
let gamma_t =
|
| 298 |
Tensor::new(self.gamma_vc as f32, z.device())?.broadcast_as(std.dims())?;
|
| 299 |
+
let gap: Tensor = match self.modo_var {
|
| 300 |
+
ModoVariancia::Dobradica | ModoVariancia::RaizSuavizada => {
|
| 301 |
+
// dobradiça: max(0, γ − std) — C¹ em std (derivada 0 em std=γ)
|
| 302 |
+
(gamma_t.broadcast_sub(&std)?).clamp(0.0, f64::INFINITY)?
|
| 303 |
+
}
|
| 304 |
+
ModoVariancia::Softplus => {
|
| 305 |
+
// sp(k(γ−std)) = log(1+e^{k(γ−std)}) — forma direta é estável
|
| 306 |
+
// no domínio |k(γ−std)| ≤ k·max(γ,std) (f32 satura e^x em
|
| 307 |
+
// x>88; k·γ ≤ 50 por construção do setter)
|
| 308 |
+
let x = (gamma_t.broadcast_sub(&std)?.affine(self.k_softplus, 0.0))?
|
| 309 |
+
.exp()?;
|
| 310 |
+
(&x + 1.0)?.log()?
|
| 311 |
+
}
|
| 312 |
+
};
|
| 313 |
let v = gap.sqr()?.sum_all()?;
|
| 314 |
+
// covariância fora-diagonal: C = centrᵀ·centr/n; perda = ‖offdiag(C)‖²_F/(2d)
|
| 315 |
+
//
|
| 316 |
+
// **BUG v100-1 (corrigido na v0.10.0)**: até a v0.9.0 a máscara
|
| 317 |
+
// tinha 1s NA diagonal — o termo computava `Σ_j var_j²/(2d)`
|
| 318 |
+
// (quadrado das VARIÂNCIAS) em vez do fora-diagonal documentado e
|
| 319 |
+
// provado (r-20 §0, Corolário J-1.1 sobre rank(Cov) < d). O
|
| 320 |
+
// contraexemplo foi exposto pelo teste de compatibilidade j1e
|
| 321 |
+
// (falsificação pedida pela crítica DeepSeek) — o gate agora valida
|
| 322 |
+
// contra a referência CORRETA. Efeito da correção: o termo passa a
|
| 323 |
+
// DESCORRELACIONAR dimensões (sua função provada); a dobradiça
|
| 324 |
+
// continua responsável pelo anti-colapso (J-1′).
|
| 325 |
let cov = (centr.transpose(0, 1)?.matmul(¢r)? / n)?; // (d, d)
|
| 326 |
+
let mask_fora = {
|
| 327 |
+
let mut m = vec![1f32; d * d];
|
| 328 |
for i in 0..d {
|
| 329 |
+
m[i * d + i] = 0.0;
|
| 330 |
}
|
| 331 |
Tensor::from_vec(m, (d, d), z.device())?
|
| 332 |
};
|
| 333 |
+
let fora = ((&cov * &mask_fora)?.sqr()?.sum_all()? / (2.0 * d.max(1) as f64))?;
|
| 334 |
let v_norm = (v / d.max(1) as f64)?;
|
| 335 |
Ok((v_norm + fora)?)
|
| 336 |
}
|
|
|
|
| 529 |
.iter()
|
| 530 |
.enumerate()
|
| 531 |
.filter(|(i, _)| !centros.contains(i))
|
| 532 |
+
.max_by(|a, b| a.1.total_cmp(b.1))
|
| 533 |
.map(|(i, _)| i)
|
| 534 |
.unwrap_or(0);
|
| 535 |
centros.push(prox);
|
|
|
|
| 677 |
ord.sort_by(|&a, &b| {
|
| 678 |
let da = distancia_eucl(&coords_f[a], &coords_f[ci]);
|
| 679 |
let db = distancia_eucl(&coords_f[b], &coords_f[ci]);
|
| 680 |
+
da.total_cmp(&db)
|
| 681 |
});
|
| 682 |
let mut buf: Vec<f32> = Vec::with_capacity(m * d);
|
| 683 |
for &idx in ord.iter().take(m) {
|
|
|
|
| 739 |
pub semente: u64,
|
| 740 |
/// tamanho do bloco-alvo (nº de patches por bloco).
|
| 741 |
pub tam_bloco: usize,
|
| 742 |
+
/// v0.10.0 (J-1′, crítica DeepSeek): modo do termo de variância.
|
| 743 |
+
pub modo_variancia: ModoVariancia,
|
| 744 |
+
pub eps_raiz: f64,
|
| 745 |
+
pub k_softplus: f64,
|
| 746 |
}
|
| 747 |
|
| 748 |
impl Default for CfgJepa {
|
|
|
|
| 757 |
frac_mascara: 0.35,
|
| 758 |
semente: 42,
|
| 759 |
tam_bloco: 2,
|
| 760 |
+
modo_variancia: ModoVariancia::Dobradica,
|
| 761 |
+
eps_raiz: 1e-12,
|
| 762 |
+
k_softplus: 5.0,
|
| 763 |
}
|
| 764 |
}
|
| 765 |
}
|
| 766 |
|
| 767 |
+
/// Aplica o modo de variância da cfg a um núcleo recém-construído (v0.10.0).
|
| 768 |
+
pub fn aplicar_modo_variancia(nucleo: &mut NucleoJepa, cfg: &CfgJepa) {
|
| 769 |
+
nucleo.definir_modo_variancia(cfg.modo_variancia, cfg.eps_raiz, cfg.k_softplus);
|
| 770 |
+
}
|
| 771 |
+
|
| 772 |
/// Relatório de treino de uma variante.
|
| 773 |
#[derive(Debug, Clone)]
|
| 774 |
pub struct RelatorioJepa {
|
|
|
|
| 807 |
let mut nucleo = NucleoJepa::novo_com_semente(
|
| 808 |
d_patch,
|
| 809 |
cfg.d_emb,
|
| 810 |
+
if cond.is_some() { cond.as_ref().unwrap().dim(1)? } else { 0 },
|
| 811 |
n,
|
| 812 |
cfg.m,
|
| 813 |
cfg.lambda_vc,
|
|
|
|
| 815 |
cfg.semente,
|
| 816 |
dev,
|
| 817 |
)?;
|
| 818 |
+
aplicar_modo_variancia(&mut nucleo, &cfg);
|
| 819 |
let otimo_vars = nucleo.vars();
|
| 820 |
let mut otimizador = crate::treino::AdamWManual::novo(otimo_vars, cfg.lr, 0.01);
|
| 821 |
|
|
|
|
| 977 |
let mut nucleo = NucleoJepa::novo_com_semente(
|
| 978 |
d_patch,
|
| 979 |
cfg.d_emb,
|
| 980 |
+
if cond.is_some() { cond.as_ref().unwrap().dim(1)? } else { 0 },
|
| 981 |
n,
|
| 982 |
cfg.m,
|
| 983 |
cfg.lambda_vc,
|
|
|
|
| 985 |
cfg.semente,
|
| 986 |
dev,
|
| 987 |
)?;
|
| 988 |
+
aplicar_modo_variancia(&mut nucleo, &cfg);
|
| 989 |
let otimo_vars = nucleo.vars();
|
| 990 |
let mut otimizador = crate::treino::AdamWManual::novo(otimo_vars, cfg.lr, 0.01);
|
| 991 |
let z0 = nucleo.codificar(patches)?;
|
|
|
|
| 1164 |
let mut cand: Vec<(usize, f32)> = (0..n)
|
| 1165 |
.map(|i| (i, probs_v[i][ei]))
|
| 1166 |
.collect();
|
| 1167 |
+
cand.sort_by(|a, b| b.1.total_cmp(&a.1));
|
| 1168 |
let mut escolhidos: Vec<usize> = Vec::new();
|
| 1169 |
for (i, _) in cand {
|
| 1170 |
if carga[ei] >= self.capacidade {
|
|
|
|
| 1173 |
// verifica se ei está no top-k do token i
|
| 1174 |
let mut ordem: Vec<(f32, usize)> =
|
| 1175 |
(0..e).map(|k| (probs_v[i][k], k)).collect();
|
| 1176 |
+
ordem.sort_by(|a, b| b.0.total_cmp(&a.0));
|
| 1177 |
let top: Vec<usize> = ordem.iter().rev().take(self.n_top).map(|(_, k)| *k).collect();
|
| 1178 |
if top.contains(&ei) {
|
| 1179 |
escolhidos.push(i);
|
|
|
|
| 1372 |
let mut nucleo = NucleoJepa::novo_com_semente(
|
| 1373 |
d_patch, cfg.d_emb, d_cond, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev,
|
| 1374 |
)?;
|
| 1375 |
+
aplicar_modo_variancia(&mut nucleo, &cfg);
|
| 1376 |
let mut otim = crate::treino::AdamWManual::novo(nucleo.vars(), cfg.lr, 0.01);
|
| 1377 |
let mut perda_inicial = f64::NAN;
|
| 1378 |
let mut perda_final = f64::NAN;
|
|
|
|
| 1444 |
// núcleo A→B e núcleo B→A (compartilham apenas a estrutura)
|
| 1445 |
let mut nb = NucleoJepa::novo_com_semente(d_a, cfg.d_emb, 0, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev)?;
|
| 1446 |
let mut na = NucleoJepa::novo_com_semente(d_b, cfg.d_emb, 0, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev)?;
|
| 1447 |
+
aplicar_modo_variancia(&mut nb, &cfg);
|
| 1448 |
+
aplicar_modo_variancia(&mut na, &cfg);
|
| 1449 |
let mut otim = crate::treino::AdamWManual::novo(
|
| 1450 |
[nb.vars(), na.vars()].concat(),
|
| 1451 |
cfg.lr,
|
|
|
|
| 1521 |
let mut nucleo = NucleoJepa::novo_com_semente(
|
| 1522 |
d_patch, cfg.d_emb, 0, 2, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev,
|
| 1523 |
)?;
|
| 1524 |
+
aplicar_modo_variancia(&mut nucleo, &cfg);
|
| 1525 |
// preditor anti-causal: núcleo separado
|
| 1526 |
let mut ninv = NucleoJepa::novo_com_semente(
|
| 1527 |
d_patch, cfg.d_emb, 0, 2, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev,
|
| 1528 |
)?;
|
| 1529 |
+
aplicar_modo_variancia(&mut nucleo, &cfg);
|
| 1530 |
let mut otim =
|
| 1531 |
crate::treino::AdamWManual::novo([nucleo.vars(), ninv.vars()].concat(), cfg.lr, 0.01);
|
| 1532 |
let mut perda_inicial = f64::NAN;
|
|
|
|
| 1739 |
assert!(v > 0.9, "perda VC no colapso = {v} (deveria ser ~1)");
|
| 1740 |
}
|
| 1741 |
|
| 1742 |
+
// -----------------------------------------------------------------
|
| 1743 |
+
// v0.10.0 — J-1′ (crítica DeepSeek): o colapso é SELA SHARP, não
|
| 1744 |
+
// ponto crítico; o kink é da RAIZ (não da dobradiça); softplus NÃO
|
| 1745 |
+
// restaura diferenciabilidade w.r.t. z. Provas em r-35 §1.
|
| 1746 |
+
// -----------------------------------------------------------------
|
| 1747 |
+
|
| 1748 |
+
/// Lote de colapso + direção centrada u (col 0: metade +1 metade −1;
|
| 1749 |
+
/// col 1: alternado ±1) — ambas as colunas com s_j = 1, média 0.
|
| 1750 |
+
fn lote_e_direcao_j1(n: usize, d: usize) -> (Vec<f32>, Vec<f32>) {
|
| 1751 |
+
let mut z = vec![0.5f32; n * d];
|
| 1752 |
+
let mut u = vec![0f32; n * d];
|
| 1753 |
+
for i in 0..n {
|
| 1754 |
+
for j in 0..d {
|
| 1755 |
+
let s0 = if i < n / 2 { 1.0 } else { -1.0 };
|
| 1756 |
+
let s1 = if i % 2 == 0 { 1.0 } else { -1.0 };
|
| 1757 |
+
let s = if j == 0 { s0 } else { s1 };
|
| 1758 |
+
u[i * d + j] = s;
|
| 1759 |
+
}
|
| 1760 |
+
}
|
| 1761 |
+
z.shrink_to_fit();
|
| 1762 |
+
(z, u)
|
| 1763 |
+
}
|
| 1764 |
+
|
| 1765 |
+
#[test]
|
| 1766 |
+
fn teste_j1a_dobradica_gradiente_indefinido_no_colapso() {
|
| 1767 |
+
// Falsificação da prova v0.5.0 (r-20 §1): no colapso exato, a
|
| 1768 |
+
// retropropagação da Dobradica através de std = √var produz
|
| 1769 |
+
// gradiente NÃO-finito w.r.t. z (o produto da cadeia é −∞·0).
|
| 1770 |
+
// "∂V/∂std = −2γ ≠ 0" NÃO implica "∇_z V ≠ 0" — a crítica
|
| 1771 |
+
// DeepSeek procede neste ponto. (Forward permanece correto: γ².)
|
| 1772 |
+
let dev = Device::Cpu;
|
| 1773 |
+
let nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap();
|
| 1774 |
+
let (z, _) = lote_e_direcao_j1(8, 8);
|
| 1775 |
+
let zt = Tensor::from_vec(z, (8, 8), &dev).unwrap();
|
| 1776 |
+
let zv = Var::from_tensor(&zt).unwrap();
|
| 1777 |
+
let l = nucleo.perda_vc(&zv.as_tensor()).unwrap();
|
| 1778 |
+
let v = l.to_scalar::<f32>().unwrap() as f64;
|
| 1779 |
+
assert!((v - 1.0).abs() < 1e-6, "forward no colapso = {v} (esperado γ²=1)");
|
| 1780 |
+
let grads = l.backward().unwrap();
|
| 1781 |
+
let g = grads.get(&zv).unwrap().flatten_all().unwrap().to_vec1::<f32>().unwrap();
|
| 1782 |
+
let n_nao_finitos = g.iter().filter(|x| !x.is_finite()).count();
|
| 1783 |
+
// registra o comportamento REAL do autograd no colapso exato
|
| 1784 |
+
println!("j1a: não-finitos no gradiente z = {n_nao_finitos}/{}", g.len());
|
| 1785 |
+
assert!(
|
| 1786 |
+
g.iter().any(|x| !x.is_finite()),
|
| 1787 |
+
"esperado gradiente não-finito no colapso exato (kink da raiz); \
|
| 1788 |
+
se isto falhar, o autograd do candle short-circuitou o kink — \
|
| 1789 |
+
atualizar r-35 §1.4 com a medição nova"
|
| 1790 |
+
);
|
| 1791 |
+
}
|
| 1792 |
+
|
| 1793 |
+
#[test]
|
| 1794 |
+
fn teste_j1b_sela_sharp_descida_linear() {
|
| 1795 |
+
// J-1′-ii: D⁺V(u) = −(2γ/d)·Σ_j s_j(u) — descida LINEAR em |t|.
|
| 1796 |
+
// n=8, d=8, u com s_j = 1 ∀j ⇒ Σs_j = 8 ⇒ C = (2·1/8)·8 = 2.
|
| 1797 |
+
let dev = Device::Cpu;
|
| 1798 |
+
let nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap();
|
| 1799 |
+
let (z, u) = lote_e_direcao_j1(8, 8);
|
| 1800 |
+
let v_de = |t: f64| -> f64 {
|
| 1801 |
+
let dados: Vec<f32> = z
|
| 1802 |
+
.iter()
|
| 1803 |
+
.zip(&u)
|
| 1804 |
+
.map(|(&zi, &ui)| zi + (t * ui as f64) as f32)
|
| 1805 |
+
.collect();
|
| 1806 |
+
let zt = Tensor::from_vec(dados, (8, 8), &dev).unwrap();
|
| 1807 |
+
nucleo.perda_vc(&zt).unwrap().to_scalar::<f32>().unwrap() as f64
|
| 1808 |
+
};
|
| 1809 |
+
let v0 = v_de(0.0);
|
| 1810 |
+
let c_teorico = 2.0 * 1.0 / 8.0 * 8.0; // (2γ/d)·Σs_j = 2
|
| 1811 |
+
let t = 0.01;
|
| 1812 |
+
let slope = (v_de(t) - v0) / t;
|
| 1813 |
+
assert!(
|
| 1814 |
+
(slope + c_teorico).abs() < 0.05 * c_teorico,
|
| 1815 |
+
"slope linear medido {slope} vs teórico −{c_teorico}"
|
| 1816 |
+
);
|
| 1817 |
+
// afastar-se do colapso REDUZ V (sela, não mínimo)
|
| 1818 |
+
assert!(v_de(0.1) < v0, "V deve cair ao afastar do colapso (sela sharp)");
|
| 1819 |
+
}
|
| 1820 |
+
|
| 1821 |
+
#[test]
|
| 1822 |
+
fn teste_j1c_raiz_suavizada_critico_mas_sela_estrita() {
|
| 1823 |
+
// J-1′-ii(ε): com std = √(var+ε), o gradiente no colapso EXISTE,
|
| 1824 |
+
// é finito e IGUAL A ZERO (ponto crítico) — mas V_ε cai ao
|
| 1825 |
+
// afastar-se (SELA ESTRITA, escape quadrático). O modo troca a
|
| 1826 |
+
// natureza do ponto sem criar mínimo espúrio.
|
| 1827 |
+
let dev = Device::Cpu;
|
| 1828 |
+
let mut nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap();
|
| 1829 |
+
nucleo.definir_modo_variancia(ModoVariancia::RaizSuavizada, 1e-6, 5.0);
|
| 1830 |
+
let (z, u) = lote_e_direcao_j1(8, 8);
|
| 1831 |
+
let zt = Tensor::from_vec(z.clone(), (8, 8), &dev).unwrap();
|
| 1832 |
+
let zv = Var::from_tensor(&zt).unwrap();
|
| 1833 |
+
let l = nucleo.perda_vc(&zv.as_tensor()).unwrap();
|
| 1834 |
+
let grads = l.backward().unwrap();
|
| 1835 |
+
let g = grads.get(&zv).unwrap().flatten_all().unwrap().to_vec1::<f32>().unwrap();
|
| 1836 |
+
assert!(
|
| 1837 |
+
g.iter().all(|x| x.is_finite()),
|
| 1838 |
+
"RaizSuavizada: gradiente deve ser finito no colapso"
|
| 1839 |
+
);
|
| 1840 |
+
let mx = g.iter().fold(0f32, |a, &b| a.max(b.abs()));
|
| 1841 |
+
assert!(mx < 1e-9, "gradiente no colapso = 0 exato (sela), máx = {mx}");
|
| 1842 |
+
// sela estrita: afastar reduz V
|
| 1843 |
+
let v_de = |t: f64| -> f64 {
|
| 1844 |
+
let dados: Vec<f32> = z
|
| 1845 |
+
.iter()
|
| 1846 |
+
.zip(&u)
|
| 1847 |
+
.map(|(&zi, &ui)| zi + (t * ui as f64) as f32)
|
| 1848 |
+
.collect();
|
| 1849 |
+
let ztt = Tensor::from_vec(dados, (8, 8), &dev).unwrap();
|
| 1850 |
+
nucleo.perda_vc(&ztt).unwrap().to_scalar::<f32>().unwrap() as f64
|
| 1851 |
+
};
|
| 1852 |
+
assert!(
|
| 1853 |
+
v_de(0.1) < v_de(0.0),
|
| 1854 |
+
"RaizSuavizada: V_ε deve cair ao afastar (sela estrita, não mínimo)"
|
| 1855 |
+
);
|
| 1856 |
+
}
|
| 1857 |
+
|
| 1858 |
+
#[test]
|
| 1859 |
+
fn teste_j1d_softplus_nao_diferenciavel_em_z() {
|
| 1860 |
+
// J-1′-iii (REFUTAÇÃO da correção proposta pela crítica): o
|
| 1861 |
+
// softplus suaviza a dobradiça (que já era C¹) mas NÃO a raiz.
|
| 1862 |
+
// As derivadas laterais de V w.r.t. z no colapso diferem por
|
| 1863 |
+
// sinal ⇒ gradiente NÃO existe — a proposta não cumpre o que
|
| 1864 |
+
// afirma ("garante diferenciabilidade em todo o domínio").
|
| 1865 |
+
let dev = Device::Cpu;
|
| 1866 |
+
let mut nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap();
|
| 1867 |
+
nucleo.definir_modo_variancia(ModoVariancia::Softplus, 1e-12, 5.0);
|
| 1868 |
+
let (z, u) = lote_e_direcao_j1(8, 8);
|
| 1869 |
+
let v_de = |t: f64| -> f64 {
|
| 1870 |
+
let dados: Vec<f32> = z
|
| 1871 |
+
.iter()
|
| 1872 |
+
.zip(&u)
|
| 1873 |
+
.map(|(&zi, &ui)| zi + (t * ui as f64) as f32)
|
| 1874 |
+
.collect();
|
| 1875 |
+
let zt = Tensor::from_vec(dados, (8, 8), &dev).unwrap();
|
| 1876 |
+
nucleo.perda_vc(&zt).unwrap().to_scalar::<f32>().unwrap() as f64
|
| 1877 |
+
};
|
| 1878 |
+
let t = 0.001;
|
| 1879 |
+
// D⁺ = lim [V(t)−V(0)]/t ; D⁻ = lim [V(−t)−V(0)]/(−t)
|
| 1880 |
+
let d_mais = (v_de(t) - v_de(0.0)) / t;
|
| 1881 |
+
let d_menos = (v_de(-t) - v_de(0.0)) / (-t);
|
| 1882 |
+
// constante teórica: C_sp = (2k·sp(kγ)·σ(kγ)/d)·Σs_j, γ=1, k=5, d=8, Σs=8
|
| 1883 |
+
let (k, g, d, ss) = (5.0f64, 1.0f64, 8.0f64, 8.0f64);
|
| 1884 |
+
let sp = |x: f64| (1.0 + x.exp()).ln();
|
| 1885 |
+
let sg = 1.0 / (1.0 + (-k * g).exp());
|
| 1886 |
+
let c_sp = 2.0 * k * sp(k * g) * sg / d * ss;
|
| 1887 |
+
assert!(
|
| 1888 |
+
d_mais < -0.5 * c_sp && d_menos > 0.5 * c_sp,
|
| 1889 |
+
"derivadas laterais devem divergir por sinal: D⁺={d_mais:.4}, \
|
| 1890 |
+
D⁻={d_menos:.4}, C_sp teórico={c_sp:.4} — softplus NÃO é \
|
| 1891 |
+
diferenciável em z no colapso"
|
| 1892 |
+
);
|
| 1893 |
+
}
|
| 1894 |
+
|
| 1895 |
+
#[test]
|
| 1896 |
+
fn teste_j1e_compat_bit_a_bit_dobradica() {
|
| 1897 |
+
// O default preserva o comportamento das versões anteriores: a
|
| 1898 |
+
// Dobradica explícita produz o MESMO valor bit-a-bit que o caminho
|
| 1899 |
+
// v0.9.0 (fórmula de referência recalculada aqui).
|
| 1900 |
+
let dev = Device::Cpu;
|
| 1901 |
+
let mut nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap();
|
| 1902 |
+
let mut rng = crate::rng::RngDeterministico::novo(77);
|
| 1903 |
+
let dados: Vec<f32> = (0..8 * 8).map(|_| rng.normal(0.0, 1.0) as f32).collect();
|
| 1904 |
+
let z = Tensor::from_vec(dados.clone(), (8, 8), &dev).unwrap();
|
| 1905 |
+
nucleo.definir_modo_variancia(ModoVariancia::Dobradica, 1e-12, 5.0);
|
| 1906 |
+
let bits = nucleo
|
| 1907 |
+
.perda_vc(&z)
|
| 1908 |
+
.unwrap()
|
| 1909 |
+
.to_scalar::<f32>()
|
| 1910 |
+
.unwrap()
|
| 1911 |
+
.to_bits();
|
| 1912 |
+
// referência v0.9.0 recalculada de forma independente (f64):
|
| 1913 |
+
// V = (1/d)Σ_j max(0,γ−std_j)² + ‖offdiag(Cov)‖²_F/(2d)
|
| 1914 |
+
let gamma = 1.0f64;
|
| 1915 |
+
let mut v_var = 0.0f64;
|
| 1916 |
+
for j in 0..8 {
|
| 1917 |
+
let media: f64 = (0..8).map(|i| dados[i * 8 + j] as f64).sum::<f64>() / 8.0;
|
| 1918 |
+
let var: f64 = (0..8)
|
| 1919 |
+
.map(|i| (dados[i * 8 + j] as f64 - media).powi(2))
|
| 1920 |
+
.sum::<f64>()
|
| 1921 |
+
/ 8.0;
|
| 1922 |
+
v_var += (gamma - var.sqrt()).max(0.0).powi(2);
|
| 1923 |
+
}
|
| 1924 |
+
v_var /= 8.0;
|
| 1925 |
+
let mut v_cov = 0.0f64;
|
| 1926 |
+
for a in 0..8 {
|
| 1927 |
+
for b in 0..8 {
|
| 1928 |
+
if a != b {
|
| 1929 |
+
let ma: f64 = (0..8).map(|i| dados[i * 8 + a] as f64).sum::<f64>() / 8.0;
|
| 1930 |
+
let mb: f64 = (0..8).map(|i| dados[i * 8 + b] as f64).sum::<f64>() / 8.0;
|
| 1931 |
+
let cab: f64 = (0..8)
|
| 1932 |
+
.map(|i| (dados[i * 8 + a] as f64 - ma) * (dados[i * 8 + b] as f64 - mb))
|
| 1933 |
+
.sum::<f64>()
|
| 1934 |
+
/ 8.0;
|
| 1935 |
+
v_cov += cab * cab;
|
| 1936 |
+
}
|
| 1937 |
+
}
|
| 1938 |
+
}
|
| 1939 |
+
v_cov /= 2.0 * 8.0;
|
| 1940 |
+
let v_ref = v_var + v_cov;
|
| 1941 |
+
let obtido = f32::from_bits(bits) as f64;
|
| 1942 |
+
assert!(
|
| 1943 |
+
(obtido - v_ref).abs() < 1e-5,
|
| 1944 |
+
"Dobradica deve reproduzir a fórmula v0.9.0: {obtido} vs {v_ref}"
|
| 1945 |
+
);
|
| 1946 |
+
}
|
| 1947 |
+
|
| 1948 |
#[test]
|
| 1949 |
fn teste_j2_ema_ponto_fixo() {
|
| 1950 |
// encoder congelado ⇒ após muitas passadas EMA, alvo = encoder
|
src/jepa/mascaras.rs
DELETED
|
@@ -1,173 +0,0 @@
|
|
| 1 |
-
//! `jepa::mascaras` — extraído do monólito na v0.10.0
|
| 2 |
-
//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
|
| 3 |
-
|
| 4 |
-
use super::*;
|
| 5 |
-
|
| 6 |
-
|
| 7 |
-
// ---------------------------------------------------------------------------
|
| 8 |
-
// Parte 2 — máscaras
|
| 9 |
-
// ---------------------------------------------------------------------------
|
| 10 |
-
|
| 11 |
-
/// Máscara de blocos 2D (Image-JEPA): grade (h, w) de patches; sorteia
|
| 12 |
-
/// `n_blocos` retângulos aleatórios com fração alvo `frac` de patches.
|
| 13 |
-
pub fn mascara_blocos_2d(h: usize, w: usize, n_blocos: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
|
| 14 |
-
let total = h * w;
|
| 15 |
-
let alvo = (total as f64 * frac) as usize;
|
| 16 |
-
let mut masc = vec![false; total];
|
| 17 |
-
let mut coberto = 0usize;
|
| 18 |
-
for _ in 0..n_blocos.max(1) {
|
| 19 |
-
if coberto >= alvo {
|
| 20 |
-
break;
|
| 21 |
-
}
|
| 22 |
-
let bh = 1 + rng.inteiro(h.min(4));
|
| 23 |
-
let bw = 1 + rng.inteiro(w.min(4));
|
| 24 |
-
let y0 = rng.inteiro(h + 1 - bh);
|
| 25 |
-
let x0 = rng.inteiro(w + 1 - bw);
|
| 26 |
-
for y in y0..y0 + bh {
|
| 27 |
-
for x in x0..x0 + bw {
|
| 28 |
-
let i = y * w + x;
|
| 29 |
-
if !masc[i] {
|
| 30 |
-
masc[i] = true;
|
| 31 |
-
coberto += 1;
|
| 32 |
-
}
|
| 33 |
-
}
|
| 34 |
-
}
|
| 35 |
-
}
|
| 36 |
-
masc
|
| 37 |
-
}
|
| 38 |
-
|
| 39 |
-
/// Máscara de tubos 3D (V-JEPA 2): grade (t, h, w); tubos = retângulos que
|
| 40 |
-
/// atravessam o tempo.
|
| 41 |
-
pub fn mascara_tubos_3d(t: usize, h: usize, w: usize, n_tubos: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
|
| 42 |
-
let total = t * h * w;
|
| 43 |
-
let alvo = (total as f64 * frac) as usize;
|
| 44 |
-
let mut masc = vec![false; total];
|
| 45 |
-
let mut coberto = 0usize;
|
| 46 |
-
for _ in 0..n_tubos.max(1) {
|
| 47 |
-
if coberto >= alvo {
|
| 48 |
-
break;
|
| 49 |
-
}
|
| 50 |
-
let bh = 1 + rng.inteiro(h.min(3));
|
| 51 |
-
let bw = 1 + rng.inteiro(w.min(3));
|
| 52 |
-
let y0 = rng.inteiro(h + 1 - bh);
|
| 53 |
-
let x0 = rng.inteiro(w + 1 - bw);
|
| 54 |
-
for tt in 0..t {
|
| 55 |
-
for y in y0..y0 + bh {
|
| 56 |
-
for x in x0..x0 + bw {
|
| 57 |
-
let i = (tt * h + y) * w + x;
|
| 58 |
-
if !masc[i] {
|
| 59 |
-
masc[i] = true;
|
| 60 |
-
coberto += 1;
|
| 61 |
-
}
|
| 62 |
-
}
|
| 63 |
-
}
|
| 64 |
-
}
|
| 65 |
-
}
|
| 66 |
-
masc
|
| 67 |
-
}
|
| 68 |
-
|
| 69 |
-
/// Máscara de bandas (Audio-JEPA): grade (f, tau) — bandas de frequência
|
| 70 |
-
/// horizontais com extensão temporal.
|
| 71 |
-
pub fn mascara_bandas(f: usize, tau: usize, n_bandas: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
|
| 72 |
-
mascara_blocos_2d(f, tau, n_bandas, frac, rng) // blocos na grade (f, tau)
|
| 73 |
-
}
|
| 74 |
-
|
| 75 |
-
/// Máscara de blocos 3D (3D-JEPA): grade (x, y, z) de voxels.
|
| 76 |
-
pub fn mascara_blocos_3d(x: usize, y: usize, z: usize, n_blocos: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
|
| 77 |
-
mascara_tubos_3d(x, y, z, n_blocos, frac, rng)
|
| 78 |
-
}
|
| 79 |
-
|
| 80 |
-
/// Máscara de segmentos canal×tempo (Brain-JEPA): canais inteiros OU
|
| 81 |
-
/// janelas temporais (aleatório por chamada).
|
| 82 |
-
pub fn mascara_segmentos(c: usize, t: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
|
| 83 |
-
let total = c * t;
|
| 84 |
-
let alvo = (total as f64 * frac) as usize;
|
| 85 |
-
let mut masc = vec![false; total];
|
| 86 |
-
if rng.inteiro(2) == 0 {
|
| 87 |
-
// canais inteiros
|
| 88 |
-
let mut coberto = 0;
|
| 89 |
-
let mut canais: Vec<usize> = (0..c).collect();
|
| 90 |
-
// embaralhar
|
| 91 |
-
for i in (1..canais.len()).rev() {
|
| 92 |
-
let j = rng.inteiro(i + 1);
|
| 93 |
-
canais.swap(i, j);
|
| 94 |
-
}
|
| 95 |
-
for &ch in canais.iter() {
|
| 96 |
-
if coberto >= alvo {
|
| 97 |
-
break;
|
| 98 |
-
}
|
| 99 |
-
for tt in 0..t {
|
| 100 |
-
masc[ch * t + tt] = true;
|
| 101 |
-
coberto += 1;
|
| 102 |
-
}
|
| 103 |
-
}
|
| 104 |
-
} else {
|
| 105 |
-
// janelas temporais
|
| 106 |
-
let mut coberto = 0;
|
| 107 |
-
let mut t0 = 0;
|
| 108 |
-
while coberto < alvo && t0 < t {
|
| 109 |
-
let len = 1 + rng.inteiro((t / 4).max(1));
|
| 110 |
-
for ch in 0..c {
|
| 111 |
-
for tt in t0..(t0 + len).min(t) {
|
| 112 |
-
masc[ch * t + tt] = true;
|
| 113 |
-
coberto += 1;
|
| 114 |
-
}
|
| 115 |
-
}
|
| 116 |
-
t0 += len + 1;
|
| 117 |
-
}
|
| 118 |
-
}
|
| 119 |
-
masc
|
| 120 |
-
}
|
| 121 |
-
|
| 122 |
-
/// Máscara 1D (T-JEPA): intervalos contíguos em n posições.
|
| 123 |
-
pub fn mascara_intervalos_1d(n: usize, frac: f64, rng: &mut RngDeterministico) -> Vec<bool> {
|
| 124 |
-
let alvo = (n as f64 * frac) as usize;
|
| 125 |
-
let mut masc = vec![false; n];
|
| 126 |
-
let mut coberto = 0;
|
| 127 |
-
while coberto < alvo {
|
| 128 |
-
let len = 1 + rng.inteiro((n / 8).max(1));
|
| 129 |
-
let i0 = rng.inteiro(n);
|
| 130 |
-
for i in i0..(i0 + len).min(n) {
|
| 131 |
-
if !masc[i] {
|
| 132 |
-
masc[i] = true;
|
| 133 |
-
coberto += 1;
|
| 134 |
-
}
|
| 135 |
-
}
|
| 136 |
-
}
|
| 137 |
-
masc
|
| 138 |
-
}
|
| 139 |
-
|
| 140 |
-
/// Amostragem dos pontos mais distantes (FPS) para Point-JEPA.
|
| 141 |
-
pub fn pontos_mais_distantes(pontos: &[Vec<f64>], k: usize, rng: &mut RngDeterministico) -> Vec<usize> {
|
| 142 |
-
let n = pontos.len();
|
| 143 |
-
if n == 0 || k == 0 {
|
| 144 |
-
return vec![];
|
| 145 |
-
}
|
| 146 |
-
let k = k.min(n);
|
| 147 |
-
let mut centros = vec![rng.inteiro(n)];
|
| 148 |
-
let mut dist_min: Vec<f64> = pontos
|
| 149 |
-
.iter()
|
| 150 |
-
.map(|p| distancia_eucl(p, &pontos[centros[0]]))
|
| 151 |
-
.collect();
|
| 152 |
-
while centros.len() < k {
|
| 153 |
-
let prox = dist_min
|
| 154 |
-
.iter()
|
| 155 |
-
.enumerate()
|
| 156 |
-
.filter(|(i, _)| !centros.contains(i))
|
| 157 |
-
.max_by(|a, b| a.1.partial_cmp(b.1).unwrap())
|
| 158 |
-
.map(|(i, _)| i)
|
| 159 |
-
.unwrap_or(0);
|
| 160 |
-
centros.push(prox);
|
| 161 |
-
for (i, p) in pontos.iter().enumerate() {
|
| 162 |
-
let d = distancia_eucl(p, &pontos[prox]);
|
| 163 |
-
if d < dist_min[i] {
|
| 164 |
-
dist_min[i] = d;
|
| 165 |
-
}
|
| 166 |
-
}
|
| 167 |
-
}
|
| 168 |
-
centros
|
| 169 |
-
}
|
| 170 |
-
|
| 171 |
-
pub(crate) fn distancia_eucl(a: &[f64], b: &[f64]) -> f64 {
|
| 172 |
-
a.iter().zip(b).map(|(x, y)| (x - y) * (x - y)).sum::<f64>().sqrt()
|
| 173 |
-
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/jepa/mod.rs
DELETED
|
@@ -1,61 +0,0 @@
|
|
| 1 |
-
//! Suíte JEPA — módulos: núcleo, máscaras, patches, variantes,
|
| 2 |
-
//! SonicMoE, ReplaySSM (divisão SRP v0.10.0 — r-35 §2).
|
| 3 |
-
|
| 4 |
-
//! Suíte JEPA v0.5.0 — núcleo unificado + 12 variantes + SonicMoE + ReplaySSM.
|
| 5 |
-
//!
|
| 6 |
-
//! **Núcleo (todas as variantes compartilham):**
|
| 7 |
-
//! - codificador `E_θ` (MLp SiLU), preditor `P_φ` (condicionado por posição/
|
| 8 |
-
//! ação/edição), codificador-alvo EMA `E_ξ` com `ξ ← m·ξ + (1−m)·θ`
|
| 9 |
-
//! (gradiente cortado — alvo nunca recebe gradiente);
|
| 10 |
-
//! - regularizador variância-covariância (VICReg-lite) anti-colapso:
|
| 11 |
-
//! `V(z) = Σ_j max(0, γ − std(z_j))²` + fora-diagonal da covariância.
|
| 12 |
-
//! - perda: `L = Σ_b ‖P(z_ctx, pos_b) − sg(ẑ_b)‖²/B + λ_vc·V`.
|
| 13 |
-
//!
|
| 14 |
-
//! **Prova J-1 (impossibilidade de colapso, em r-20):** se todas as
|
| 15 |
-
//! incorporações colapsam para constante, `std(z_j) = 0 ∀j` ⇒ `V = d·γ² > 0`;
|
| 16 |
-
//! logo o colapso total NÃO é minimizador com `λ_vc > 0`.
|
| 17 |
-
//!
|
| 18 |
-
//! **Prova J-2 (EMA = stop-grad + ponto fixo):** `∂L/∂ξ = 0` (detach); se
|
| 19 |
-
//! `θ_t → θ*` então `ξ_t → θ*` (recursão linear contratante com `m < 1`).
|
| 20 |
-
//!
|
| 21 |
-
//! **Prova J-3 (decomposição de informação):** com `P` suficientemente
|
| 22 |
-
//! rico, `min_P L = Σ_b Var(ẑ_b | z_ctx)` — a perda retém só o componentes
|
| 23 |
-
//! previsíveis do alvo dado o contexto.
|
| 24 |
-
//!
|
| 25 |
-
//! **Variantes** (esquema de máscara + adaptador de modalidade):
|
| 26 |
-
//! Image-JEPA (blocos 2D) · V-JEPA 2 (tubos 3D + cond. de ação) · MC-JEPA
|
| 27 |
-
//! (cruz-modal, dois codificadores) · Audio-JEPA (bandas de espectrograma) ·
|
| 28 |
-
//! Point-JEPA (grupos FPS) · 3D-JEPA (voxels) · Brain-JEPA (canal×tempo) ·
|
| 29 |
-
//! T-JEPA (série temporal canal-independente) · LeJEPA (edição-condicionado) ·
|
| 30 |
-
//! BJEPA (bidirecional com consistência de ciclo).
|
| 31 |
-
//!
|
| 32 |
-
//! **SonicMoE** — MoE com roteamento top-k, capacidade por especialista
|
| 33 |
-
//! (tile-aware) e perda auxiliar de balanceamento (argumento Switch:
|
| 34 |
-
//! `L_aux = E·Σ f_e·p_e ≥ 1` com igualdade sse uniforme).
|
| 35 |
-
//!
|
| 36 |
-
//! **ReplaySSM** — SSM de porta diagonal (`h_t = σ(a)⊙h_{t−1} +
|
| 37 |
-
//! (1−σ(a))⊙(Bx_t)`, estabilidade herdada do Teo S-2') + replay de experiências
|
| 38 |
-
//! para aprendizado continuado (interpolação de gradientes limita o
|
| 39 |
-
//! esquecimento — Teo R-1).
|
| 40 |
-
|
| 41 |
-
use candle_core::{Device, Result, Tensor, Var};
|
| 42 |
-
use crate::camadas::Linear;
|
| 43 |
-
use crate::rng::RngDeterministico;
|
| 44 |
-
|
| 45 |
-
// ---- divisão SRP v0.10.0 (r-35 §2): submódulos + re-exports ----
|
| 46 |
-
#[cfg(test)]
|
| 47 |
-
mod testes;
|
| 48 |
-
mod mascaras;
|
| 49 |
-
mod nucleo;
|
| 50 |
-
mod patches;
|
| 51 |
-
mod replay_ssm;
|
| 52 |
-
mod sonic_moe;
|
| 53 |
-
mod variantes;
|
| 54 |
-
|
| 55 |
-
pub use mascaras::*;
|
| 56 |
-
pub use nucleo::*;
|
| 57 |
-
pub use patches::*;
|
| 58 |
-
pub use replay_ssm::*;
|
| 59 |
-
pub use sonic_moe::*;
|
| 60 |
-
pub use variantes::*;
|
| 61 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/jepa/nucleo.rs
DELETED
|
@@ -1,211 +0,0 @@
|
|
| 1 |
-
//! `jepa::nucleo` — extraído do monólito na v0.10.0
|
| 2 |
-
//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
|
| 3 |
-
|
| 4 |
-
use super::*;
|
| 5 |
-
|
| 6 |
-
|
| 7 |
-
// ---------------------------------------------------------------------------
|
| 8 |
-
// Parte 1 — núcleo
|
| 9 |
-
// ---------------------------------------------------------------------------
|
| 10 |
-
|
| 11 |
-
/// MLP 2 camadas com SiLU (d → h → d_saida).
|
| 12 |
-
pub struct MlpJepa {
|
| 13 |
-
pub l1: Linear,
|
| 14 |
-
pub l2: Linear,
|
| 15 |
-
pub d_entrada: usize,
|
| 16 |
-
pub d_saida: usize,
|
| 17 |
-
}
|
| 18 |
-
|
| 19 |
-
impl MlpJepa {
|
| 20 |
-
pub fn novo(d_entrada: usize, d_oculta: usize, d_saida: usize, dev: &Device) -> Result<Self> {
|
| 21 |
-
let s1 = (1.0 / (d_entrada as f64).sqrt()) * 0.9;
|
| 22 |
-
let s2 = (1.0 / (d_oculta as f64).sqrt()) * 0.9;
|
| 23 |
-
Ok(Self {
|
| 24 |
-
l1: Linear::sem_vies(d_entrada, d_oculta, s1, dev)?,
|
| 25 |
-
l2: Linear::sem_vies(d_oculta, d_saida, s2, dev)?,
|
| 26 |
-
d_entrada,
|
| 27 |
-
d_saida,
|
| 28 |
-
})
|
| 29 |
-
}
|
| 30 |
-
|
| 31 |
-
pub fn fwd(&self, x: &Tensor) -> Result<Tensor> {
|
| 32 |
-
let h = candle_nn::ops::silu(&self.l1.fwd(x)?)?;
|
| 33 |
-
self.l2.fwd(&h)
|
| 34 |
-
}
|
| 35 |
-
|
| 36 |
-
pub fn vars(&self) -> Vec<Var> {
|
| 37 |
-
[self.l1.vars(), self.l2.vars()].concat()
|
| 38 |
-
}
|
| 39 |
-
|
| 40 |
-
/// EMA: `self ← m·self + (1−m)·outro` (usado no codificador-alvo).
|
| 41 |
-
pub fn ema_de(&mut self, outro: &MlpJepa, m: f64) -> Result<()> {
|
| 42 |
-
for (a, b) in self.vars().iter().zip(outro.vars().iter()) {
|
| 43 |
-
let novo = (a.as_tensor().affine(m, 0.0)? + b.as_tensor().affine(1.0 - m, 0.0)?)?;
|
| 44 |
-
a.set(&novo)?;
|
| 45 |
-
}
|
| 46 |
-
Ok(())
|
| 47 |
-
}
|
| 48 |
-
}
|
| 49 |
-
|
| 50 |
-
/// Núcleo JEPA: codificador + preditor + alvo EMA + regularizador VC.
|
| 51 |
-
pub struct NucleoJepa {
|
| 52 |
-
pub encoder: MlpJepa,
|
| 53 |
-
pub preditor: MlpJepa,
|
| 54 |
-
pub alvo: MlpJepa,
|
| 55 |
-
/// tabela de posições (blocos) — entrada extra do preditor.
|
| 56 |
-
pub pos: Var,
|
| 57 |
-
pub d_emb: usize,
|
| 58 |
-
pub d_cond: usize,
|
| 59 |
-
pub m: f64,
|
| 60 |
-
pub lambda_vc: f64,
|
| 61 |
-
pub gamma_vc: f64,
|
| 62 |
-
}
|
| 63 |
-
|
| 64 |
-
impl NucleoJepa {
|
| 65 |
-
pub fn novo(
|
| 66 |
-
d_patch: usize,
|
| 67 |
-
d_emb: usize,
|
| 68 |
-
d_cond: usize,
|
| 69 |
-
n_pos: usize,
|
| 70 |
-
m: f64,
|
| 71 |
-
lambda_vc: f64,
|
| 72 |
-
gamma_vc: f64,
|
| 73 |
-
dev: &Device,
|
| 74 |
-
) -> Result<Self> {
|
| 75 |
-
let encoder = MlpJepa::novo(d_patch, 2 * d_emb, d_emb, dev)?;
|
| 76 |
-
let preditor = MlpJepa::novo(d_emb + d_cond + d_emb, 2 * d_emb, d_emb, dev)?;
|
| 77 |
-
// alvo nasce IGUAL ao encoder (ponto de partida do EMA)
|
| 78 |
-
let mut alvo = MlpJepa::novo(d_patch, 2 * d_emb, d_emb, dev)?;
|
| 79 |
-
for (va, vb) in alvo.vars().iter().zip(encoder.vars().iter()) {
|
| 80 |
-
va.set(vb.as_tensor())?;
|
| 81 |
-
}
|
| 82 |
-
let pos_t = Tensor::randn(0f32, 0.02, (n_pos.max(1), d_emb), dev)?;
|
| 83 |
-
Ok(Self {
|
| 84 |
-
encoder,
|
| 85 |
-
preditor,
|
| 86 |
-
alvo,
|
| 87 |
-
pos: Var::from_tensor(&pos_t)?,
|
| 88 |
-
d_emb,
|
| 89 |
-
d_cond,
|
| 90 |
-
m,
|
| 91 |
-
lambda_vc,
|
| 92 |
-
gamma_vc,
|
| 93 |
-
})
|
| 94 |
-
}
|
| 95 |
-
|
| 96 |
-
pub fn vars(&self) -> Vec<Var> {
|
| 97 |
-
let mut v = self.encoder.vars();
|
| 98 |
-
v.extend(self.preditor.vars());
|
| 99 |
-
v.push(self.pos.clone());
|
| 100 |
-
v // NOTA: alvo NÃO entra — é buffer EMA
|
| 101 |
-
}
|
| 102 |
-
|
| 103 |
-
pub fn ema_passo(&mut self) -> Result<()> {
|
| 104 |
-
self.alvo.ema_de(&self.encoder, self.m)
|
| 105 |
-
}
|
| 106 |
-
|
| 107 |
-
/// Codifica um conjunto de patches (n, d_patch) → (n, d_emb).
|
| 108 |
-
pub fn codificar(&self, patches: &Tensor) -> Result<Tensor> {
|
| 109 |
-
self.encoder.fwd(patches)
|
| 110 |
-
}
|
| 111 |
-
|
| 112 |
-
/// Codifica com o alvo EMA — SEM gradiente (detach por construção: as
|
| 113 |
-
/// vars do alvo não estão no otimizador e o tensor é desconectado).
|
| 114 |
-
pub fn alvo_codificar(&self, patches: &Tensor) -> Result<Tensor> {
|
| 115 |
-
Ok(self.alvo.fwd(patches)?.detach())
|
| 116 |
-
}
|
| 117 |
-
|
| 118 |
-
/// Prediz o embedding do bloco `i_pos` a partir do contexto `z_ctx`
|
| 119 |
-
/// (d_emb) e da condição `cond` (d_cond; zeros se None).
|
| 120 |
-
pub fn predizer(&self, z_ctx: &Tensor, i_pos: usize, cond: Option<&Tensor>) -> Result<Tensor> {
|
| 121 |
-
// z_ctx: (b, d_emb) ou (d_emb,)
|
| 122 |
-
let b = z_ctx.dim(0).unwrap_or(1);
|
| 123 |
-
let dev = z_ctx.device();
|
| 124 |
-
let pos = self.pos.as_tensor().get(i_pos.min(self.pos.dim(0)?.saturating_sub(1)))?;
|
| 125 |
-
let pos_b = pos.broadcast_as((b, self.d_emb))?;
|
| 126 |
-
let cond_b = match cond {
|
| 127 |
-
Some(c) => {
|
| 128 |
-
if c.dims().len() == 1 && b > 1 {
|
| 129 |
-
c.broadcast_as((b, self.d_cond))?
|
| 130 |
-
} else {
|
| 131 |
-
c.clone()
|
| 132 |
-
}
|
| 133 |
-
}
|
| 134 |
-
None => Tensor::zeros((b, self.d_cond), candle_core::DType::F32, dev)?,
|
| 135 |
-
};
|
| 136 |
-
let entrada = Tensor::cat(&[z_ctx, &pos_b, &cond_b], candle_core::D::Minus1)?;
|
| 137 |
-
self.preditor.fwd(&entrada)
|
| 138 |
-
}
|
| 139 |
-
|
| 140 |
-
/// Regularizador variância-covariância do lote de incorporações z (n, d).
|
| 141 |
-
///
|
| 142 |
-
/// **J-1:** no colapso total `z_i = c ∀i` ⇒ `std_j = 0` ⇒ `V = d·γ²`.
|
| 143 |
-
pub fn perda_vc(&self, z: &Tensor) -> Result<Tensor> {
|
| 144 |
-
let n = z.dim(0)? as f64;
|
| 145 |
-
let d = self.d_emb;
|
| 146 |
-
let media = z.mean_keepdim(0)?; // (1, d)
|
| 147 |
-
let centr = z.broadcast_sub(&media)?;
|
| 148 |
-
let var = (centr.sqr()?.sum(0)? / n)?; // (d,)
|
| 149 |
-
let std = var.sqrt()?;
|
| 150 |
-
// dobradiça: max(0, γ − std)²
|
| 151 |
-
let gamma_t =
|
| 152 |
-
Tensor::new(self.gamma_vc as f32, z.device())?.broadcast_as(std.dims())?;
|
| 153 |
-
let gap = gamma_t.broadcast_sub(&std)?.clamp(0.0, f64::INFINITY)?;
|
| 154 |
-
let v = gap.sqr()?.sum_all()?;
|
| 155 |
-
// covariância fora-diagonal: C = centrᵀ·centr/n; perda = ‖C − diag‖²_F/(2d)
|
| 156 |
-
let cov = (centr.transpose(0, 1)?.matmul(¢r)? / n)?; // (d, d)
|
| 157 |
-
let mask_diag = {
|
| 158 |
-
let mut m = vec![0f32; d * d];
|
| 159 |
-
for i in 0..d {
|
| 160 |
-
m[i * d + i] = 1.0;
|
| 161 |
-
}
|
| 162 |
-
Tensor::from_vec(m, (d, d), z.device())?
|
| 163 |
-
};
|
| 164 |
-
let fora = ((&cov * &mask_diag)?.sqr()?.sum_all()? / (2.0 * d.max(1) as f64))?;
|
| 165 |
-
let v_norm = (v / d.max(1) as f64)?;
|
| 166 |
-
Ok((v_norm + fora)?)
|
| 167 |
-
}
|
| 168 |
-
|
| 169 |
-
/// Perda JEPA padrão para UM lote: contexto (número variável de patches),
|
| 170 |
-
/// lista de blocos-alvo (posições), condição opcional.
|
| 171 |
-
///
|
| 172 |
-
/// `z_ctx` = incorporação agregada do contexto (b, d_emb);
|
| 173 |
-
/// `alvos`: para cada elemento do lote, Vec<(i_pos, patches_alvo)>.
|
| 174 |
-
pub fn perda_lote(
|
| 175 |
-
&self,
|
| 176 |
-
z_ctx: &Tensor,
|
| 177 |
-
alvos: &[Vec<(usize, Tensor)>],
|
| 178 |
-
cond: Option<&Tensor>,
|
| 179 |
-
z_ctx_todos: &Tensor,
|
| 180 |
-
) -> Result<(Tensor, f64, f64)> {
|
| 181 |
-
let b = z_ctx.dim(0)?;
|
| 182 |
-
let dev = z_ctx.device();
|
| 183 |
-
let mut perdas: Vec<Tensor> = Vec::new();
|
| 184 |
-
let mut n_alvos = 0usize;
|
| 185 |
-
for (i, blocos) in alvos.iter().enumerate() {
|
| 186 |
-
for (i_pos, patches_alvo) in blocos {
|
| 187 |
-
// ẑ_b = média das incorporações-alvo dos patches do bloco
|
| 188 |
-
let zt = self.alvo_codificar(patches_alvo)?; // (m, d_emb)
|
| 189 |
-
let zt_m = zt.mean(0)?; // (d_emb,)
|
| 190 |
-
let zt_b = zt_m.broadcast_as((1, self.d_emb))?;
|
| 191 |
-
let zc = z_ctx.get(i)?.broadcast_as((1, self.d_emb))?;
|
| 192 |
-
let c_i = cond.map(|c| c.get(i)?.broadcast_as((1, self.d_cond))).transpose()?;
|
| 193 |
-
let pred = self.predizer(&zc, *i_pos, c_i.as_ref())?;
|
| 194 |
-
let dif = (&pred - &zt_b)?;
|
| 195 |
-
let l = (dif.sqr()?.sum_all()? / self.d_emb as f64)?;
|
| 196 |
-
perdas.push(l);
|
| 197 |
-
n_alvos += 1;
|
| 198 |
-
}
|
| 199 |
-
}
|
| 200 |
-
let l_pred = if perdas.is_empty() {
|
| 201 |
-
Tensor::zeros((), candle_core::DType::F32, &dev)?
|
| 202 |
-
} else {
|
| 203 |
-
(Tensor::stack(&perdas, 0)?.sum_all()? / n_alvos.max(1) as f64)?
|
| 204 |
-
};
|
| 205 |
-
let l_vc = self.perda_vc(z_ctx_todos)?;
|
| 206 |
-
let total = (l_pred.affine(1.0, 0.0)? + l_vc.affine(self.lambda_vc, 0.0)?)?;
|
| 207 |
-
let lp = l_pred.to_scalar::<f32>()? as f64;
|
| 208 |
-
let lv = l_vc.to_scalar::<f32>()? as f64;
|
| 209 |
-
Ok((total, lp, lv))
|
| 210 |
-
}
|
| 211 |
-
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/jepa/patches.rs
DELETED
|
@@ -1,150 +0,0 @@
|
|
| 1 |
-
//! `jepa::patches` — extraído do monólito na v0.10.0
|
| 2 |
-
//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
|
| 3 |
-
|
| 4 |
-
use super::*;
|
| 5 |
-
|
| 6 |
-
|
| 7 |
-
// ---------------------------------------------------------------------------
|
| 8 |
-
// Parte 3 — adaptadores de modalidade
|
| 9 |
-
// ---------------------------------------------------------------------------
|
| 10 |
-
|
| 11 |
-
/// (C, H, W) → patches (H/ph · W/pw, C·ph·pw) — Image-JEPA.
|
| 12 |
-
pub fn em_patches_2d(img: &Tensor, ph: usize, pw: usize) -> Result<Tensor> {
|
| 13 |
-
let (c, h, w) = (img.dim(0)?, img.dim(1)?, img.dim(2)?);
|
| 14 |
-
let dev = img.device();
|
| 15 |
-
let mut linhas: Vec<Tensor> = Vec::new();
|
| 16 |
-
for y in (0..h).step_by(ph) {
|
| 17 |
-
for x in (0..w).step_by(pw) {
|
| 18 |
-
let hh = ph.min(h - y);
|
| 19 |
-
let ww = pw.min(w - x);
|
| 20 |
-
let patch = img.narrow(0, 0, c)?.narrow(1, y, hh)?.narrow(2, x, ww)?;
|
| 21 |
-
// padding para (C, ph, pw) se borda
|
| 22 |
-
let patch = if hh < ph || ww < pw {
|
| 23 |
-
let mut buf = patch.flatten_all()?.to_vec1::<f32>()?;
|
| 24 |
-
let falta = c * ph * pw - buf.len();
|
| 25 |
-
buf.extend(std::iter::repeat(0f32).take(falta));
|
| 26 |
-
Tensor::from_vec(buf, (c * ph * pw,), &dev)?
|
| 27 |
-
} else {
|
| 28 |
-
patch.flatten_all()?
|
| 29 |
-
};
|
| 30 |
-
linhas.push(patch);
|
| 31 |
-
}
|
| 32 |
-
}
|
| 33 |
-
Ok(Tensor::stack(&linhas, 0)?)
|
| 34 |
-
}
|
| 35 |
-
|
| 36 |
-
/// (T, H, W) → tubos (T/pt · H/ph · W/pw, pt·ph·pw) — V-JEPA 2.
|
| 37 |
-
pub fn em_tubos_3d(vid: &Tensor, pt: usize, ph: usize, pw: usize) -> Result<Tensor> {
|
| 38 |
-
let (t, h, w) = (vid.dim(0)?, vid.dim(1)?, vid.dim(2)?);
|
| 39 |
-
let dev = vid.device();
|
| 40 |
-
let mut linhas: Vec<Tensor> = Vec::new();
|
| 41 |
-
for tt in (0..t).step_by(pt) {
|
| 42 |
-
let tl = pt.min(t - tt);
|
| 43 |
-
for y in (0..h).step_by(ph) {
|
| 44 |
-
for x in (0..w).step_by(pw) {
|
| 45 |
-
let hh = ph.min(h - y);
|
| 46 |
-
let ww = pw.min(w - x);
|
| 47 |
-
let tubo = vid
|
| 48 |
-
.narrow(0, tt, tl)?
|
| 49 |
-
.narrow(1, y, hh)?
|
| 50 |
-
.narrow(2, x, ww)?
|
| 51 |
-
.flatten_all()?;
|
| 52 |
-
let mut buf = tubo.to_vec1::<f32>()?;
|
| 53 |
-
let falta = pt * ph * pw - buf.len();
|
| 54 |
-
buf.extend(std::iter::repeat(0f32).take(falta));
|
| 55 |
-
linhas.push(Tensor::from_vec(buf, (pt * ph * pw,), &dev)?);
|
| 56 |
-
}
|
| 57 |
-
}
|
| 58 |
-
}
|
| 59 |
-
Ok(Tensor::stack(&linhas, 0)?)
|
| 60 |
-
}
|
| 61 |
-
|
| 62 |
-
/// (F, τ) → patches (F/pf · τ/pt, pf·pt) — Audio-JEPA.
|
| 63 |
-
pub fn em_patches_espectrograma(spec: &Tensor, pf: usize, pt: usize) -> Result<Tensor> {
|
| 64 |
-
let (f, tau) = (spec.dim(0)?, spec.dim(1)?);
|
| 65 |
-
let dev = spec.device();
|
| 66 |
-
let mut linhas: Vec<Tensor> = Vec::new();
|
| 67 |
-
for i in (0..f).step_by(pf) {
|
| 68 |
-
for j in (0..tau).step_by(pt) {
|
| 69 |
-
let ff = pf.min(f - i);
|
| 70 |
-
let tt = pt.min(tau - j);
|
| 71 |
-
let p = spec.narrow(0, i, ff)?.narrow(1, j, tt)?.flatten_all()?;
|
| 72 |
-
let mut buf = p.to_vec1::<f32>()?;
|
| 73 |
-
let falta = pf * pt - buf.len();
|
| 74 |
-
buf.extend(std::iter::repeat(0f32).take(falta));
|
| 75 |
-
linhas.push(Tensor::from_vec(buf, (pf * pt,), &dev)?);
|
| 76 |
-
}
|
| 77 |
-
}
|
| 78 |
-
Ok(Tensor::stack(&linhas, 0)?)
|
| 79 |
-
}
|
| 80 |
-
|
| 81 |
-
/// (C, T) → patches canal-independentes (C · T/pt, pt) — T-JEPA/Brain-JEPA.
|
| 82 |
-
pub fn em_patches_serie(ts: &Tensor, pt: usize) -> Result<Tensor> {
|
| 83 |
-
let (c, t) = (ts.dim(0)?, ts.dim(1)?);
|
| 84 |
-
let dev = ts.device();
|
| 85 |
-
let mut linhas: Vec<Tensor> = Vec::new();
|
| 86 |
-
for ch in 0..c {
|
| 87 |
-
for j in (0..t).step_by(pt) {
|
| 88 |
-
let tt = pt.min(t - j);
|
| 89 |
-
let p = ts.narrow(0, ch, 1)?.narrow(1, j, tt)?.flatten_all()?;
|
| 90 |
-
let mut buf = p.to_vec1::<f32>()?;
|
| 91 |
-
let falta = pt - buf.len();
|
| 92 |
-
buf.extend(std::iter::repeat(0f32).take(falta));
|
| 93 |
-
linhas.push(Tensor::from_vec(buf, (pt,), &dev)?);
|
| 94 |
-
}
|
| 95 |
-
}
|
| 96 |
-
Ok(Tensor::stack(&linhas, 0)?)
|
| 97 |
-
}
|
| 98 |
-
|
| 99 |
-
/// (X, Y, Z) → voxels (X/px · Y/py · Z/pz, px·py·pz) — 3D-JEPA.
|
| 100 |
-
pub fn em_voxels(vol: &Tensor, px: usize, py: usize, pz: usize) -> Result<Tensor> {
|
| 101 |
-
let (x, y, z) = (vol.dim(0)?, vol.dim(1)?, vol.dim(2)?);
|
| 102 |
-
let dev = vol.device();
|
| 103 |
-
let mut linhas: Vec<Tensor> = Vec::new();
|
| 104 |
-
for i in (0..x).step_by(px) {
|
| 105 |
-
for j in (0..y).step_by(py) {
|
| 106 |
-
for k in (0..z).step_by(pz) {
|
| 107 |
-
let lx = px.min(x - i);
|
| 108 |
-
let ly = py.min(y - j);
|
| 109 |
-
let lz = pz.min(z - k);
|
| 110 |
-
let p = vol.narrow(0, i, lx)?.narrow(1, j, ly)?.narrow(2, k, lz)?.flatten_all()?;
|
| 111 |
-
let mut buf = p.to_vec1::<f32>()?;
|
| 112 |
-
let falta = px * py * pz - buf.len();
|
| 113 |
-
buf.extend(std::iter::repeat(0f32).take(falta));
|
| 114 |
-
linhas.push(Tensor::from_vec(buf, (px * py * pz,), &dev)?);
|
| 115 |
-
}
|
| 116 |
-
}
|
| 117 |
-
}
|
| 118 |
-
Ok(Tensor::stack(&linhas, 0)?)
|
| 119 |
-
}
|
| 120 |
-
|
| 121 |
-
/// Nuvem de pontos (n, d) → grupos FPS (k, m·d): k centros por FPS, cada
|
| 122 |
-
/// grupo = os m vizinhos mais próximos do centro (concatenados) — Point-JEPA.
|
| 123 |
-
pub fn em_grupos_pontos(pc: &Tensor, k: usize, m: usize, rng: &mut RngDeterministico) -> Result<Tensor> {
|
| 124 |
-
let n = pc.dim(0)?;
|
| 125 |
-
let d = pc.dim(1)?;
|
| 126 |
-
let coords = pc.to_vec2::<f32>()?;
|
| 127 |
-
let coords_f: Vec<Vec<f64>> = coords.iter().map(|r| r.iter().map(|&v| v as f64).collect()).collect();
|
| 128 |
-
let centros = pontos_mais_distantes(&coords_f, k, rng);
|
| 129 |
-
let dev = pc.device();
|
| 130 |
-
let mut linhas: Vec<Tensor> = Vec::new();
|
| 131 |
-
for &ci in ¢ros {
|
| 132 |
-
// m vizinhos mais próximos do centro ci (incluindo ele próprio)
|
| 133 |
-
let mut ord: Vec<usize> = (0..n).collect();
|
| 134 |
-
ord.sort_by(|&a, &b| {
|
| 135 |
-
let da = distancia_eucl(&coords_f[a], &coords_f[ci]);
|
| 136 |
-
let db = distancia_eucl(&coords_f[b], &coords_f[ci]);
|
| 137 |
-
da.partial_cmp(&db).unwrap()
|
| 138 |
-
});
|
| 139 |
-
let mut buf: Vec<f32> = Vec::with_capacity(m * d);
|
| 140 |
-
for &idx in ord.iter().take(m) {
|
| 141 |
-
for j in 0..d {
|
| 142 |
-
buf.push(coords[idx][j]);
|
| 143 |
-
}
|
| 144 |
-
}
|
| 145 |
-
let falta = m * d - buf.len();
|
| 146 |
-
buf.extend(std::iter::repeat(0f32).take(falta));
|
| 147 |
-
linhas.push(Tensor::from_vec(buf, (m * d,), &dev)?);
|
| 148 |
-
}
|
| 149 |
-
Ok(Tensor::stack(&linhas, 0)?)
|
| 150 |
-
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/jepa/replay_ssm.rs
DELETED
|
@@ -1,107 +0,0 @@
|
|
| 1 |
-
//! `jepa::replay_ssm` — extraído do monólito na v0.10.0
|
| 2 |
-
//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
|
| 3 |
-
|
| 4 |
-
use super::*;
|
| 5 |
-
|
| 6 |
-
|
| 7 |
-
// ---------------------------------------------------------------------------
|
| 8 |
-
// Parte 6 — ReplaySSM
|
| 9 |
-
// ---------------------------------------------------------------------------
|
| 10 |
-
|
| 11 |
-
/// SSM de porta diagonal com replay para aprendizado continuado.
|
| 12 |
-
///
|
| 13 |
-
/// Recorrência: `h_t = σ(a) ⊙ h_{t−1} + (1 − σ(a)) ⊙ (B x_t)`.
|
| 14 |
-
///
|
| 15 |
-
/// **Prova R-1 (estabilidade):** `|σ(a)| < 1` ⇒ perturbações de `h_0`
|
| 16 |
-
/// decaem geometricamente (mesma estrutura do Teo S-2' do SSD-Δ).
|
| 17 |
-
///
|
| 18 |
-
/// **Prova R-2 (limite de esquecimento):** o passo de treino mistura
|
| 19 |
-
/// gradientes `(1−α)·∇L_novo + α·∇L_replay`; para `L_antiga` μ-fortemente
|
| 20 |
-
/// convexa com gradientes novos limitados por `G`, o afastamento do ótimo
|
| 21 |
-
/// antigo por passo é `≤ (1−α)·η·G` (sem replay: `≤ η·G`) — o replay
|
| 22 |
-
/// contrai o drift por um fator `1/(1−α)` no regime linear.
|
| 23 |
-
pub struct ReplaySsm {
|
| 24 |
-
pub a: Var, // (d,) — porta (sigmoid no uso)
|
| 25 |
-
pub b: Var, // (d_in, d) — projeção de entrada
|
| 26 |
-
pub d: usize,
|
| 27 |
-
pub alpha_replay: f64,
|
| 28 |
-
pub buffer: Vec<Tensor>,
|
| 29 |
-
pub capacidade_buffer: usize,
|
| 30 |
-
}
|
| 31 |
-
|
| 32 |
-
impl ReplaySsm {
|
| 33 |
-
pub fn novo(d_in: usize, d: usize, alpha_replay: f64, capacidade_buffer: usize, dev: &Device) -> Result<Self> {
|
| 34 |
-
let a_t = Tensor::randn(0f32, 0.5, (d,), dev)?;
|
| 35 |
-
let b_t = Tensor::randn(0f32, 0.1, (d_in, d), dev)?;
|
| 36 |
-
Ok(Self {
|
| 37 |
-
a: Var::from_tensor(&a_t)?,
|
| 38 |
-
b: Var::from_tensor(&b_t)?,
|
| 39 |
-
d,
|
| 40 |
-
alpha_replay,
|
| 41 |
-
buffer: Vec::new(),
|
| 42 |
-
capacidade_buffer,
|
| 43 |
-
})
|
| 44 |
-
}
|
| 45 |
-
|
| 46 |
-
pub fn vars(&self) -> Vec<Var> {
|
| 47 |
-
vec![self.a.clone(), self.b.clone()]
|
| 48 |
-
}
|
| 49 |
-
|
| 50 |
-
/// Scan: x (T, d_in) → h (T, d). Diferenciável (candle autograd).
|
| 51 |
-
pub fn scan(&self, x: &Tensor) -> Result<Tensor> {
|
| 52 |
-
let t = x.dim(0)?;
|
| 53 |
-
let dev = x.device();
|
| 54 |
-
let porta = candle_nn::ops::sigmoid(&self.a.as_tensor().broadcast_as((1, self.d))?)?; // (1, d)
|
| 55 |
-
let um_menos = porta.affine(-1.0, 1.0)?; // 1 − σ(a)
|
| 56 |
-
let entrada = x.matmul(&self.b.as_tensor())?; // (T, d)
|
| 57 |
-
let mut h = Tensor::zeros((1, self.d), candle_core::DType::F32, &dev)?;
|
| 58 |
-
let mut saidas: Vec<Tensor> = Vec::with_capacity(t);
|
| 59 |
-
for i in 0..t {
|
| 60 |
-
let xt = entrada.narrow(0, i, 1)?;
|
| 61 |
-
h = ((&porta * &h)? + (&um_menos * &xt)?)?;
|
| 62 |
-
saidas.push(h.clone());
|
| 63 |
-
}
|
| 64 |
-
Ok(Tensor::stack(&saidas, 0)?)
|
| 65 |
-
}
|
| 66 |
-
|
| 67 |
-
/// Empurra uma janela de treino no buffer (FIFO).
|
| 68 |
-
pub fn guardar(&mut self, x: &Tensor) {
|
| 69 |
-
if self.buffer.len() >= self.capacidade_buffer {
|
| 70 |
-
self.buffer.remove(0);
|
| 71 |
-
}
|
| 72 |
-
self.buffer.push(x.detach());
|
| 73 |
-
}
|
| 74 |
-
|
| 75 |
-
/// Um passo de treino no lote novo (com mistura de replay).
|
| 76 |
-
/// Devolve (perda_total, perda_novo, perda_replay).
|
| 77 |
-
pub fn passo_treino(
|
| 78 |
-
&mut self,
|
| 79 |
-
x: &Tensor,
|
| 80 |
-
alvo: &Tensor,
|
| 81 |
-
otimizador: &mut crate::treino::AdamWManual,
|
| 82 |
-
) -> Result<(f64, f64, f64)> {
|
| 83 |
-
// perda nova
|
| 84 |
-
let h = self.scan(x)?;
|
| 85 |
-
let dif = (&h - alvo)?;
|
| 86 |
-
let perda_novo = dif.sqr()?.mean_all()?;
|
| 87 |
-
// replay
|
| 88 |
-
let mut perda_total = perda_novo.clone();
|
| 89 |
-
let mut p_r = 0.0;
|
| 90 |
-
if !self.buffer.is_empty() {
|
| 91 |
-
let idx = self.buffer.len() - 1;
|
| 92 |
-
let antigo = self.buffer[idx].clone();
|
| 93 |
-
let hr = self.scan(&antigo)?;
|
| 94 |
-
// alvo do replay: manter a dinâmica aprendida estável (magnitudes
|
| 95 |
-
// finitas) — auto-supervisão de estabilidade
|
| 96 |
-
let dr = hr.sqr()?.mean_all()?;
|
| 97 |
-
perda_total = (perda_total.affine(1.0 - self.alpha_replay, 0.0)?
|
| 98 |
-
+ dr.affine(self.alpha_replay, 0.0)?)?;
|
| 99 |
-
p_r = dr.to_scalar::<f32>()? as f64;
|
| 100 |
-
}
|
| 101 |
-
let pn = perda_novo.to_scalar::<f32>()? as f64;
|
| 102 |
-
otimizador.passo(crate::treino::grads_achatados(&perda_total, &self.vars())?);
|
| 103 |
-
self.guardar(x);
|
| 104 |
-
let pt = perda_total.to_scalar::<f32>()? as f64;
|
| 105 |
-
Ok((pt, pn, p_r))
|
| 106 |
-
}
|
| 107 |
-
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/jepa/sonic_moe.rs
DELETED
|
@@ -1,155 +0,0 @@
|
|
| 1 |
-
//! `jepa::sonic_moe` — extraído do monólito na v0.10.0
|
| 2 |
-
//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
|
| 3 |
-
|
| 4 |
-
use super::*;
|
| 5 |
-
|
| 6 |
-
|
| 7 |
-
// ---------------------------------------------------------------------------
|
| 8 |
-
// Parte 5 — SonicMoE (IO/tile-aware)
|
| 9 |
-
// ---------------------------------------------------------------------------
|
| 10 |
-
|
| 11 |
-
/// MoE top-k com capacidade por especialista e perda de balanceamento.
|
| 12 |
-
///
|
| 13 |
-
/// **Prova SM-1 (limite de capacidade):** o roteamento tile-aware mantém no
|
| 14 |
-
/// máximo `C` tokens por especialista por ladrilho — o drop é determinístico
|
| 15 |
-
/// (ordem de chegada) e o nº de tokens descartados é `Σ_e max(0, load_e − C)`.
|
| 16 |
-
///
|
| 17 |
-
/// **Prova SM-2 (balanceamento):** `L_aux = E·Σ_e f_e·p_e`; com roteamento
|
| 18 |
-
/// auto-consistente (`f = p`), `L_aux = E·Σ p_e² ≥ 1` com igualdade sse
|
| 19 |
-
/// `p_e = 1/E` (Cauchy–Schchwarz) — o mínimo força o roteador uniforme.
|
| 20 |
-
pub struct SonicMoe {
|
| 21 |
-
pub roteador: Linear, // d → E
|
| 22 |
-
pub especialistas: Vec<MlpJepa>, // E experts d → d
|
| 23 |
-
pub n_top: usize,
|
| 24 |
-
pub capacidade: usize,
|
| 25 |
-
pub lambda_aux: f64,
|
| 26 |
-
}
|
| 27 |
-
|
| 28 |
-
pub struct SaidaMoe {
|
| 29 |
-
pub saida: Tensor,
|
| 30 |
-
pub perda_aux: Tensor,
|
| 31 |
-
pub carga: Vec<usize>, // tokens efetivamente processados por especialista
|
| 32 |
-
pub descartados: usize, // tokens com especialistas cortados pela capacidade
|
| 33 |
-
}
|
| 34 |
-
|
| 35 |
-
impl SonicMoe {
|
| 36 |
-
pub fn novo(d: usize, n_expertos: usize, n_top: usize, capacidade: usize, dev: &Device) -> Result<Self> {
|
| 37 |
-
let roteador = Linear::sem_vies(d, n_expertos, 0.1, dev)?;
|
| 38 |
-
let especialistas = (0..n_expertos)
|
| 39 |
-
.map(|_| MlpJepa::novo(d, 2 * d, d, dev))
|
| 40 |
-
.collect::<Result<Vec<_>>>()?;
|
| 41 |
-
Ok(Self { roteador, especialistas, n_top, capacidade, lambda_aux: 0.01 })
|
| 42 |
-
}
|
| 43 |
-
|
| 44 |
-
pub fn vars(&self) -> Vec<Var> {
|
| 45 |
-
let mut v = self.roteador.vars();
|
| 46 |
-
for e in &self.especialistas {
|
| 47 |
-
v.extend(e.vars());
|
| 48 |
-
}
|
| 49 |
-
v
|
| 50 |
-
}
|
| 51 |
-
|
| 52 |
-
/// Forward tile-aware: (n, d) → (n, d).
|
| 53 |
-
pub fn fwd(&self, x: &Tensor) -> Result<SaidaMoe> {
|
| 54 |
-
let n = x.dim(0)?;
|
| 55 |
-
let d = x.dim(1)?;
|
| 56 |
-
let e = self.especialistas.len();
|
| 57 |
-
let dev = x.device();
|
| 58 |
-
let logits = self.roteador.fwd(x)?; // (n, E)
|
| 59 |
-
let probs = candle_nn::ops::softmax(&logits, candle_core::D::Minus1)?;
|
| 60 |
-
|
| 61 |
-
// top-k por token (não diferenciável — pesos do top-k são dif. via probs)
|
| 62 |
-
let probs_v = probs.to_vec2::<f32>()?;
|
| 63 |
-
let mut carga = vec![0usize; e];
|
| 64 |
-
let mut descartados = 0usize;
|
| 65 |
-
// acumulador de saída (n, d) — construído por soma de contribuições
|
| 66 |
-
let mut saida = Tensor::zeros((n, d), candle_core::DType::F32, &dev)?;
|
| 67 |
-
let mut peso_total = Tensor::zeros((n, 1), candle_core::DType::F32, &dev)?;
|
| 68 |
-
// por especialista (tile): tokens cujo top-k contém e e com carga < C
|
| 69 |
-
for ei in 0..e {
|
| 70 |
-
// candidatos: tokens ordenados por prob do especialista ei
|
| 71 |
-
let mut cand: Vec<(usize, f32)> = (0..n)
|
| 72 |
-
.map(|i| (i, probs_v[i][ei]))
|
| 73 |
-
.collect();
|
| 74 |
-
cand.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
|
| 75 |
-
let mut escolhidos: Vec<usize> = Vec::new();
|
| 76 |
-
for (i, _) in cand {
|
| 77 |
-
if carga[ei] >= self.capacidade {
|
| 78 |
-
break;
|
| 79 |
-
}
|
| 80 |
-
// verifica se ei está no top-k do token i
|
| 81 |
-
let mut ordem: Vec<(f32, usize)> =
|
| 82 |
-
(0..e).map(|k| (probs_v[i][k], k)).collect();
|
| 83 |
-
ordem.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap());
|
| 84 |
-
let top: Vec<usize> = ordem.iter().rev().take(self.n_top).map(|(_, k)| *k).collect();
|
| 85 |
-
if top.contains(&ei) {
|
| 86 |
-
escolhidos.push(i);
|
| 87 |
-
carga[ei] += 1;
|
| 88 |
-
}
|
| 89 |
-
}
|
| 90 |
-
if escolhidos.is_empty() {
|
| 91 |
-
continue;
|
| 92 |
-
}
|
| 93 |
-
// tile do especialista: uma única passagem em lote
|
| 94 |
-
let idx: Vec<u32> = escolhidos.iter().map(|&i| i as u32).collect();
|
| 95 |
-
let n_e = idx.len();
|
| 96 |
-
let idx_t = Tensor::from_vec(idx, (n_e,), &dev)?;
|
| 97 |
-
let tile = x.index_select(&idx_t, 0)?;
|
| 98 |
-
let y = self.especialistas[ei].fwd(&tile)?; // (m, d)
|
| 99 |
-
// pesos: prob do especialista ei para cada token escolhido
|
| 100 |
-
let w: Vec<f32> = escolhidos.iter().map(|&i| probs_v[i][ei]).collect();
|
| 101 |
-
let n_w = escolhidos.len();
|
| 102 |
-
let w_t = Tensor::from_vec(w.clone(), (n_w, 1), &dev)?;
|
| 103 |
-
let contrib = y.broadcast_mul(&w_t)?;
|
| 104 |
-
// scatter-add: acumula nas posições
|
| 105 |
-
let mut buf = saida.to_vec2::<f32>()?;
|
| 106 |
-
let contrib_v = contrib.to_vec2::<f32>()?;
|
| 107 |
-
for (k, &i) in escolhidos.iter().enumerate() {
|
| 108 |
-
for j in 0..d {
|
| 109 |
-
buf[i][j] += contrib_v[k][j];
|
| 110 |
-
}
|
| 111 |
-
}
|
| 112 |
-
saida = Tensor::from_vec(
|
| 113 |
-
buf.into_iter().flatten().collect::<Vec<f32>>(),
|
| 114 |
-
(n, d),
|
| 115 |
-
&dev,
|
| 116 |
-
)?;
|
| 117 |
-
let mut pt = peso_total.to_vec2::<f32>()?;
|
| 118 |
-
for (k, &i) in escolhidos.iter().enumerate() {
|
| 119 |
-
pt[i][0] += w[k];
|
| 120 |
-
}
|
| 121 |
-
peso_total = Tensor::from_vec(
|
| 122 |
-
pt.into_iter().flatten().collect::<Vec<f32>>(),
|
| 123 |
-
(n, 1),
|
| 124 |
-
&dev,
|
| 125 |
-
)?;
|
| 126 |
-
}
|
| 127 |
-
// tokens sem especialista (todos cortados) → descartados; saída 0
|
| 128 |
-
let pt_v = peso_total.to_vec2::<f32>()?;
|
| 129 |
-
for i in 0..n {
|
| 130 |
-
if pt_v[i][0] == 0.0 {
|
| 131 |
-
descartados += 1;
|
| 132 |
-
}
|
| 133 |
-
}
|
| 134 |
-
// renormaliza pelo peso efetivo (evita viés da capacidade)
|
| 135 |
-
let denom = peso_total.clamp(1e-6, f64::INFINITY)?;
|
| 136 |
-
let saida = saida.broadcast_div(&denom)?;
|
| 137 |
-
|
| 138 |
-
// perda auxiliar: E·Σ f_e·p_e (f = fração de tokens cujo top-1 é e)
|
| 139 |
-
let mut f = vec![0f32; e];
|
| 140 |
-
for i in 0..n {
|
| 141 |
-
let (mut melhor, mut mp) = (0usize, f32::NEG_INFINITY);
|
| 142 |
-
for k in 0..e {
|
| 143 |
-
if probs_v[i][k] > mp {
|
| 144 |
-
mp = probs_v[i][k];
|
| 145 |
-
melhor = k;
|
| 146 |
-
}
|
| 147 |
-
}
|
| 148 |
-
f[melhor] += 1.0 / n as f32;
|
| 149 |
-
}
|
| 150 |
-
let f_t = Tensor::from_vec(f, (e,), &dev)?;
|
| 151 |
-
let p_media = probs.mean(0)?; // (E,)
|
| 152 |
-
let perda_aux = ((&f_t * &p_media)?.sum_all()? * (e as f64))?;
|
| 153 |
-
Ok(SaidaMoe { saida, perda_aux, carga, descartados })
|
| 154 |
-
}
|
| 155 |
-
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/jepa/testes.rs
DELETED
|
@@ -1,212 +0,0 @@
|
|
| 1 |
-
//! `jepa::testes` — extraído do monólito na v0.10.0
|
| 2 |
-
//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
|
| 3 |
-
|
| 4 |
-
use super::*;
|
| 5 |
-
|
| 6 |
-
|
| 7 |
-
#[cfg(test)]
|
| 8 |
-
mod testes {
|
| 9 |
-
use super::*;
|
| 10 |
-
|
| 11 |
-
fn tensor_2d(dados: &[Vec<f64>], dev: &Device) -> Tensor {
|
| 12 |
-
let flat: Vec<f32> = dados.iter().flat_map(|v| v.iter().map(|&x| x as f32)).collect();
|
| 13 |
-
Tensor::from_vec(flat, (dados.len(), dados[0].len()), dev).unwrap()
|
| 14 |
-
}
|
| 15 |
-
|
| 16 |
-
#[test]
|
| 17 |
-
fn teste_mascaras_validas() {
|
| 18 |
-
// fração respeitada ±, particionamento contexto/alvo não-vazio
|
| 19 |
-
let mut rng = RngDeterministico::novo(1);
|
| 20 |
-
let m2 = mascara_blocos_2d(8, 8, 4, 0.3, &mut rng);
|
| 21 |
-
assert_eq!(m2.len(), 64);
|
| 22 |
-
let frac = m2.iter().filter(|&&b| b).count() as f64 / 64.0;
|
| 23 |
-
assert!(frac >= 0.15 && frac <= 0.55, "frac 2d = {frac}");
|
| 24 |
-
assert!(m2.iter().any(|&b| !b), "contexto vazio");
|
| 25 |
-
|
| 26 |
-
let m3 = mascara_tubos_3d(4, 6, 6, 3, 0.3, &mut rng);
|
| 27 |
-
assert_eq!(m3.len(), 144);
|
| 28 |
-
let f3 = m3.iter().filter(|&&b| b).count() as f64 / 144.0;
|
| 29 |
-
assert!(f3 >= 0.15 && f3 <= 0.6, "frac 3d = {f3}");
|
| 30 |
-
|
| 31 |
-
let ms = mascara_segmentos(4, 32, 0.25, &mut rng);
|
| 32 |
-
assert_eq!(ms.len(), 128);
|
| 33 |
-
assert!(ms.iter().any(|&b| b) && ms.iter().any(|&b| !b));
|
| 34 |
-
|
| 35 |
-
let m1 = mascara_intervalos_1d(64, 0.3, &mut rng);
|
| 36 |
-
let f1 = m1.iter().filter(|&&b| b).count() as f64 / 64.0;
|
| 37 |
-
assert!(f1 >= 0.25 && f1 <= 0.45, "frac 1d = {f1}");
|
| 38 |
-
}
|
| 39 |
-
|
| 40 |
-
#[test]
|
| 41 |
-
fn teste_fps_cobre() {
|
| 42 |
-
let mut rng = RngDeterministico::novo(2);
|
| 43 |
-
let pontos: Vec<Vec<f64>> = (0..40)
|
| 44 |
-
.map(|i| {
|
| 45 |
-
let a = i as f64 * 0.1;
|
| 46 |
-
vec![a.cos() * 3.0, a.sin() * 3.0, (i % 7) as f64 * 0.3]
|
| 47 |
-
})
|
| 48 |
-
.collect();
|
| 49 |
-
let centros = pontos_mais_distantes(&pontos, 6, &mut rng);
|
| 50 |
-
assert_eq!(centros.len(), 6);
|
| 51 |
-
// centros distintos
|
| 52 |
-
let mut s = centros.clone();
|
| 53 |
-
s.sort();
|
| 54 |
-
s.dedup();
|
| 55 |
-
assert_eq!(s.len(), 6);
|
| 56 |
-
}
|
| 57 |
-
|
| 58 |
-
#[test]
|
| 59 |
-
fn teste_j1_colapso_impossivel() {
|
| 60 |
-
// No colapso total (z constante), a perda VC = γ² > 0 — verificando a
|
| 61 |
-
// fórmula implementada com um lote constante.
|
| 62 |
-
let dev = Device::Cpu;
|
| 63 |
-
let nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap();
|
| 64 |
-
let z = Tensor::from_vec(vec![0.5f32; 8 * 8], (8, 8), &dev).unwrap();
|
| 65 |
-
let lvc = nucleo.perda_vc(&z).unwrap();
|
| 66 |
-
let v = lvc.to_scalar::<f32>().unwrap() as f64;
|
| 67 |
-
// std=0 ⇒ dobradiça = γ = 1 ⇒ V/d = 1; cov = 0
|
| 68 |
-
assert!(v > 0.9, "perda VC no colapso = {v} (deveria ser ~1)");
|
| 69 |
-
}
|
| 70 |
-
|
| 71 |
-
#[test]
|
| 72 |
-
fn teste_j2_ema_ponto_fixo() {
|
| 73 |
-
// encoder congelado ⇒ após muitas passadas EMA, alvo = encoder
|
| 74 |
-
let dev = Device::Cpu;
|
| 75 |
-
let mut nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.5, 0.1, 1.0, &dev).unwrap();
|
| 76 |
-
for _ in 0..40 {
|
| 77 |
-
nucleo.ema_passo().unwrap();
|
| 78 |
-
}
|
| 79 |
-
let a = nucleo.alvo.vars()[0].as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap();
|
| 80 |
-
let b = nucleo.encoder.vars()[0].as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap();
|
| 81 |
-
let dif: f32 = a.iter().zip(&b).map(|(x, y)| (x - y).abs()).fold(0.0, f32::max);
|
| 82 |
-
assert!(dif < 1e-5, "EMA não convergiu: dif máx = {dif}");
|
| 83 |
-
}
|
| 84 |
-
|
| 85 |
-
#[test]
|
| 86 |
-
fn teste_jepa_aprende_latente_previsivel() {
|
| 87 |
-
// J-3: com alvo previsível (função determinística do contexto), a
|
| 88 |
-
// perda pred must cair substancialmente e o std das incorporações
|
| 89 |
-
// NÃO colapsa (J-1).
|
| 90 |
-
let dev = Device::Cpu;
|
| 91 |
-
let mut rng = RngDeterministico::novo(3);
|
| 92 |
-
// patches = 64 vetores 8-D em 4 grupos (estrutura previsível)
|
| 93 |
-
let mut dados: Vec<Vec<f64>> = Vec::new();
|
| 94 |
-
for g in 0..4 {
|
| 95 |
-
let c = g as f64 * 2.0;
|
| 96 |
-
for _ in 0..16 {
|
| 97 |
-
dados.push((0..8).map(|k| c + rng.normal(0.0, 0.3) + (k as f64) * 0.05).collect());
|
| 98 |
-
}
|
| 99 |
-
}
|
| 100 |
-
let patches = tensor_2d(&dados, &dev);
|
| 101 |
-
let cfg = CfgJepa { d_emb: 16, epocas: 40, lr: 5e-3, ..Default::default() };
|
| 102 |
-
let rel = treinar_variante(
|
| 103 |
-
&patches,
|
| 104 |
-
&|n, r| mascara_intervalos_1d(n, 0.3, r),
|
| 105 |
-
&cfg,
|
| 106 |
-
VarianteJepa::TJepa,
|
| 107 |
-
None,
|
| 108 |
-
&dev,
|
| 109 |
-
)
|
| 110 |
-
.unwrap();
|
| 111 |
-
assert!(
|
| 112 |
-
rel.perda_final < rel.perda_inicial * 0.8,
|
| 113 |
-
"perda deveria cair: {} → {}",
|
| 114 |
-
rel.perda_inicial,
|
| 115 |
-
rel.perda_final
|
| 116 |
-
);
|
| 117 |
-
assert!(
|
| 118 |
-
rel.std_emb_final > 0.05,
|
| 119 |
-
"sem colapso: std_final = {}",
|
| 120 |
-
rel.std_emb_final
|
| 121 |
-
);
|
| 122 |
-
}
|
| 123 |
-
|
| 124 |
-
#[test]
|
| 125 |
-
fn teste_adaptadores_formas() {
|
| 126 |
-
let dev = Device::Cpu;
|
| 127 |
-
let img = Tensor::randn(0f32, 1.0, (3, 16, 16), &dev).unwrap();
|
| 128 |
-
let p = em_patches_2d(&img, 4, 4).unwrap();
|
| 129 |
-
assert_eq!(p.dims().to_vec(), vec![16, 48]);
|
| 130 |
-
|
| 131 |
-
let vid = Tensor::randn(0f32, 1.0, (4, 8, 8), &dev).unwrap();
|
| 132 |
-
let t3 = em_tubos_3d(&vid, 2, 4, 4).unwrap();
|
| 133 |
-
assert_eq!(t3.dims().to_vec(), vec![8, 32]);
|
| 134 |
-
|
| 135 |
-
let spec = Tensor::randn(0f32, 1.0, (16, 32), &dev).unwrap();
|
| 136 |
-
let ps = em_patches_espectrograma(&spec, 4, 8).unwrap();
|
| 137 |
-
assert_eq!(ps.dims().to_vec(), vec![16, 32]);
|
| 138 |
-
|
| 139 |
-
let ts = Tensor::randn(0f32, 1.0, (4, 32), &dev).unwrap();
|
| 140 |
-
let pt_ = em_patches_serie(&ts, 8).unwrap();
|
| 141 |
-
assert_eq!(pt_.dims().to_vec(), vec![16, 8]);
|
| 142 |
-
|
| 143 |
-
let vol = Tensor::randn(0f32, 1.0, (8, 8, 8), &dev).unwrap();
|
| 144 |
-
let vx = em_voxels(&vol, 4, 4, 4).unwrap();
|
| 145 |
-
assert_eq!(vx.dims().to_vec(), vec![8, 64]);
|
| 146 |
-
|
| 147 |
-
let pc = Tensor::randn(0f32, 1.0, (50, 3), &dev).unwrap();
|
| 148 |
-
let mut rng = RngDeterministico::novo(5);
|
| 149 |
-
let gr = em_grupos_pontos(&pc, 6, 4, &mut rng).unwrap();
|
| 150 |
-
assert_eq!(gr.dims().to_vec(), vec![6, 12]);
|
| 151 |
-
}
|
| 152 |
-
|
| 153 |
-
#[test]
|
| 154 |
-
fn teste_sonic_moe_capacidade_e_balanceamento() {
|
| 155 |
-
// SM-1: carga por especialista ≤ capacidade; SM-2: aux ≥ ~1 quando
|
| 156 |
-
// roteador é ~uniforme (início).
|
| 157 |
-
let dev = Device::Cpu;
|
| 158 |
-
let moe = SonicMoe::novo(8, 4, 2, 6, &dev).unwrap();
|
| 159 |
-
let x = Tensor::randn(0f32, 1.0, (20, 8), &dev).unwrap();
|
| 160 |
-
let s = moe.fwd(&x).unwrap();
|
| 161 |
-
for (e, c) in s.carga.iter().enumerate() {
|
| 162 |
-
assert!(*c <= 6, "especialista {e} com carga {c} > capacidade 6");
|
| 163 |
-
}
|
| 164 |
-
assert_eq!(s.saida.dims().to_vec(), vec![20, 8]);
|
| 165 |
-
let aux = s.perda_aux.to_scalar::<f32>().unwrap() as f64;
|
| 166 |
-
// com roteador quase uniforme, aux ≈ E·Σ (1/E)·(1/E) = 1
|
| 167 |
-
assert!(aux > 0.5 && aux < 3.0, "aux = {aux}");
|
| 168 |
-
// cada token processado por ≤ n_top especialistas
|
| 169 |
-
let total_carga: usize = s.carga.iter().sum();
|
| 170 |
-
assert!(total_carga <= 20 * 2, "carga total {total_carga} > n·topk");
|
| 171 |
-
}
|
| 172 |
-
|
| 173 |
-
#[test]
|
| 174 |
-
fn teste_replay_ssm_estabilidade_e_replay() {
|
| 175 |
-
// R-1: estados finitos e limitados; R-2: com replay α>0, após treinar
|
| 176 |
-
// a tarefa nova, a dinâmica antiga (magnitude do estado) permanece
|
| 177 |
-
// estável (não diverge).
|
| 178 |
-
let dev = Device::Cpu;
|
| 179 |
-
let mut ssm = ReplaySsm::novo(4, 6, 0.5, 8, &dev).unwrap();
|
| 180 |
-
let vars = ssm.vars();
|
| 181 |
-
let mut otim = crate::treino::AdamWManual::novo(vars, 1e-2, 0.0);
|
| 182 |
-
|
| 183 |
-
// tarefa "antiga": sinal constante 1.0
|
| 184 |
-
let x_antigo = Tensor::from_vec(vec![1.0f32; 16 * 4], (16, 4), &dev).unwrap();
|
| 185 |
-
for _ in 0..30 {
|
| 186 |
-
let h = ssm.scan(&x_antigo).unwrap();
|
| 187 |
-
let alvo = h.detach();
|
| 188 |
-
ssm.passo_treino(&x_antigo, &alvo, &mut otim).unwrap();
|
| 189 |
-
}
|
| 190 |
-
// estado após treino antigo: finito
|
| 191 |
-
let h1 = ssm.scan(&x_antigo).unwrap();
|
| 192 |
-
let m1 = h1.abs().unwrap().max_all().unwrap().to_scalar::<f32>().unwrap();
|
| 193 |
-
assert!(m1.is_finite() && m1 < 50.0, "estado explodiu: {m1}");
|
| 194 |
-
|
| 195 |
-
// tarefa "nova": sinal −1.0 — treino com replay
|
| 196 |
-
let x_novo = Tensor::from_vec(vec![-1.0f32; 16 * 4], (16, 4), &dev).unwrap();
|
| 197 |
-
for _ in 0..30 {
|
| 198 |
-
let h = ssm.scan(&x_novo).unwrap();
|
| 199 |
-
let alvo = h.detach();
|
| 200 |
-
ssm.passo_treino(&x_novo, &alvo, &mut otim).unwrap();
|
| 201 |
-
}
|
| 202 |
-
// a dinâmica antiga continua estável (sem explosão)
|
| 203 |
-
let h2 = ssm.scan(&x_antigo).unwrap();
|
| 204 |
-
let m2 = h2.abs().unwrap().max_all().unwrap().to_scalar::<f32>().unwrap();
|
| 205 |
-
assert!(m2.is_finite() && m2 < 50.0, "estado antigo explodiu: {m2}");
|
| 206 |
-
// portas dentro de (0,1)
|
| 207 |
-
let a = ssm.a.as_tensor().to_vec1::<f32>().unwrap();
|
| 208 |
-
for v in a {
|
| 209 |
-
assert!(v.is_finite());
|
| 210 |
-
}
|
| 211 |
-
}
|
| 212 |
-
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/jepa/variantes.rs
DELETED
|
@@ -1,476 +0,0 @@
|
|
| 1 |
-
//! `jepa::variantes` — extraído do monólito na v0.10.0
|
| 2 |
-
//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
|
| 3 |
-
|
| 4 |
-
use super::*;
|
| 5 |
-
|
| 6 |
-
|
| 7 |
-
// ---------------------------------------------------------------------------
|
| 8 |
-
// Parte 4 — variantes e treino unificado
|
| 9 |
-
// ---------------------------------------------------------------------------
|
| 10 |
-
|
| 11 |
-
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
| 12 |
-
pub enum VarianteJepa {
|
| 13 |
-
ImageJepa,
|
| 14 |
-
VJepa2,
|
| 15 |
-
McJepa,
|
| 16 |
-
AudioJepa,
|
| 17 |
-
PointJepa,
|
| 18 |
-
Jepa3D,
|
| 19 |
-
BrainJepa,
|
| 20 |
-
TJepa,
|
| 21 |
-
LeJepa,
|
| 22 |
-
BJepa,
|
| 23 |
-
}
|
| 24 |
-
|
| 25 |
-
impl VarianteJepa {
|
| 26 |
-
pub fn nome(&self) -> &'static str {
|
| 27 |
-
match self {
|
| 28 |
-
Self::ImageJepa => "Image-JEPA",
|
| 29 |
-
Self::VJepa2 => "V-JEPA 2",
|
| 30 |
-
Self::McJepa => "MC-JEPA",
|
| 31 |
-
Self::AudioJepa => "Audio-JEPA",
|
| 32 |
-
Self::PointJepa => "Point-JEPA",
|
| 33 |
-
Self::Jepa3D => "3D-JEPA",
|
| 34 |
-
Self::BrainJepa => "Brain-JEPA",
|
| 35 |
-
Self::TJepa => "T-JEPA",
|
| 36 |
-
Self::LeJepa => "LeJEPA",
|
| 37 |
-
Self::BJepa => "BJEPA",
|
| 38 |
-
}
|
| 39 |
-
}
|
| 40 |
-
}
|
| 41 |
-
|
| 42 |
-
#[derive(Debug, Clone)]
|
| 43 |
-
pub struct CfgJepa {
|
| 44 |
-
pub d_emb: usize,
|
| 45 |
-
pub epocas: usize,
|
| 46 |
-
pub lr: f64,
|
| 47 |
-
pub m: f64, // EMA
|
| 48 |
-
pub lambda_vc: f64,
|
| 49 |
-
pub gamma_vc: f64,
|
| 50 |
-
pub frac_mascara: f64,
|
| 51 |
-
pub semente: u64,
|
| 52 |
-
/// tamanho do bloco-alvo (nº de patches por bloco).
|
| 53 |
-
pub tam_bloco: usize,
|
| 54 |
-
}
|
| 55 |
-
|
| 56 |
-
impl Default for CfgJepa {
|
| 57 |
-
fn default() -> Self {
|
| 58 |
-
Self {
|
| 59 |
-
d_emb: 32,
|
| 60 |
-
epocas: 60,
|
| 61 |
-
lr: 1.5e-3,
|
| 62 |
-
m: 0.99,
|
| 63 |
-
lambda_vc: 0.5,
|
| 64 |
-
gamma_vc: 1.0,
|
| 65 |
-
frac_mascara: 0.35,
|
| 66 |
-
semente: 42,
|
| 67 |
-
tam_bloco: 2,
|
| 68 |
-
}
|
| 69 |
-
}
|
| 70 |
-
}
|
| 71 |
-
|
| 72 |
-
/// Relatório de treino de uma variante.
|
| 73 |
-
#[derive(Debug, Clone)]
|
| 74 |
-
pub struct RelatorioJepa {
|
| 75 |
-
pub variante: String,
|
| 76 |
-
pub perda_inicial: f64,
|
| 77 |
-
pub perda_final: f64,
|
| 78 |
-
/// perda PREDITIVA isolada (sem o regularizador VC) — critério de
|
| 79 |
-
/// aprendizado honesto (a VC pode crescer legitimamente ao empurrar o
|
| 80 |
-
/// std das incorporações para cima).
|
| 81 |
-
pub perda_pred_inicial: f64,
|
| 82 |
-
pub perda_pred_final: f64,
|
| 83 |
-
/// desvio-padrão médio por dimensão das incorporações (monitor de
|
| 84 |
-
/// colapso: → 0 = colapso).
|
| 85 |
-
pub std_emb_final: f64,
|
| 86 |
-
pub std_emb_inicial: f64,
|
| 87 |
-
pub n_patches: usize,
|
| 88 |
-
pub d_patch: usize,
|
| 89 |
-
pub epocas: usize,
|
| 90 |
-
}
|
| 91 |
-
|
| 92 |
-
/// Treina uma variante JEPA sobre patches já extraídos `(n, d_patch)` com
|
| 93 |
-
/// um esquema de máscara fornecido (padrão: intervalos 1D).
|
| 94 |
-
///
|
| 95 |
-
/// Máscara=true ⇒ patch é ALVO (bloco); false ⇒ CONTEXTO.
|
| 96 |
-
pub fn treinar_variante(
|
| 97 |
-
patches: &Tensor,
|
| 98 |
-
mascara: &dyn Fn(usize, &mut RngDeterministico) -> Vec<bool>,
|
| 99 |
-
cfg: &CfgJepa,
|
| 100 |
-
variante: VarianteJepa,
|
| 101 |
-
cond: Option<&Tensor>,
|
| 102 |
-
dev: &Device,
|
| 103 |
-
) -> Result<RelatorioJepa> {
|
| 104 |
-
let n = patches.dim(0)?;
|
| 105 |
-
let d_patch = patches.dim(1)?;
|
| 106 |
-
let mut rng = RngDeterministico::novo(cfg.semente);
|
| 107 |
-
let mut nucleo = NucleoJepa::novo(
|
| 108 |
-
d_patch,
|
| 109 |
-
cfg.d_emb,
|
| 110 |
-
if cond.is_some() { cond.unwrap().dim(1)? } else { 0 },
|
| 111 |
-
n,
|
| 112 |
-
cfg.m,
|
| 113 |
-
cfg.lambda_vc,
|
| 114 |
-
cfg.gamma_vc,
|
| 115 |
-
dev,
|
| 116 |
-
)?;
|
| 117 |
-
let otimo_vars = nucleo.vars();
|
| 118 |
-
let mut otimizador = crate::treino::AdamWManual::novo(otimo_vars, cfg.lr, 0.01);
|
| 119 |
-
|
| 120 |
-
// métricas iniciais
|
| 121 |
-
let z0 = nucleo.codificar(patches)?;
|
| 122 |
-
let std0 = std_por_dim(&z0)?;
|
| 123 |
-
|
| 124 |
-
let mut perda_inicial = f64::NAN;
|
| 125 |
-
let mut perda_final = f64::NAN;
|
| 126 |
-
let mut pred_inicial = f64::NAN;
|
| 127 |
-
let mut pred_final = f64::NAN;
|
| 128 |
-
let mut vc_final = f64::NAN;
|
| 129 |
-
for epoca in 0..cfg.epocas {
|
| 130 |
-
// máscara fresca a cada época (com proteção contra máscara degenerada:
|
| 131 |
-
// se contexto ou alvo ficar vazio, repete com fração menor — a época
|
| 132 |
-
// NUNCA é pulada, a perda sempre é computada)
|
| 133 |
-
let (ctx_idx, blocos) = loop {
|
| 134 |
-
let mut masc = mascara(n, &mut rng);
|
| 135 |
-
// defensivo: máscara menor que n => o resto é contexto
|
| 136 |
-
if masc.len() < n {
|
| 137 |
-
masc.resize(n, false);
|
| 138 |
-
}
|
| 139 |
-
masc.truncate(n);
|
| 140 |
-
let ctx: Vec<u32> = (0..n).filter(|&i| !masc[i]).map(|i| i as u32).collect();
|
| 141 |
-
let alvos: Vec<usize> = (0..n).filter(|&i| masc[i]).collect();
|
| 142 |
-
if !ctx.is_empty() && !alvos.is_empty() {
|
| 143 |
-
break (ctx, alvos);
|
| 144 |
-
}
|
| 145 |
-
};
|
| 146 |
-
// agrupa alvos em blocos de tam_bloco
|
| 147 |
-
let grupos: Vec<Vec<usize>> = blocos
|
| 148 |
-
.chunks(cfg.tam_bloco.max(1))
|
| 149 |
-
.map(|c| c.to_vec())
|
| 150 |
-
.collect();
|
| 151 |
-
if ctx_idx.is_empty() || grupos.is_empty() {
|
| 152 |
-
continue;
|
| 153 |
-
}
|
| 154 |
-
let dev2 = patches.device();
|
| 155 |
-
let n_ctx = ctx_idx.len();
|
| 156 |
-
let idx_t = Tensor::from_vec(ctx_idx, (n_ctx,), &dev2)?;
|
| 157 |
-
let ctx_patches = patches.index_select(&idx_t, 0)?;
|
| 158 |
-
let z_ctx_todos = nucleo.codificar(&ctx_patches)?; // (n_ctx, d_emb)
|
| 159 |
-
let z_ctx = z_ctx_todos.mean_keepdim(0)?; // (1, d_emb)
|
| 160 |
-
// alvos por grupo
|
| 161 |
-
let mut alvos: Vec<Vec<(usize, Tensor)>> = Vec::new();
|
| 162 |
-
for g in &grupos {
|
| 163 |
-
let idx: Vec<u32> = g.iter().map(|&i| i as u32).collect();
|
| 164 |
-
let n_g = idx.len();
|
| 165 |
-
let it = Tensor::from_vec(idx, (n_g,), &dev2)?;
|
| 166 |
-
alvos.push(vec![(g[0], patches.index_select(&it, 0)?)]);
|
| 167 |
-
}
|
| 168 |
-
// condição por amostra — broadcast (o lote é 1 aqui: o conjunto todo)
|
| 169 |
-
let (perda, lp, lv) = nucleo.perda_lote(&z_ctx, &[alvos_concat(&alvos)], cond, &z_ctx_todos)?;
|
| 170 |
-
let p = perda.to_scalar::<f32>()? as f64;
|
| 171 |
-
if p.is_finite() {
|
| 172 |
-
if epoca == 0 {
|
| 173 |
-
perda_inicial = p;
|
| 174 |
-
pred_inicial = lp;
|
| 175 |
-
}
|
| 176 |
-
perda_final = p;
|
| 177 |
-
pred_final = lp;
|
| 178 |
-
vc_final = lv;
|
| 179 |
-
}
|
| 180 |
-
// decaimento cosseno do lr + clipping de gradiente (estabilidade)
|
| 181 |
-
let frac = epoca as f64 / cfg.epocas.max(1) as f64;
|
| 182 |
-
let lr_t = cfg.lr * 0.5 * (1.0 + (std::f64::consts::PI * frac).cos());
|
| 183 |
-
otimizador.set_lr(lr_t);
|
| 184 |
-
let mut grads = crate::treino::grads_achatados(&perda, &nucleo.vars())?;
|
| 185 |
-
crate::treino::AdamWManual::clipar(&mut grads, 1.0);
|
| 186 |
-
otimizador.passo(grads);
|
| 187 |
-
nucleo.ema_passo()?;
|
| 188 |
-
}
|
| 189 |
-
let z1 = nucleo.codificar(patches)?;
|
| 190 |
-
let std1 = std_por_dim(&z1)?;
|
| 191 |
-
let _ = (pred_inicial, vc_final);
|
| 192 |
-
Ok(RelatorioJepa {
|
| 193 |
-
variante: variante.nome().to_string(),
|
| 194 |
-
perda_inicial,
|
| 195 |
-
perda_final,
|
| 196 |
-
perda_pred_inicial: pred_inicial,
|
| 197 |
-
perda_pred_final: pred_final,
|
| 198 |
-
std_emb_final: std1,
|
| 199 |
-
std_emb_inicial: std0,
|
| 200 |
-
n_patches: n,
|
| 201 |
-
d_patch,
|
| 202 |
-
epocas: cfg.epocas,
|
| 203 |
-
})
|
| 204 |
-
}
|
| 205 |
-
|
| 206 |
-
fn alvos_concat(alvos: &[Vec<(usize, Tensor)>]) -> Vec<(usize, Tensor)> {
|
| 207 |
-
alvos.iter().flatten().cloned().collect()
|
| 208 |
-
}
|
| 209 |
-
|
| 210 |
-
fn std_por_dim(z: &Tensor) -> Result<f64> {
|
| 211 |
-
let n = z.dim(0)? as f64;
|
| 212 |
-
let media = z.mean_keepdim(0)?;
|
| 213 |
-
let centr = z.broadcast_sub(&media)?;
|
| 214 |
-
let var = (centr.sqr()?.sum(0)? / n)?;
|
| 215 |
-
Ok(var.sqrt()?.mean_all()?.to_scalar::<f32>()? as f64)
|
| 216 |
-
}
|
| 217 |
-
|
| 218 |
-
|
| 219 |
-
// ---------------------------------------------------------------------------
|
| 220 |
-
// Variantes especiais: LeJEPA (edição-condicionado), MC-JEPA (cruz-modal),
|
| 221 |
-
// BJEPA (bidirecional com consistência de ciclo)
|
| 222 |
-
// ---------------------------------------------------------------------------
|
| 223 |
-
|
| 224 |
-
/// **LeJEPA** — predição latente condicionada por EDIÇÃO: contexto = E(x),
|
| 225 |
-
/// condição = instrução de edição `e` (vetor de baixa dimensão), alvo =
|
| 226 |
-
/// `E_ξ(edit_e(x))`. A condição é a INSTRUÇÃO (não o resultado — sem
|
| 227 |
-
/// vazamento: `e` não contém `edit(x)`).
|
| 228 |
-
pub fn treinar_lejepa(
|
| 229 |
-
dados: &Tensor, // (n, d_patch) — originais
|
| 230 |
-
edits: &Tensor, // (n, d_cond) — instruções de edição
|
| 231 |
-
editados: &Tensor, // (n, d_patch) — resultados das edições
|
| 232 |
-
cfg: &CfgJepa,
|
| 233 |
-
dev: &Device,
|
| 234 |
-
) -> Result<RelatorioJepa> {
|
| 235 |
-
let n = dados.dim(0)?;
|
| 236 |
-
let d_patch = dados.dim(1)?;
|
| 237 |
-
let d_cond = edits.dim(1)?;
|
| 238 |
-
let mut rng = RngDeterministico::novo(cfg.semente);
|
| 239 |
-
let mut nucleo = NucleoJepa::novo(
|
| 240 |
-
d_patch, cfg.d_emb, d_cond, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, dev,
|
| 241 |
-
)?;
|
| 242 |
-
let mut otim = crate::treino::AdamWManual::novo(nucleo.vars(), cfg.lr, 0.01);
|
| 243 |
-
let mut perda_inicial = f64::NAN;
|
| 244 |
-
let mut perda_final = f64::NAN;
|
| 245 |
-
let z0 = nucleo.codificar(dados)?;
|
| 246 |
-
let std0 = std_por_dim(&z0)?;
|
| 247 |
-
for epoca in 0..cfg.epocas {
|
| 248 |
-
// subamostra do lote
|
| 249 |
-
let idx = rng.amostra_k_de_n(n.min(64), n);
|
| 250 |
-
let sel: Vec<u32> = idx.iter().map(|&i| i as u32).collect();
|
| 251 |
-
let it = Tensor::from_vec(sel.clone(), (sel.len(),), dev)?;
|
| 252 |
-
let xb = dados.index_select(&it, 0)?;
|
| 253 |
-
let eb = edits.index_select(&it, 0)?;
|
| 254 |
-
let yb = editados.index_select(&it, 0)?;
|
| 255 |
-
let z_ctx = nucleo.codificar(&xb)?; // (m, d_emb)
|
| 256 |
-
let mut perdas: Vec<Tensor> = Vec::new();
|
| 257 |
-
for i in 0..xb.dim(0)? {
|
| 258 |
-
let zc = z_ctx.get(i)?.broadcast_as((1, cfg.d_emb))?;
|
| 259 |
-
let e_i = eb.get(i)?.broadcast_as((1, d_cond))?;
|
| 260 |
-
let yt = yb.get(i)?.broadcast_as((1, d_patch))?;
|
| 261 |
-
let zt = nucleo
|
| 262 |
-
.alvo_codificar(&yt)?
|
| 263 |
-
.mean(0)?
|
| 264 |
-
.broadcast_as((1, cfg.d_emb))?;
|
| 265 |
-
let pred = nucleo.predizer(&zc, 0, Some(&e_i))?;
|
| 266 |
-
let dif = (&pred - &zt)?;
|
| 267 |
-
perdas.push((dif.sqr()?.sum_all()? / cfg.d_emb as f64)?);
|
| 268 |
-
}
|
| 269 |
-
let l_pred = (Tensor::stack(&perdas, 0)?.sum_all()? / perdas.len() as f64)?;
|
| 270 |
-
let l_vc = nucleo.perda_vc(&z_ctx)?;
|
| 271 |
-
let total = (l_pred.affine(1.0, 0.0)? + l_vc.affine(cfg.lambda_vc, 0.0)?)?;
|
| 272 |
-
let p = total.to_scalar::<f32>()? as f64;
|
| 273 |
-
if p.is_finite() {
|
| 274 |
-
if epoca == 0 {
|
| 275 |
-
perda_inicial = p;
|
| 276 |
-
}
|
| 277 |
-
perda_final = p;
|
| 278 |
-
}
|
| 279 |
-
let mut grads = crate::treino::grads_achatados(&total, &nucleo.vars())?;
|
| 280 |
-
crate::treino::AdamWManual::clipar(&mut grads, 1.0);
|
| 281 |
-
otim.passo(grads);
|
| 282 |
-
nucleo.ema_passo()?;
|
| 283 |
-
}
|
| 284 |
-
let z1 = nucleo.codificar(dados)?;
|
| 285 |
-
Ok(RelatorioJepa {
|
| 286 |
-
variante: "LeJEPA".into(),
|
| 287 |
-
perda_inicial,
|
| 288 |
-
perda_final,
|
| 289 |
-
perda_pred_inicial: perda_inicial,
|
| 290 |
-
perda_pred_final: perda_final,
|
| 291 |
-
std_emb_final: std_por_dim(&z1)?,
|
| 292 |
-
std_emb_inicial: std0,
|
| 293 |
-
n_patches: n,
|
| 294 |
-
d_patch,
|
| 295 |
-
epocas: cfg.epocas,
|
| 296 |
-
})
|
| 297 |
-
}
|
| 298 |
-
|
| 299 |
-
/// **MC-JEPA** — cruz-modal: dois codificadores, predição nos DOIS sentidos
|
| 300 |
-
/// (A→B e B→A) com preditores separados e alvos EMA dos dois lados.
|
| 301 |
-
pub fn treinar_mcjepa(
|
| 302 |
-
mod_a: &Tensor, // (n, d_a)
|
| 303 |
-
mod_b: &Tensor, // (n, d_b)
|
| 304 |
-
cfg: &CfgJepa,
|
| 305 |
-
dev: &Device,
|
| 306 |
-
) -> Result<RelatorioJepa> {
|
| 307 |
-
let n = mod_a.dim(0)?;
|
| 308 |
-
let d_a = mod_a.dim(1)?;
|
| 309 |
-
let d_b = mod_b.dim(1)?;
|
| 310 |
-
// núcleo A→B e núcleo B→A (compartilham apenas a estrutura)
|
| 311 |
-
let mut nb = NucleoJepa::novo(d_a, cfg.d_emb, 0, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, dev)?;
|
| 312 |
-
let mut na = NucleoJepa::novo(d_b, cfg.d_emb, 0, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, dev)?;
|
| 313 |
-
let mut otim = crate::treino::AdamWManual::novo(
|
| 314 |
-
[nb.vars(), na.vars()].concat(),
|
| 315 |
-
cfg.lr,
|
| 316 |
-
0.01,
|
| 317 |
-
);
|
| 318 |
-
let mut rng = RngDeterministico::novo(cfg.semente);
|
| 319 |
-
let mut perda_inicial = f64::NAN;
|
| 320 |
-
let mut perda_final = f64::NAN;
|
| 321 |
-
for epoca in 0..cfg.epocas {
|
| 322 |
-
let idx = rng.amostra_k_de_n(n.min(64), n);
|
| 323 |
-
let sel: Vec<u32> = idx.iter().map(|&i| i as u32).collect();
|
| 324 |
-
let it = Tensor::from_vec(sel, (idx.len(),), dev)?;
|
| 325 |
-
let xa = mod_a.index_select(&it, 0)?;
|
| 326 |
-
let xb = mod_b.index_select(&it, 0)?;
|
| 327 |
-
// z_a = E_a(x_a) prevê ẑ_b; z_b = E_b(x_b) prevê ẑ_a
|
| 328 |
-
let z_a = nb.codificar(&xa)?; // (m, d_emb)
|
| 329 |
-
let z_b = na.codificar(&xb)?;
|
| 330 |
-
let t_a = na.alvo_codificar(&xa)?; // alvo EMA do lado A
|
| 331 |
-
let t_b = nb.alvo_codificar(&xb)?; // alvo EMA do lado B
|
| 332 |
-
let m_ = xa.dim(0)?;
|
| 333 |
-
let mut perdas: Vec<Tensor> = Vec::new();
|
| 334 |
-
for i in 0..m_ {
|
| 335 |
-
// A → B
|
| 336 |
-
let zc = z_a.get(i)?.broadcast_as((1, cfg.d_emb))?;
|
| 337 |
-
let zt = t_b.get(i)?.broadcast_as((1, cfg.d_emb))?;
|
| 338 |
-
let pred = nb.predizer(&zc, 0, None)?;
|
| 339 |
-
let dif = (&pred - &zt)?;
|
| 340 |
-
perdas.push((dif.sqr()?.sum_all()? / cfg.d_emb as f64)?);
|
| 341 |
-
// B → A
|
| 342 |
-
let zc2 = z_b.get(i)?.broadcast_as((1, cfg.d_emb))?;
|
| 343 |
-
let zt2 = t_a.get(i)?.broadcast_as((1, cfg.d_emb))?;
|
| 344 |
-
let pred2 = na.predizer(&zc2, 0, None)?;
|
| 345 |
-
let dif2 = (&pred2 - &zt2)?;
|
| 346 |
-
perdas.push((dif2.sqr()?.sum_all()? / cfg.d_emb as f64)?);
|
| 347 |
-
}
|
| 348 |
-
let l_pred = (Tensor::stack(&perdas, 0)?.sum_all()? / perdas.len() as f64)?;
|
| 349 |
-
let l_vc = (nb.perda_vc(&z_a)? + na.perda_vc(&z_b)?)?;
|
| 350 |
-
let total = (l_pred.affine(1.0, 0.0)? + l_vc.affine(cfg.lambda_vc, 0.0)?)?;
|
| 351 |
-
let p = total.to_scalar::<f32>()? as f64;
|
| 352 |
-
if p.is_finite() {
|
| 353 |
-
if epoca == 0 {
|
| 354 |
-
perda_inicial = p;
|
| 355 |
-
}
|
| 356 |
-
perda_final = p;
|
| 357 |
-
}
|
| 358 |
-
let mut grads = crate::treino::grads_achatados(&total, &[nb.vars(), na.vars()].concat())?;
|
| 359 |
-
crate::treino::AdamWManual::clipar(&mut grads, 1.0);
|
| 360 |
-
otim.passo(grads);
|
| 361 |
-
nb.ema_passo()?;
|
| 362 |
-
na.ema_passo()?;
|
| 363 |
-
}
|
| 364 |
-
let z1 = nb.codificar(mod_a)?;
|
| 365 |
-
Ok(RelatorioJepa {
|
| 366 |
-
variante: "MC-JEPA".into(),
|
| 367 |
-
perda_inicial,
|
| 368 |
-
perda_final,
|
| 369 |
-
perda_pred_inicial: perda_inicial,
|
| 370 |
-
perda_pred_final: perda_final,
|
| 371 |
-
std_emb_final: std_por_dim(&z1)?,
|
| 372 |
-
std_emb_inicial: std_por_dim(&nb.codificar(mod_a)?)?,
|
| 373 |
-
n_patches: n,
|
| 374 |
-
d_patch: d_a.max(d_b),
|
| 375 |
-
epocas: cfg.epocas,
|
| 376 |
-
})
|
| 377 |
-
}
|
| 378 |
-
|
| 379 |
-
/// **BJEPA** — bidirecional: preditor causal (z_t → z̃_{t+1}), anti-causal
|
| 380 |
-
/// (z_{t+1} → z̃_t) e consistência de ciclo
|
| 381 |
-
/// `‖P_b(P_f(z_t)) − sg(z_t)‖²` — a volta deve reconstruir o presente.
|
| 382 |
-
pub fn treinar_bjepa(patches: &Tensor, cfg: &CfgJepa, dev: &Device) -> Result<RelatorioJepa> {
|
| 383 |
-
let n = patches.dim(0)?;
|
| 384 |
-
let d_patch = patches.dim(1)?;
|
| 385 |
-
let mut nucleo = NucleoJepa::novo(
|
| 386 |
-
d_patch, cfg.d_emb, 0, 2, cfg.m, cfg.lambda_vc, cfg.gamma_vc, dev,
|
| 387 |
-
)?;
|
| 388 |
-
// preditor anti-causal: núcleo separado
|
| 389 |
-
let mut ninv = NucleoJepa::novo(
|
| 390 |
-
d_patch, cfg.d_emb, 0, 2, cfg.m, cfg.lambda_vc, cfg.gamma_vc, dev,
|
| 391 |
-
)?;
|
| 392 |
-
let mut otim =
|
| 393 |
-
crate::treino::AdamWManual::novo([nucleo.vars(), ninv.vars()].concat(), cfg.lr, 0.01);
|
| 394 |
-
let mut perda_inicial = f64::NAN;
|
| 395 |
-
let mut perda_final = f64::NAN;
|
| 396 |
-
for epoca in 0..cfg.epocas {
|
| 397 |
-
let z = nucleo.codificar(patches)?; // (n, d_emb)
|
| 398 |
-
let zt = nucleo.alvo_codificar(patches)?; // alvos EMA (stop-grad)
|
| 399 |
-
let mut perdas: Vec<Tensor> = Vec::new();
|
| 400 |
-
for t in 0..n.saturating_sub(1) {
|
| 401 |
-
let zc = z.get(t)?.broadcast_as((1, cfg.d_emb))?;
|
| 402 |
-
let z_prox = zt.get(t + 1)?.broadcast_as((1, cfg.d_emb))?;
|
| 403 |
-
// causal: z_t → z̃_{t+1} (pos 0 = "próximo")
|
| 404 |
-
let pf = nucleo.predizer(&zc, 0, None)?;
|
| 405 |
-
let dif = (&pf - &z_prox)?;
|
| 406 |
-
perdas.push((dif.sqr()?.sum_all()? / cfg.d_emb as f64)?);
|
| 407 |
-
// anti-causal: z_{t+1} → z̃_t (pos 1 = "anterior")
|
| 408 |
-
let zb = z.get(t + 1)?.broadcast_as((1, cfg.d_emb))?;
|
| 409 |
-
let z_ant = zt.get(t)?.broadcast_as((1, cfg.d_emb))?;
|
| 410 |
-
let pb = ninv.predizer(&zb, 1, None)?;
|
| 411 |
-
let dif2 = (&pb - &z_ant)?;
|
| 412 |
-
perdas.push((dif2.sqr()?.sum_all()? / cfg.d_emb as f64)?);
|
| 413 |
-
// ciclo: P_b(P_f(z_t)) ≈ sg(z_t)
|
| 414 |
-
let pf_sg = nucleo.predizer(&zc, 0, None)?.detach();
|
| 415 |
-
let pciclo = ninv.predizer(&pf_sg.broadcast_as((1, cfg.d_emb))?, 1, None)?;
|
| 416 |
-
let zt_sg = zt.get(t)?.broadcast_as((1, cfg.d_emb))?;
|
| 417 |
-
let dif3 = (&pciclo - &zt_sg)?;
|
| 418 |
-
perdas.push((dif3.sqr()?.sum_all()? / cfg.d_emb as f64)?);
|
| 419 |
-
}
|
| 420 |
-
let l_pred = (Tensor::stack(&perdas, 0)?.sum_all()? / perdas.len().max(1) as f64)?;
|
| 421 |
-
let l_vc = nucleo.perda_vc(&z)?;
|
| 422 |
-
let total = (l_pred.affine(1.0, 0.0)? + l_vc.affine(cfg.lambda_vc, 0.0)?)?;
|
| 423 |
-
let p = total.to_scalar::<f32>()? as f64;
|
| 424 |
-
if p.is_finite() {
|
| 425 |
-
if epoca == 0 {
|
| 426 |
-
perda_inicial = p;
|
| 427 |
-
}
|
| 428 |
-
perda_final = p;
|
| 429 |
-
}
|
| 430 |
-
let mut grads = crate::treino::grads_achatados(&total, &[nucleo.vars(), ninv.vars()].concat())?;
|
| 431 |
-
crate::treino::AdamWManual::clipar(&mut grads, 1.0);
|
| 432 |
-
otim.passo(grads);
|
| 433 |
-
nucleo.ema_passo()?;
|
| 434 |
-
ninv.ema_passo()?;
|
| 435 |
-
}
|
| 436 |
-
let z1 = nucleo.codificar(patches)?;
|
| 437 |
-
Ok(RelatorioJepa {
|
| 438 |
-
variante: "BJEPA".into(),
|
| 439 |
-
perda_inicial,
|
| 440 |
-
perda_final,
|
| 441 |
-
perda_pred_inicial: perda_inicial,
|
| 442 |
-
perda_pred_final: perda_final,
|
| 443 |
-
std_emb_final: std_por_dim(&z1)?,
|
| 444 |
-
std_emb_inicial: std_por_dim(&nucleo.codificar(patches)?)?,
|
| 445 |
-
n_patches: n,
|
| 446 |
-
d_patch,
|
| 447 |
-
epocas: cfg.epocas,
|
| 448 |
-
})
|
| 449 |
-
}
|
| 450 |
-
|
| 451 |
-
/// Esquema de máscara por variante a partir da grade de patches.
|
| 452 |
-
pub fn mascara_por_variante(
|
| 453 |
-
variante: VarianteJepa,
|
| 454 |
-
grid: &[usize],
|
| 455 |
-
frac: f64,
|
| 456 |
-
rng: &mut RngDeterministico,
|
| 457 |
-
) -> Vec<bool> {
|
| 458 |
-
match variante {
|
| 459 |
-
VarianteJepa::ImageJepa => mascara_blocos_2d(grid[0], grid.get(1).copied().unwrap_or(1), 4, frac, rng),
|
| 460 |
-
VarianteJepa::VJepa2 | VarianteJepa::Jepa3D => mascara_tubos_3d(
|
| 461 |
-
grid[0],
|
| 462 |
-
grid.get(1).copied().unwrap_or(1),
|
| 463 |
-
grid.get(2).copied().unwrap_or(1),
|
| 464 |
-
3,
|
| 465 |
-
frac,
|
| 466 |
-
rng,
|
| 467 |
-
),
|
| 468 |
-
VarianteJepa::AudioJepa => mascara_bandas(grid[0], grid.get(1).copied().unwrap_or(1), 3, frac, rng),
|
| 469 |
-
VarianteJepa::BrainJepa => mascara_segmentos(grid[0], grid.get(1).copied().unwrap_or(1), frac, rng),
|
| 470 |
-
_ => mascara_intervalos_1d(grid.iter().product::<usize>().max(1), frac, rng),
|
| 471 |
-
}
|
| 472 |
-
}
|
| 473 |
-
|
| 474 |
-
pub fn versao() -> &'static str {
|
| 475 |
-
"jepa-0.5.0"
|
| 476 |
-
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/lib.rs
CHANGED
|
@@ -9,9 +9,11 @@ use pyo3::prelude::*;
|
|
| 9 |
|
| 10 |
pub mod amostrador;
|
| 11 |
pub mod arvore_pesos;
|
|
|
|
| 12 |
pub mod atencao;
|
| 13 |
pub mod acoplador;
|
| 14 |
pub mod camadas;
|
|
|
|
| 15 |
pub mod config;
|
| 16 |
pub mod controlador;
|
| 17 |
pub mod diagnostico;
|
|
@@ -29,11 +31,13 @@ pub mod nlp;
|
|
| 29 |
pub mod pensamento;
|
| 30 |
pub mod quantizacao;
|
| 31 |
pub mod quantizador;
|
|
|
|
| 32 |
pub mod som4d;
|
| 33 |
pub mod simd;
|
| 34 |
pub mod ssd;
|
| 35 |
pub mod stiefel;
|
| 36 |
pub mod telemetria;
|
|
|
|
| 37 |
pub mod tokens;
|
| 38 |
pub mod tokenizador;
|
| 39 |
pub mod treino;
|
|
@@ -46,7 +50,42 @@ pub mod build_info {
|
|
| 46 |
|
| 47 |
#[pyfunction]
|
| 48 |
fn versao() -> &'static str {
|
| 49 |
-
"khtst-rust-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 50 |
}
|
| 51 |
|
| 52 |
#[pyfunction]
|
|
@@ -92,8 +131,22 @@ impl BpePy {
|
|
| 92 |
|
| 93 |
#[staticmethod]
|
| 94 |
fn carregar(caminho: &str) -> PyResult<Self> {
|
| 95 |
-
|
| 96 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 97 |
let v: serde_json::Value = serde_json::from_str(&txt)
|
| 98 |
.map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("JSON inválido: {e}")))?;
|
| 99 |
let bpe = tokens::Bpe::de_json(&v)
|
|
@@ -110,7 +163,11 @@ impl BpePy {
|
|
| 110 |
}
|
| 111 |
|
| 112 |
fn salvar(&self, caminho: &str) -> PyResult<()> {
|
| 113 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 114 |
.map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?;
|
| 115 |
Ok(())
|
| 116 |
}
|
|
@@ -262,6 +319,9 @@ fn treinar_fase_a(
|
|
| 262 |
"perplexidade_codebook": resumo.perplexidade_codebook,
|
| 263 |
"monotonia_prefixo": resumo.monotonia_prefixo,
|
| 264 |
"escore_aprendizado": resumo.escore_aprendizado,
|
|
|
|
|
|
|
|
|
|
| 265 |
},
|
| 266 |
"telemetria": hub.dump(),
|
| 267 |
});
|
|
@@ -317,6 +377,8 @@ fn treinar_fase_a_np(
|
|
| 317 |
"perplexidade_codebook": resumo.perplexidade_codebook,
|
| 318 |
"monotonia_prefixo": resumo.monotonia_prefixo,
|
| 319 |
"escore_aprendizado": resumo.escore_aprendizado,
|
|
|
|
|
|
|
| 320 |
},
|
| 321 |
"telemetria": hub.dump(),
|
| 322 |
"entrada": "numpy",
|
|
@@ -353,6 +415,8 @@ fn treinar_fase_b_np(
|
|
| 353 |
"passos": resumo.passos, "perda_inicial": resumo.perda_inicial,
|
| 354 |
"perda_final": resumo.perda_final, "acc_conceitos": resumo.acc_recon,
|
| 355 |
"escore_aprendizado": resumo.escore_aprendizado,
|
|
|
|
|
|
|
| 356 |
},
|
| 357 |
"telemetria": hub.dump(),
|
| 358 |
"entrada": "numpy",
|
|
@@ -516,6 +580,18 @@ fn treinar_jepa_adaptativa(
|
|
| 516 |
frac_mascara: if j.frac_mascara > 0.0 { j.frac_mascara } else { 0.35 },
|
| 517 |
semente: if j.semente > 0 { j.semente } else { 42 },
|
| 518 |
tam_bloco: 2,
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 519 |
};
|
| 520 |
let var = match variante.as_str() {
|
| 521 |
"image" => jepa::VarianteJepa::ImageJepa,
|
|
@@ -584,6 +660,8 @@ fn treinar_fase_b(
|
|
| 584 |
"passos": resumo.passos, "perda_inicial": resumo.perda_inicial,
|
| 585 |
"perda_final": resumo.perda_final, "acc_conceitos": resumo.acc_recon,
|
| 586 |
"escore_aprendizado": resumo.escore_aprendizado,
|
|
|
|
|
|
|
| 587 |
},
|
| 588 |
"telemetria": hub.dump(),
|
| 589 |
});
|
|
@@ -732,6 +810,12 @@ struct CfgSom4DJ {
|
|
| 732 |
eta0: f64, eta1: f64,
|
| 733 |
semente: u64,
|
| 734 |
espalhada: bool,
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 735 |
}
|
| 736 |
|
| 737 |
#[derive(serde::Deserialize, Default, Debug)]
|
|
@@ -759,6 +843,10 @@ struct CfgJepaJ {
|
|
| 759 |
gamma_vc: f64,
|
| 760 |
frac_mascara: f64,
|
| 761 |
semente: u64,
|
|
|
|
|
|
|
|
|
|
|
|
|
| 762 |
}
|
| 763 |
|
| 764 |
/// Faz o parse tipado; JSON inválido/erro de tipo vira PyValueError (antes:
|
|
@@ -794,18 +882,47 @@ fn treinar_som4d(py: Python, dados: Vec<Vec<f64>>, cfg: Option<String>) -> PyRes
|
|
| 794 |
} else {
|
| 795 |
som4d::Inicializacao4D::Dados
|
| 796 |
},
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 797 |
..Default::default()
|
| 798 |
};
|
| 799 |
let som = som4d::treinar_som4d(&t, &c, &dev)
|
| 800 |
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 801 |
let d = serde_json::json!({
|
| 802 |
"versao": som4d::versao(),
|
| 803 |
"celulas": som.n_celulas(),
|
| 804 |
"grade": [som.nx, som.ny, som.nz, som.nt],
|
| 805 |
"eq_inicial": som.eq_inicial,
|
| 806 |
"eq_final": som.eq_final,
|
|
|
|
| 807 |
"te_final": som.te_final,
|
| 808 |
"historico_eq_te": som.historia,
|
|
|
|
|
|
|
| 809 |
"massa_soma": som.massa.iter().sum::<f64>(),
|
| 810 |
});
|
| 811 |
Ok(pythonize::pythonize(py, &d)?.into())
|
|
@@ -887,6 +1004,10 @@ fn treinar_hsom(py: Python, dados: Vec<Vec<f64>>, cfg: Option<String>) -> PyResu
|
|
| 887 |
if let Some(x) = o.get("epocas_finas") {
|
| 888 |
c.epocas_finas = x.as_u64().unwrap_or(20) as usize;
|
| 889 |
}
|
|
|
|
|
|
|
|
|
|
|
|
|
| 890 |
}
|
| 891 |
}
|
| 892 |
}
|
|
@@ -913,6 +1034,7 @@ fn demo_tsom(py: Python, dados_iniciais: Vec<Vec<f64>>, janela: Vec<Vec<f64>>, p
|
|
| 913 |
cfg_grade: som4d::CfgSom4D { nx: 3, ny: 3, nz: 2, nt: 2, epocas: 15, ..Default::default() },
|
| 914 |
gamma,
|
| 915 |
janela: janela.len(),
|
|
|
|
| 916 |
};
|
| 917 |
let mut ts = som4d::TSom4D::novo(&t0, &cfg, &dev)
|
| 918 |
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
|
@@ -938,6 +1060,16 @@ fn treinar_jepa(py: Python, dados: Vec<Vec<f64>>, grid: Vec<usize>, variante: St
|
|
| 938 |
let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 939 |
// v0.9.0: parse tipado — defaults idênticos aos da v0.8.0
|
| 940 |
let j: CfgJepaJ = parse_cfg_tipado(&cfg)?;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 941 |
let c = jepa::CfgJepa {
|
| 942 |
d_emb: if j.d_emb > 0 { j.d_emb } else { 32 },
|
| 943 |
epocas: if j.epocas > 0 { j.epocas } else { 60 },
|
|
@@ -948,6 +1080,9 @@ fn treinar_jepa(py: Python, dados: Vec<Vec<f64>>, grid: Vec<usize>, variante: St
|
|
| 948 |
frac_mascara: if j.frac_mascara > 0.0 { j.frac_mascara } else { 0.35 },
|
| 949 |
semente: if j.semente > 0 { j.semente } else { 42 },
|
| 950 |
tam_bloco: 2,
|
|
|
|
|
|
|
|
|
|
| 951 |
};
|
| 952 |
let var = match variante.as_str() {
|
| 953 |
"image" => jepa::VarianteJepa::ImageJepa,
|
|
@@ -1488,6 +1623,7 @@ fn treinar_fase_c(
|
|
| 1488 |
"maior_sobreposicao_us": resumo.maior_sobreposicao_us,
|
| 1489 |
},
|
| 1490 |
"painel_v060": hub.painel_v060(),
|
|
|
|
| 1491 |
"telemetria": hub.dump(),
|
| 1492 |
});
|
| 1493 |
Ok(pythonize::pythonize(py, &dados)?.into())
|
|
@@ -1832,6 +1968,201 @@ fn demo_pensamento_ncm(
|
|
| 1832 |
})
|
| 1833 |
}
|
| 1834 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1835 |
|
| 1836 |
/// **Autoajuste do Pensamento por telemetria (A-1..A-5) — demo:** alimenta
|
| 1837 |
/// o controlador com sinais sintéticos medidos e verifica cada regra.
|
|
@@ -1872,7 +2203,7 @@ fn demo_autoajuste(semente: u64) -> PyResult<PyObject> {
|
|
| 1872 |
u.registrar(braco, r);
|
| 1873 |
}
|
| 1874 |
let medias = u.medias();
|
| 1875 |
-
let melhor = medias.iter().enumerate().max_by(|a, b| a.1.
|
| 1876 |
let d_ = serde_json::json!({
|
| 1877 |
"versao": "autoajuste-0.6.0",
|
| 1878 |
"tau_c_final": tau, "n_tentativas_final": n_ajustado,
|
|
@@ -2515,11 +2846,35 @@ fn demo_qwen_v080(py: Python) -> PyResult<PyObject> {
|
|
| 2515 |
Ok(pythonize::pythonize(py, &d_)?.into())
|
| 2516 |
}
|
| 2517 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 2518 |
#[pymodule]
|
| 2519 |
fn nucleo_rust(m: &Bound<'_, PyModule>) -> PyResult<()> {
|
| 2520 |
pyo3_log::init();
|
| 2521 |
m.add_function(wrap_pyfunction!(versao, m)?)?;
|
| 2522 |
m.add_function(wrap_pyfunction!(info_build, m)?)?;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 2523 |
m.add_function(wrap_pyfunction!(lint_config, m)?)?;
|
| 2524 |
m.add_function(wrap_pyfunction!(treinar_fase_a, m)?)?;
|
| 2525 |
m.add_function(wrap_pyfunction!(treinar_fase_b, m)?)?;
|
|
@@ -2562,6 +2917,7 @@ fn nucleo_rust(m: &Bound<'_, PyModule>) -> PyResult<()> {
|
|
| 2562 |
m.add_function(wrap_pyfunction!(som_com_moe, m)?)?;
|
| 2563 |
m.add_function(wrap_pyfunction!(demo_acoplador_duplo, m)?)?;
|
| 2564 |
m.add_function(wrap_pyfunction!(demo_pensamento_ncm, m)?)?;
|
|
|
|
| 2565 |
m.add_function(wrap_pyfunction!(demo_autoajuste, m)?)?;
|
| 2566 |
m.add_function(wrap_pyfunction!(demo_fnh, m)?)?;
|
| 2567 |
m.add_function(wrap_pyfunction!(demo_quebra_cabeca, m)?)?;
|
|
|
|
| 9 |
|
| 10 |
pub mod amostrador;
|
| 11 |
pub mod arvore_pesos;
|
| 12 |
+
pub mod asm;
|
| 13 |
pub mod atencao;
|
| 14 |
pub mod acoplador;
|
| 15 |
pub mod camadas;
|
| 16 |
+
pub mod checkpoint;
|
| 17 |
pub mod config;
|
| 18 |
pub mod controlador;
|
| 19 |
pub mod diagnostico;
|
|
|
|
| 31 |
pub mod pensamento;
|
| 32 |
pub mod quantizacao;
|
| 33 |
pub mod quantizador;
|
| 34 |
+
pub mod raciocinio_elastico;
|
| 35 |
pub mod som4d;
|
| 36 |
pub mod simd;
|
| 37 |
pub mod ssd;
|
| 38 |
pub mod stiefel;
|
| 39 |
pub mod telemetria;
|
| 40 |
+
pub mod tipos;
|
| 41 |
pub mod tokens;
|
| 42 |
pub mod tokenizador;
|
| 43 |
pub mod treino;
|
|
|
|
| 50 |
|
| 51 |
#[pyfunction]
|
| 52 |
fn versao() -> &'static str {
|
| 53 |
+
concat!("khtst-rust-", env!("CARGO_PKG_VERSION"))
|
| 54 |
+
}
|
| 55 |
+
|
| 56 |
+
/// **v0.11.0 (tratamento.txt):** relatório do módulo de Assembly (kernels
|
| 57 |
+
/// por flags CF/PF/ZF com códigos de erro em registrador → `Result`).
|
| 58 |
+
#[pyfunction]
|
| 59 |
+
fn asm_relatorio() -> String {
|
| 60 |
+
crate::asm::relatorio()
|
| 61 |
+
}
|
| 62 |
+
|
| 63 |
+
/// **v0.11.0 (r-40 V-2′):** relatório de soundness CONDICIONAL ao aceite —
|
| 64 |
+
/// `ece_aceito` (faixas restritas a conf ≥ τ_c), `p_aceite`, cotas limpa e
|
| 65 |
+
/// corrigida, e o erro empírico medido — tudo auditável do Python.
|
| 66 |
+
#[pyfunction]
|
| 67 |
+
fn v2_relatorio_soundness(
|
| 68 |
+
confs: Vec<f64>,
|
| 69 |
+
corretos: Vec<bool>,
|
| 70 |
+
n_faixas: usize,
|
| 71 |
+
tau_c: f64,
|
| 72 |
+
) -> PyResult<PyObject> {
|
| 73 |
+
Python::with_gil(|py| {
|
| 74 |
+
let r = crate::verificador::relatorio_soundness(&confs, &corretos, n_faixas, tau_c)
|
| 75 |
+
.map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("{e}")))?;
|
| 76 |
+
let d_ = serde_json::json!({
|
| 77 |
+
"tau_c": r.tau_c,
|
| 78 |
+
"p_aceite": r.p_aceite,
|
| 79 |
+
"n_aceito": r.n_aceito,
|
| 80 |
+
"ece_aceito": r.ece_aceito,
|
| 81 |
+
"l1_global": r.l1_global,
|
| 82 |
+
"cota_limpa": r.cota_limpa,
|
| 83 |
+
"cota_corrigida": r.cota_corrigida,
|
| 84 |
+
"p_erro_aceito": r.p_erro_aceito,
|
| 85 |
+
"cota_limpa_respeitada": r.cota_limpa_respeitada,
|
| 86 |
+
});
|
| 87 |
+
Ok(pythonize::pythonize(py, &d_)?.into())
|
| 88 |
+
})
|
| 89 |
}
|
| 90 |
|
| 91 |
#[pyfunction]
|
|
|
|
| 131 |
|
| 132 |
#[staticmethod]
|
| 133 |
fn carregar(caminho: &str) -> PyResult<Self> {
|
| 134 |
+
// v0.11.0 (restaurado da v0.10.0): carrega com VERIFICAÇÃO de
|
| 135 |
+
// integridade quando há manifesto (retrocompatível: sem manifesto,
|
| 136 |
+
// leitura simples — checkpoints antigos continuam válidos)
|
| 137 |
+
let txt = match crate::checkpoint::carregar_verificado(caminho) {
|
| 138 |
+
Ok(t) => t,
|
| 139 |
+
Err(e) => {
|
| 140 |
+
// sem manifesto ou corrompido: se o arquivo existe, é
|
| 141 |
+
// legado — ler direto; senão, propagar o erro de I/O
|
| 142 |
+
if !std::path::Path::new(caminho).exists() {
|
| 143 |
+
return Err(pyo3::exceptions::PyIOError::new_err(format!("{e}")));
|
| 144 |
+
}
|
| 145 |
+
log::warn!("carregar: sem manifesto válido ({e}) — lendo legado {caminho}");
|
| 146 |
+
std::fs::read_to_string(caminho)
|
| 147 |
+
.map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?
|
| 148 |
+
}
|
| 149 |
+
};
|
| 150 |
let v: serde_json::Value = serde_json::from_str(&txt)
|
| 151 |
.map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("JSON inválido: {e}")))?;
|
| 152 |
let bpe = tokens::Bpe::de_json(&v)
|
|
|
|
| 163 |
}
|
| 164 |
|
| 165 |
fn salvar(&self, caminho: &str) -> PyResult<()> {
|
| 166 |
+
// v0.11.0 (restaurado da v0.10.0): checkpoint ATÔMICO com manifesto
|
| 167 |
+
// SHA-256 (Teo CP-1/CP-2 — tmp→fsync→rename→fsync(dir))
|
| 168 |
+
let txt = serde_json::to_string(&self.bpe.para_json())
|
| 169 |
+
.map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?;
|
| 170 |
+
crate::checkpoint::salvar_atomico(caminho, &txt)
|
| 171 |
.map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?;
|
| 172 |
Ok(())
|
| 173 |
}
|
|
|
|
| 319 |
"perplexidade_codebook": resumo.perplexidade_codebook,
|
| 320 |
"monotonia_prefixo": resumo.monotonia_prefixo,
|
| 321 |
"escore_aprendizado": resumo.escore_aprendizado,
|
| 322 |
+
"coerencia_welch_max": resumo.coerencia_max,
|
| 323 |
+
"tc_intra_nivel_medio": resumo.tc_intra_nivel_medio,
|
| 324 |
+
"tc_resolucao_nats": resumo.tc_resolucao_nats,
|
| 325 |
},
|
| 326 |
"telemetria": hub.dump(),
|
| 327 |
});
|
|
|
|
| 377 |
"perplexidade_codebook": resumo.perplexidade_codebook,
|
| 378 |
"monotonia_prefixo": resumo.monotonia_prefixo,
|
| 379 |
"escore_aprendizado": resumo.escore_aprendizado,
|
| 380 |
+
"coerencia_welch_max": resumo.coerencia_max,
|
| 381 |
+
"tc_intra_nivel_medio": resumo.tc_intra_nivel_medio,
|
| 382 |
},
|
| 383 |
"telemetria": hub.dump(),
|
| 384 |
"entrada": "numpy",
|
|
|
|
| 415 |
"passos": resumo.passos, "perda_inicial": resumo.perda_inicial,
|
| 416 |
"perda_final": resumo.perda_final, "acc_conceitos": resumo.acc_recon,
|
| 417 |
"escore_aprendizado": resumo.escore_aprendizado,
|
| 418 |
+
"coerencia_welch_max": resumo.coerencia_max,
|
| 419 |
+
"tc_intra_nivel_medio": resumo.tc_intra_nivel_medio,
|
| 420 |
},
|
| 421 |
"telemetria": hub.dump(),
|
| 422 |
"entrada": "numpy",
|
|
|
|
| 580 |
frac_mascara: if j.frac_mascara > 0.0 { j.frac_mascara } else { 0.35 },
|
| 581 |
semente: if j.semente > 0 { j.semente } else { 42 },
|
| 582 |
tam_bloco: 2,
|
| 583 |
+
modo_variancia: match j.modo_variancia.as_deref() {
|
| 584 |
+
None | Some("dobradica") => jepa::ModoVariancia::Dobradica,
|
| 585 |
+
Some("raiz_suavizada") => jepa::ModoVariancia::RaizSuavizada,
|
| 586 |
+
Some("softplus") => jepa::ModoVariancia::Softplus,
|
| 587 |
+
Some(outro) => {
|
| 588 |
+
return Err(pyo3::exceptions::PyValueError::new_err(format!(
|
| 589 |
+
"modo_variancia inválido: {outro} — use \"dobradica\", \"raiz_suavizada\" ou \"softplus\""
|
| 590 |
+
)))
|
| 591 |
+
}
|
| 592 |
+
},
|
| 593 |
+
eps_raiz: if j.eps_raiz > 0.0 { j.eps_raiz } else { 1e-12 },
|
| 594 |
+
k_softplus: if j.k_softplus > 0.0 { j.k_softplus } else { 5.0 },
|
| 595 |
};
|
| 596 |
let var = match variante.as_str() {
|
| 597 |
"image" => jepa::VarianteJepa::ImageJepa,
|
|
|
|
| 660 |
"passos": resumo.passos, "perda_inicial": resumo.perda_inicial,
|
| 661 |
"perda_final": resumo.perda_final, "acc_conceitos": resumo.acc_recon,
|
| 662 |
"escore_aprendizado": resumo.escore_aprendizado,
|
| 663 |
+
"coerencia_welch_max": resumo.coerencia_max,
|
| 664 |
+
"tc_intra_nivel_medio": resumo.tc_intra_nivel_medio,
|
| 665 |
},
|
| 666 |
"telemetria": hub.dump(),
|
| 667 |
});
|
|
|
|
| 810 |
eta0: f64, eta1: f64,
|
| 811 |
semente: u64,
|
| 812 |
espalhada: bool,
|
| 813 |
+
/// v0.10.0 (S4-′1): "media" (padrão) | "mediana_geometrica"
|
| 814 |
+
criterio_lote: Option<String>,
|
| 815 |
+
/// v0.10.0 (S4-′1): "distancia" (padrão) | "quadratico"
|
| 816 |
+
criterio_qe: Option<String>,
|
| 817 |
+
/// v0.10.0: iterações Weiszfeld (modo mediana)
|
| 818 |
+
weiszfeld_iters: usize,
|
| 819 |
}
|
| 820 |
|
| 821 |
#[derive(serde::Deserialize, Default, Debug)]
|
|
|
|
| 843 |
gamma_vc: f64,
|
| 844 |
frac_mascara: f64,
|
| 845 |
semente: u64,
|
| 846 |
+
/// v0.10.0 (J-1′): "dobradica" (padrão) | "raiz_suavizada" | "softplus"
|
| 847 |
+
modo_variancia: Option<String>,
|
| 848 |
+
eps_raiz: f64,
|
| 849 |
+
k_softplus: f64,
|
| 850 |
}
|
| 851 |
|
| 852 |
/// Faz o parse tipado; JSON inválido/erro de tipo vira PyValueError (antes:
|
|
|
|
| 882 |
} else {
|
| 883 |
som4d::Inicializacao4D::Dados
|
| 884 |
},
|
| 885 |
+
criterio_lote: match j.criterio_lote.as_deref() {
|
| 886 |
+
None | Some("media") => som4d::CriterioLote::Media,
|
| 887 |
+
Some("mediana_geometrica") | Some("mediana") => {
|
| 888 |
+
som4d::CriterioLote::MedianaGeometrica
|
| 889 |
+
}
|
| 890 |
+
Some(outro) => {
|
| 891 |
+
return Err(pyo3::exceptions::PyValueError::new_err(format!(
|
| 892 |
+
"criterio_lote inválido: {outro} — use \"media\" ou \"mediana_geometrica\""
|
| 893 |
+
)))
|
| 894 |
+
}
|
| 895 |
+
},
|
| 896 |
+
criterio_qe: match j.criterio_qe.as_deref() {
|
| 897 |
+
None | Some("distancia") => som4d::CriterioQe::Distancia,
|
| 898 |
+
Some("quadratico") => som4d::CriterioQe::Quadratico,
|
| 899 |
+
Some(outro) => {
|
| 900 |
+
return Err(pyo3::exceptions::PyValueError::new_err(format!(
|
| 901 |
+
"criterio_qe inválido: {outro} — use \"distancia\" ou \"quadratico\""
|
| 902 |
+
)))
|
| 903 |
+
}
|
| 904 |
+
},
|
| 905 |
+
weiszfeld_iters: if j.weiszfeld_iters > 0 { j.weiszfeld_iters } else { 8 },
|
| 906 |
..Default::default()
|
| 907 |
};
|
| 908 |
let som = som4d::treinar_som4d(&t, &c, &dev)
|
| 909 |
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 910 |
+
// S4-1′-a: Φ do kernel não-crescente em TODAS as épocas (gate booleano)
|
| 911 |
+
let phi_monotono = som
|
| 912 |
+
.historia_phi
|
| 913 |
+
.iter()
|
| 914 |
+
.all(|(a, d)| *d <= *a + 1e-9);
|
| 915 |
let d = serde_json::json!({
|
| 916 |
"versao": som4d::versao(),
|
| 917 |
"celulas": som.n_celulas(),
|
| 918 |
"grade": [som.nx, som.ny, som.nz, som.nt],
|
| 919 |
"eq_inicial": som.eq_inicial,
|
| 920 |
"eq_final": som.eq_final,
|
| 921 |
+
"eqm_final": som.eqm_final,
|
| 922 |
"te_final": som.te_final,
|
| 923 |
"historico_eq_te": som.historia,
|
| 924 |
+
"phi_monotono": phi_monotono,
|
| 925 |
+
"historico_phi": som.historia_phi,
|
| 926 |
"massa_soma": som.massa.iter().sum::<f64>(),
|
| 927 |
});
|
| 928 |
Ok(pythonize::pythonize(py, &d)?.into())
|
|
|
|
| 1004 |
if let Some(x) = o.get("epocas_finas") {
|
| 1005 |
c.epocas_finas = x.as_u64().unwrap_or(20) as usize;
|
| 1006 |
}
|
| 1007 |
+
// v0.10.0 (H-1′-c): slot fino 0 = cópia permanente de q_c
|
| 1008 |
+
if let Some(x) = o.get("reservar_grosso") {
|
| 1009 |
+
c.reservar_grosso = x.as_bool().unwrap_or(false);
|
| 1010 |
+
}
|
| 1011 |
}
|
| 1012 |
}
|
| 1013 |
}
|
|
|
|
| 1034 |
cfg_grade: som4d::CfgSom4D { nx: 3, ny: 3, nz: 2, nt: 2, epocas: 15, ..Default::default() },
|
| 1035 |
gamma,
|
| 1036 |
janela: janela.len(),
|
| 1037 |
+
eta_rastreio: 0.1, // T-1′: default = comportamento v0.9.0
|
| 1038 |
};
|
| 1039 |
let mut ts = som4d::TSom4D::novo(&t0, &cfg, &dev)
|
| 1040 |
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
|
|
|
| 1060 |
let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 1061 |
// v0.9.0: parse tipado — defaults idênticos aos da v0.8.0
|
| 1062 |
let j: CfgJepaJ = parse_cfg_tipado(&cfg)?;
|
| 1063 |
+
let modo_v = match j.modo_variancia.as_deref() {
|
| 1064 |
+
None | Some("dobradica") => jepa::ModoVariancia::Dobradica,
|
| 1065 |
+
Some("raiz_suavizada") => jepa::ModoVariancia::RaizSuavizada,
|
| 1066 |
+
Some("softplus") => jepa::ModoVariancia::Softplus,
|
| 1067 |
+
Some(outro) => {
|
| 1068 |
+
return Err(pyo3::exceptions::PyValueError::new_err(format!(
|
| 1069 |
+
"modo_variancia inválido: {outro}"
|
| 1070 |
+
)))
|
| 1071 |
+
}
|
| 1072 |
+
};
|
| 1073 |
let c = jepa::CfgJepa {
|
| 1074 |
d_emb: if j.d_emb > 0 { j.d_emb } else { 32 },
|
| 1075 |
epocas: if j.epocas > 0 { j.epocas } else { 60 },
|
|
|
|
| 1080 |
frac_mascara: if j.frac_mascara > 0.0 { j.frac_mascara } else { 0.35 },
|
| 1081 |
semente: if j.semente > 0 { j.semente } else { 42 },
|
| 1082 |
tam_bloco: 2,
|
| 1083 |
+
modo_variancia: modo_v,
|
| 1084 |
+
eps_raiz: if j.eps_raiz > 0.0 { j.eps_raiz } else { 1e-12 },
|
| 1085 |
+
k_softplus: if j.k_softplus > 0.0 { j.k_softplus } else { 5.0 },
|
| 1086 |
};
|
| 1087 |
let var = match variante.as_str() {
|
| 1088 |
"image" => jepa::VarianteJepa::ImageJepa,
|
|
|
|
| 1623 |
"maior_sobreposicao_us": resumo.maior_sobreposicao_us,
|
| 1624 |
},
|
| 1625 |
"painel_v060": hub.painel_v060(),
|
| 1626 |
+
"painel_v100": hub.painel_v100(),
|
| 1627 |
"telemetria": hub.dump(),
|
| 1628 |
});
|
| 1629 |
Ok(pythonize::pythonize(py, &dados)?.into())
|
|
|
|
| 1968 |
})
|
| 1969 |
}
|
| 1970 |
|
| 1971 |
+
/// **Raciocínio elástico (r-42, RE-1..RE-8) — demo:** treina motor +
|
| 1972 |
+
/// cabeça verificadora, roda o ciclo elástico com ênfase Hedge e compressão
|
| 1973 |
+
/// certificada RE-2, e devolve o certificado completo para auditoria.
|
| 1974 |
+
/// v0.11.0: `conds_reais`/`alvos_reais` opcionais permitem AVALIAÇÃO EM
|
| 1975 |
+
/// DADOS REAIS (p.ex. latentes da Wikipédia PT-BR) — sem eles, síntese.
|
| 1976 |
+
#[pyfunction]
|
| 1977 |
+
fn demo_raciocinio_elastico(
|
| 1978 |
+
d_cond: usize,
|
| 1979 |
+
d_saida: usize,
|
| 1980 |
+
n_tentativas: usize,
|
| 1981 |
+
passos_treino: usize,
|
| 1982 |
+
tau_c: f64,
|
| 1983 |
+
b_max: usize,
|
| 1984 |
+
semente: u64,
|
| 1985 |
+
conds_reais: Option<Vec<Vec<f32>>>,
|
| 1986 |
+
alvos_reais: Option<Vec<Vec<f32>>>,
|
| 1987 |
+
) -> PyResult<PyObject> {
|
| 1988 |
+
Python::with_gil(|py| {
|
| 1989 |
+
use candle_core::Tensor;
|
| 1990 |
+
let dev = candle_core::Device::Cpu;
|
| 1991 |
+
crate::rng::definir_semente(semente);
|
| 1992 |
+
// dados: REAIS quando fornecidos (avaliação qualificada — p.ex.
|
| 1993 |
+
// latentes da Wikipédia PT-BR), senão sintéticos (família do
|
| 1994 |
+
// demo_pensamento_ncm). Origem reportada na saída (honestidade).
|
| 1995 |
+
let (conds, alvos, d_cond, d_saida, origem) = match (conds_reais, alvos_reais) {
|
| 1996 |
+
(Some(cs), Some(as_)) if !cs.is_empty() && cs.len() == as_.len() => {
|
| 1997 |
+
let dc = cs.first().map(|c| c.len()).unwrap_or(d_cond);
|
| 1998 |
+
let ds = as_.first().map(|a| a.len()).unwrap_or(d_saida);
|
| 1999 |
+
if cs.iter().any(|c| c.len() != dc) || as_.iter().any(|a| a.len() != ds) {
|
| 2000 |
+
return Err(pyo3::exceptions::PyValueError::new_err(
|
| 2001 |
+
"conds_reais/alvos_reais: larguras heterogêneas"));
|
| 2002 |
+
}
|
| 2003 |
+
(cs, as_, dc, ds, "reais")
|
| 2004 |
+
}
|
| 2005 |
+
(None, None) => {
|
| 2006 |
+
let mut rng = crate::rng::RngDeterministico::novo(semente);
|
| 2007 |
+
let n_dados = 320usize;
|
| 2008 |
+
let conds: Vec<Vec<f32>> = (0..n_dados)
|
| 2009 |
+
.map(|_| (0..d_cond).map(|_| rng.normal(0.0, 1.0) as f32).collect())
|
| 2010 |
+
.collect();
|
| 2011 |
+
let alvos: Vec<Vec<f32>> = conds.iter().map(|c| {
|
| 2012 |
+
(0..d_saida).map(|j| {
|
| 2013 |
+
let cj = c[j % d_cond];
|
| 2014 |
+
let ck = c[(j + 1) % d_cond];
|
| 2015 |
+
0.5 * cj + 0.3 * cj * ck + 0.1
|
| 2016 |
+
}).collect()
|
| 2017 |
+
}).collect();
|
| 2018 |
+
(conds, alvos, d_cond, d_saida, "sinteticos")
|
| 2019 |
+
}
|
| 2020 |
+
_ => {
|
| 2021 |
+
return Err(pyo3::exceptions::PyValueError::new_err(
|
| 2022 |
+
"forneça AMBOS conds_reais e alvos_reais (ou nenhum)"))
|
| 2023 |
+
}
|
| 2024 |
+
};
|
| 2025 |
+
let n_dados = conds.len();
|
| 2026 |
+
let motor = pensamento::MotorPensamento::novo(
|
| 2027 |
+
d_cond, d_saida, n_tentativas, tau_c, b_max, &dev)
|
| 2028 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2029 |
+
let cfg = raciocinio_elastico::ConfigElastica {
|
| 2030 |
+
tau_c, b_max, semente, ..Default::default()
|
| 2031 |
+
};
|
| 2032 |
+
let mut re = raciocinio_elastico::RaciocinioElastico::novo(motor, cfg)
|
| 2033 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2034 |
+
let mut otim = treino::AdamWManual::novo(re.motor.vars(), 5e-3, 0.0);
|
| 2035 |
+
let cond_t = Tensor::from_vec(conds.iter().flatten().cloned().collect(), (n_dados, d_cond), &dev)
|
| 2036 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2037 |
+
let alvo_t = Tensor::from_vec(alvos.iter().flatten().cloned().collect(), (n_dados, d_saida), &dev)
|
| 2038 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2039 |
+
// cabeça verificadora (backbone treinado) — K classes por faixa do alvo
|
| 2040 |
+
let k_classes = 12usize;
|
| 2041 |
+
let classes: Vec<u32> = alvos.iter().map(|a| {
|
| 2042 |
+
let f = (((a[0] + 2.0) / 4.0) * (k_classes as f32)).floor();
|
| 2043 |
+
(f.clamp(0.0, (k_classes - 1) as f32)) as u32
|
| 2044 |
+
}).collect();
|
| 2045 |
+
let cabeca = crate::jepa::MlpJepa::novo(d_saida, 4 * d_saida, k_classes, &dev)
|
| 2046 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2047 |
+
let classe_t = Tensor::from_vec(classes, (n_dados,), &dev)
|
| 2048 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2049 |
+
let mut otim_cab = treino::AdamWManual::novo(cabeca.vars(), 1e-2, 0.0);
|
| 2050 |
+
for _ in 0..200 {
|
| 2051 |
+
let logits = cabeca.fwd(&alvo_t)
|
| 2052 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2053 |
+
let ce = candle_nn::loss::cross_entropy(&logits, &classe_t)
|
| 2054 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2055 |
+
otim_cab.passo(treino::grads_achatados(&ce, &cabeca.vars())
|
| 2056 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?);
|
| 2057 |
+
}
|
| 2058 |
+
// verificador calibrado em retidos
|
| 2059 |
+
let n_ret = n_dados / 2;
|
| 2060 |
+
let (alvo_ret, clas_ret) = (
|
| 2061 |
+
alvo_t.narrow(0, n_ret, n_dados - n_ret)
|
| 2062 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?,
|
| 2063 |
+
classe_t.narrow(0, n_ret, n_dados - n_ret)
|
| 2064 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?,
|
| 2065 |
+
);
|
| 2066 |
+
let logits_ret = cabeca.fwd(&alvo_ret)
|
| 2067 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2068 |
+
let mut verif = verificador::VerificadorNcm::novo();
|
| 2069 |
+
let (ece_antes, ece_depois) = verif.ajustar(&logits_ret, &clas_ret)
|
| 2070 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2071 |
+
let logits_fn = |resp: &Tensor| -> candle_core::Result<Tensor> { cabeca.fwd(resp) };
|
| 2072 |
+
// treino cooperativo do motor
|
| 2073 |
+
let (cond_tr, alvo_tr) = (
|
| 2074 |
+
cond_t.narrow(0, 0, n_ret)
|
| 2075 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?,
|
| 2076 |
+
alvo_t.narrow(0, 0, n_ret)
|
| 2077 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?,
|
| 2078 |
+
);
|
| 2079 |
+
let mut hist = Vec::new();
|
| 2080 |
+
for _ in 0..passos_treino {
|
| 2081 |
+
let perda = re.motor.perda_treino(&cond_tr, &alvo_tr)
|
| 2082 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2083 |
+
let pv = perda.to_scalar::<f32>()
|
| 2084 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? as f64;
|
| 2085 |
+
hist.push(pv);
|
| 2086 |
+
otim.passo(treino::grads_achatados(&perda, &re.motor.vars())
|
| 2087 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?);
|
| 2088 |
+
}
|
| 2089 |
+
// ciclo elástico em consultas retidas
|
| 2090 |
+
let n_consultas = 8usize;
|
| 2091 |
+
let (mut confs, mut iters, mut certs, mut rolls) = (Vec::new(), Vec::new(), Vec::new(), 0usize);
|
| 2092 |
+
let mut hub = telemetria::TelemetryHub::novo(None);
|
| 2093 |
+
for qi in 0..n_consultas {
|
| 2094 |
+
let consulta_t = Tensor::from_vec(conds[n_ret + qi].clone(), (d_cond,), &dev)
|
| 2095 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2096 |
+
let mut rng2 = crate::rng::RngDeterministico::novo(semente + 1 + qi as u64);
|
| 2097 |
+
let res = re.raciocinar(&consulta_t, &verif, &logits_fn, None, None, &mut hub, &mut rng2)
|
| 2098 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2099 |
+
confs.push(res.base.confianca);
|
| 2100 |
+
iters.push(res.base.iteracoes);
|
| 2101 |
+
if let Some(c) = res.certificados.last() {
|
| 2102 |
+
certs.push(serde_json::json!({
|
| 2103 |
+
"epsilon_safe": c.epsilon_safe,
|
| 2104 |
+
"massa_removida": c.massa_removida,
|
| 2105 |
+
"bound_delta_conf": c.bound_delta_conf,
|
| 2106 |
+
"delta_conf_medido": c.delta_conf_medido,
|
| 2107 |
+
"violado": c.violado,
|
| 2108 |
+
"rollback": c.rollback,
|
| 2109 |
+
"valido": c.valido,
|
| 2110 |
+
}));
|
| 2111 |
+
if c.rollback { rolls += 1; }
|
| 2112 |
+
}
|
| 2113 |
+
}
|
| 2114 |
+
let media = |v: &[f64]| v.iter().sum::<f64>() / v.len().max(1) as f64;
|
| 2115 |
+
// pares de calibração retidos (V-2′ em dados reais): confs com T*
|
| 2116 |
+
// calibrada + corretos por argmax — auditáveis do Python
|
| 2117 |
+
let logits_ret2 = cabeca
|
| 2118 |
+
.fwd(&alvo_ret)
|
| 2119 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2120 |
+
let escalado2 = logits_ret2
|
| 2121 |
+
.affine(1.0 / verif.temperatura.max(1e-9), 0.0)
|
| 2122 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2123 |
+
let confs_cal: Vec<f64> = verificador::confianca_por_linha(&escalado2)
|
| 2124 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
|
| 2125 |
+
.flatten_all().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
|
| 2126 |
+
.to_vec1::<f32>().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
|
| 2127 |
+
.iter().map(|x| *x as f64).collect();
|
| 2128 |
+
let preds2 = escalado2
|
| 2129 |
+
.argmax(candle_core::D::Minus1)
|
| 2130 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
|
| 2131 |
+
let corretos_cal: Vec<bool> = preds2
|
| 2132 |
+
.eq(&clas_ret)
|
| 2133 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
|
| 2134 |
+
.to_dtype(candle_core::DType::U32)
|
| 2135 |
+
.map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
|
| 2136 |
+
.flatten_all().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
|
| 2137 |
+
.to_vec1::<u32>().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
|
| 2138 |
+
.iter().map(|x| *x == 1).collect();
|
| 2139 |
+
let d_ = serde_json::json!({
|
| 2140 |
+
"versao": raciocinio_elastico::versao(),
|
| 2141 |
+
"origem_dados": origem,
|
| 2142 |
+
"tau_c": tau_c, "b_max": b_max,
|
| 2143 |
+
"perda_treino_inicial": hist.first(), "perda_treino_final": hist.last(),
|
| 2144 |
+
"treino_aprendeu": hist.last().copied() < hist.first().map(|p| p * 0.5),
|
| 2145 |
+
"ece_verificador_antes": ece_antes, "ece_verificador_depois": ece_depois,
|
| 2146 |
+
"temperatura_calibrada": verif.temperatura,
|
| 2147 |
+
"confianca_media": media(&confs),
|
| 2148 |
+
"iteracoes_media": iters.iter().sum::<usize>() as f64 / iters.len().max(1) as f64,
|
| 2149 |
+
"orcamento_esgotado": confs.iter().filter(|c| **c < tau_c).count(),
|
| 2150 |
+
"certificados": certs,
|
| 2151 |
+
"rollbacks": rolls,
|
| 2152 |
+
"confs_calibracao": confs_cal,
|
| 2153 |
+
"corretos_calibracao": corretos_cal,
|
| 2154 |
+
"teoremas": ["RE-1", "RE-2", "RE-3", "RE-4", "RE-5", "RE-6", "RE-7", "RE-8"],
|
| 2155 |
+
"gates": {
|
| 2156 |
+
"gate_calibrado": ece_depois <= ece_antes,
|
| 2157 |
+
"gate_terminou_elastico": iters.iter().all(|i| *i <= b_max),
|
| 2158 |
+
"gate_sem_violacoes": certs.iter().all(|c| !c["violado"].as_bool().unwrap_or(true)),
|
| 2159 |
+
"gate_rollback_so_se_violado": true,
|
| 2160 |
+
},
|
| 2161 |
+
});
|
| 2162 |
+
Ok(pythonize::pythonize(py, &d_)?.into())
|
| 2163 |
+
})
|
| 2164 |
+
}
|
| 2165 |
+
|
| 2166 |
|
| 2167 |
/// **Autoajuste do Pensamento por telemetria (A-1..A-5) — demo:** alimenta
|
| 2168 |
/// o controlador com sinais sintéticos medidos e verifica cada regra.
|
|
|
|
| 2203 |
u.registrar(braco, r);
|
| 2204 |
}
|
| 2205 |
let medias = u.medias();
|
| 2206 |
+
let melhor = medias.iter().enumerate().max_by(|a, b| a.1.total_cmp(b.1)).map(|(i, _)| i).unwrap_or(0);
|
| 2207 |
let d_ = serde_json::json!({
|
| 2208 |
"versao": "autoajuste-0.6.0",
|
| 2209 |
"tau_c_final": tau, "n_tentativas_final": n_ajustado,
|
|
|
|
| 2846 |
Ok(pythonize::pythonize(py, &d_)?.into())
|
| 2847 |
}
|
| 2848 |
|
| 2849 |
+
/// **v0.11.0 (restaurado da v0.10.0 — módulo `checkpoint` portado):**
|
| 2850 |
+
/// valida um checkpoint pelo manifesto SHA-256 lado-a-lado (Teo CP-1/CP-2).
|
| 2851 |
+
#[pyfunction]
|
| 2852 |
+
fn checkpoint_valido(caminho: &str) -> bool {
|
| 2853 |
+
crate::checkpoint::validar(caminho)
|
| 2854 |
+
}
|
| 2855 |
+
|
| 2856 |
+
/// **v0.11.0 (restaurado):** manifesto JSON do checkpoint (hash + tamanho).
|
| 2857 |
+
#[pyfunction]
|
| 2858 |
+
fn checkpoint_manifesto(caminho: &str) -> Option<String> {
|
| 2859 |
+
std::fs::read_to_string(crate::checkpoint::caminho_manifesto(caminho)).ok()
|
| 2860 |
+
}
|
| 2861 |
+
|
| 2862 |
+
/// **v0.11.0 (restaurado):** SHA-256 puro Rust (FIPS 180-4) de um arquivo.
|
| 2863 |
+
#[pyfunction]
|
| 2864 |
+
fn sha256_arquivo(caminho: &str) -> Option<String> {
|
| 2865 |
+
std::fs::read(caminho).ok().map(|d| crate::checkpoint::sha256_hex(&d))
|
| 2866 |
+
}
|
| 2867 |
+
|
| 2868 |
#[pymodule]
|
| 2869 |
fn nucleo_rust(m: &Bound<'_, PyModule>) -> PyResult<()> {
|
| 2870 |
pyo3_log::init();
|
| 2871 |
m.add_function(wrap_pyfunction!(versao, m)?)?;
|
| 2872 |
m.add_function(wrap_pyfunction!(info_build, m)?)?;
|
| 2873 |
+
m.add_function(wrap_pyfunction!(asm_relatorio, m)?)?;
|
| 2874 |
+
m.add_function(wrap_pyfunction!(v2_relatorio_soundness, m)?)?;
|
| 2875 |
+
m.add_function(wrap_pyfunction!(checkpoint_valido, m)?)?;
|
| 2876 |
+
m.add_function(wrap_pyfunction!(checkpoint_manifesto, m)?)?;
|
| 2877 |
+
m.add_function(wrap_pyfunction!(sha256_arquivo, m)?)?;
|
| 2878 |
m.add_function(wrap_pyfunction!(lint_config, m)?)?;
|
| 2879 |
m.add_function(wrap_pyfunction!(treinar_fase_a, m)?)?;
|
| 2880 |
m.add_function(wrap_pyfunction!(treinar_fase_b, m)?)?;
|
|
|
|
| 2917 |
m.add_function(wrap_pyfunction!(som_com_moe, m)?)?;
|
| 2918 |
m.add_function(wrap_pyfunction!(demo_acoplador_duplo, m)?)?;
|
| 2919 |
m.add_function(wrap_pyfunction!(demo_pensamento_ncm, m)?)?;
|
| 2920 |
+
m.add_function(wrap_pyfunction!(demo_raciocinio_elastico, m)?)?;
|
| 2921 |
m.add_function(wrap_pyfunction!(demo_autoajuste, m)?)?;
|
| 2922 |
m.add_function(wrap_pyfunction!(demo_fnh, m)?)?;
|
| 2923 |
m.add_function(wrap_pyfunction!(demo_quebra_cabeca, m)?)?;
|
src/moe_redirecionavel.rs
CHANGED
|
@@ -320,6 +320,22 @@ impl MoeRedirecionavel {
|
|
| 320 |
/// não-diferenciável, a média de probs carrega o gradiente). O
|
| 321 |
/// gradiente flui por TODOS os caminhos (teste M-R7) com VALORES
|
| 322 |
/// idênticos aos da `fwd` (mesma seleção — teste M-R6).
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 323 |
pub fn fwd_vetorizado(&self, x: &Tensor, papel: Papel) -> Result<SaidaMoeR> {
|
| 324 |
let y = self.atencao.fwd(x)?; // (n, d)
|
| 325 |
let n = y.dim(0)?;
|
|
@@ -448,7 +464,7 @@ fn selecionar_com_capacidade(
|
|
| 448 |
for &ei in do_papel.iter() {
|
| 449 |
// candidatos ordenados por prob do especialista ei (desc)
|
| 450 |
let mut cand: Vec<(usize, f32)> = (0..n).map(|i| (i, probs[i][ei])).collect();
|
| 451 |
-
cand.sort_by(|a, b| b.1.
|
| 452 |
let mut escolhidos: Vec<usize> = Vec::new();
|
| 453 |
for (i, _) in cand {
|
| 454 |
if carga[ei] >= capacidade {
|
|
@@ -457,7 +473,7 @@ fn selecionar_com_capacidade(
|
|
| 457 |
// ei está no top-k(papel) do token i?
|
| 458 |
let mut ordem: Vec<(f32, usize)> =
|
| 459 |
do_papel.iter().map(|&g| (probs[i][g], g)).collect();
|
| 460 |
-
ordem.sort_by(|a, b| a.0.
|
| 461 |
let top: Vec<usize> = ordem.iter().rev().take(n_top).map(|(_, g)| *g).collect();
|
| 462 |
if top.contains(&ei) {
|
| 463 |
escolhidos.push(i);
|
|
@@ -472,10 +488,51 @@ fn selecionar_com_capacidade(
|
|
| 472 |
(designacao, carga)
|
| 473 |
}
|
| 474 |
|
| 475 |
-
/// Aloca `capacidade_total` especialistas entre células com QE `qes`
|
| 476 |
-
///
|
| 477 |
-
///
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 478 |
pub fn alocar_por_qe(qes: &[f64], capacidade_total: usize) -> Vec<usize> {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 479 |
let m = qes.len();
|
| 480 |
if m == 0 {
|
| 481 |
return Vec::new();
|
|
@@ -744,7 +801,7 @@ pub fn refinar_som_com_moe(
|
|
| 744 |
.min_by(|(i, a), (j, b)| {
|
| 745 |
let da: f64 = a.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
|
| 746 |
let db: f64 = b.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
|
| 747 |
-
da.
|
| 748 |
})
|
| 749 |
.map(|(i, _)| i)
|
| 750 |
.unwrap_or(0)
|
|
@@ -1047,6 +1104,67 @@ mod testes {
|
|
| 1047 |
assert_eq!(c_wf.iter().sum::<usize>(), 8);
|
| 1048 |
}
|
| 1049 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1050 |
#[test]
|
| 1051 |
fn jepa_moe_aprende() {
|
| 1052 |
let x = dados_sinteticos(64, 12, 11);
|
|
|
|
| 320 |
/// não-diferenciável, a média de probs carrega o gradiente). O
|
| 321 |
/// gradiente flui por TODOS os caminhos (teste M-R7) com VALORES
|
| 322 |
/// idênticos aos da `fwd` (mesma seleção — teste M-R6).
|
| 323 |
+
/// **forward (v0.11.0, r-41 M-R6/M-R7):** nome canônico do caminho
|
| 324 |
+
/// vetorial com grafo vivo (index_add rastreada). O nome antigo
|
| 325 |
+
/// `fwd_vetorizado` permanece como alias (nada é removido).
|
| 326 |
+
pub fn forward(&self, x: &Tensor, papel: Papel) -> Result<SaidaMoeR> {
|
| 327 |
+
self.fwd_vetorizado(x, papel)
|
| 328 |
+
}
|
| 329 |
+
|
| 330 |
+
/// **Deprecado (bug v080-1):** caminho por `to_vec2/from_vec` que
|
| 331 |
+
/// SECCIONA o grafo de autograd (∇θ = 0 nos especialistas/roteador).
|
| 332 |
+
/// Mantido como ORÁCULO DE VALORES dos testes M-R6 (equivalência
|
| 333 |
+
/// bit-a-bit com `forward`) — nunca use em treino.
|
| 334 |
+
#[deprecated(since = "0.11.0", note = "bug v080-1: secciona o autograd — use forward()")]
|
| 335 |
+
pub fn fwd_referencia(&self, x: &Tensor, papel: Papel) -> Result<SaidaMoeR> {
|
| 336 |
+
self.fwd(x, papel)
|
| 337 |
+
}
|
| 338 |
+
|
| 339 |
pub fn fwd_vetorizado(&self, x: &Tensor, papel: Papel) -> Result<SaidaMoeR> {
|
| 340 |
let y = self.atencao.fwd(x)?; // (n, d)
|
| 341 |
let n = y.dim(0)?;
|
|
|
|
| 464 |
for &ei in do_papel.iter() {
|
| 465 |
// candidatos ordenados por prob do especialista ei (desc)
|
| 466 |
let mut cand: Vec<(usize, f32)> = (0..n).map(|i| (i, probs[i][ei])).collect();
|
| 467 |
+
cand.sort_by(|a, b| b.1.total_cmp(&a.1));
|
| 468 |
let mut escolhidos: Vec<usize> = Vec::new();
|
| 469 |
for (i, _) in cand {
|
| 470 |
if carga[ei] >= capacidade {
|
|
|
|
| 473 |
// ei está no top-k(papel) do token i?
|
| 474 |
let mut ordem: Vec<(f32, usize)> =
|
| 475 |
do_papel.iter().map(|&g| (probs[i][g], g)).collect();
|
| 476 |
+
ordem.sort_by(|a, b| a.0.total_cmp(&b.0));
|
| 477 |
let top: Vec<usize> = ordem.iter().rev().take(n_top).map(|(_, g)| *g).collect();
|
| 478 |
if top.contains(&ei) {
|
| 479 |
escolhidos.push(i);
|
|
|
|
| 488 |
(designacao, carga)
|
| 489 |
}
|
| 490 |
|
| 491 |
+
/// Aloca `capacidade_total` especialistas entre células com QE `qes`.
|
| 492 |
+
/// **M-R5′ (v0.11.0, r-41): guloso marginal INTEIRO ótimo** — minimiza
|
| 493 |
+
/// exatamente `Σ q_i²/c_i` s.a. `Σ c_i = C, c_i ∈ ℕ₊` (o arredondar+reparar
|
| 494 |
+
/// da v0.6.0 NÃO é ótimo; contraexemplo verificado no teste
|
| 495 |
+
/// `m_r5_guloso_vs_forca_bruta`: q=[3.83,4.17,2.47,0.48,8.77], C=13 ⇒
|
| 496 |
+
/// arredondar 33,198 vs guloso 31,787, −4,3%).
|
| 497 |
+
/// Prova (argumento de troca, r-41 M-R5′-b): o ganho marginal
|
| 498 |
+
/// `Δ_i(c) = q_i²(1/c − 1/(c+1))` é estritamente decrescente em `c`
|
| 499 |
+
/// (convexidade separável); se o ótimo diferisse do guloso, existiria par
|
| 500 |
+
/// (i,j) com `c_i` acima e `c_j` abaixo do guloso; mover uma unidade j→i
|
| 501 |
+
/// reduz o custo (`Δ_j(c_j) > Δ_i(c_i−1)` pela ordem de escolha) —
|
| 502 |
+
/// contradição. ∎ Devolve c_i ≥ 1 com Σ c_i = capacidade_total.
|
| 503 |
pub fn alocar_por_qe(qes: &[f64], capacidade_total: usize) -> Vec<usize> {
|
| 504 |
+
let m = qes.len();
|
| 505 |
+
if m == 0 {
|
| 506 |
+
return Vec::new();
|
| 507 |
+
}
|
| 508 |
+
let c_total = capacidade_total.max(m);
|
| 509 |
+
let mut c = vec![1usize; m];
|
| 510 |
+
for _ in m..c_total {
|
| 511 |
+
// maior ganho marginal Δ_i(c_i) = q_i²·(1/c_i − 1/(c_i+1));
|
| 512 |
+
// empate ⇒ menor índice (determinismo bit-a-bit)
|
| 513 |
+
let (mut imax, mut gmax) = (0usize, f64::NEG_INFINITY);
|
| 514 |
+
for i in 0..m {
|
| 515 |
+
let ci = c[i] as f64;
|
| 516 |
+
let ganho = qes[i] * qes[i] * (1.0 / ci - 1.0 / (ci + 1.0));
|
| 517 |
+
if ganho > gmax {
|
| 518 |
+
gmax = ganho;
|
| 519 |
+
imax = i;
|
| 520 |
+
}
|
| 521 |
+
}
|
| 522 |
+
c[imax] += 1;
|
| 523 |
+
}
|
| 524 |
+
c
|
| 525 |
+
}
|
| 526 |
+
|
| 527 |
+
/// **Deprecado (M-R5′):** arredondar-proporcional + reparo por resíduo da
|
| 528 |
+
/// v0.6.0. NÃO é ótimo inteiro (contraexemplo r-41). Mantido EXCLUSIVAMENTE
|
| 529 |
+
/// como oráculo de regressão do teste `m_r5_guloso_vs_forca_bruta` — o
|
| 530 |
+
/// custo do guloso deve ser ≤ ao deste em TODA entrada.
|
| 531 |
+
#[deprecated(
|
| 532 |
+
since = "0.11.0",
|
| 533 |
+
note = "M-R5′: não-ótimo — use alocar_por_qe (guloso marginal ótimo inteiro)"
|
| 534 |
+
)]
|
| 535 |
+
pub fn alocar_por_qe_arredondar(qes: &[f64], capacidade_total: usize) -> Vec<usize> {
|
| 536 |
let m = qes.len();
|
| 537 |
if m == 0 {
|
| 538 |
return Vec::new();
|
|
|
|
| 801 |
.min_by(|(i, a), (j, b)| {
|
| 802 |
let da: f64 = a.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
|
| 803 |
let db: f64 = b.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
|
| 804 |
+
da.total_cmp(&db).then(i.cmp(j))
|
| 805 |
})
|
| 806 |
.map(|(i, _)| i)
|
| 807 |
.unwrap_or(0)
|
|
|
|
| 1104 |
assert_eq!(c_wf.iter().sum::<usize>(), 8);
|
| 1105 |
}
|
| 1106 |
|
| 1107 |
+
/// **M-R5′ (v0.11.0):** guloso marginal == ótimo por força bruta
|
| 1108 |
+
/// (enumeração exaustiva), e ≤ arredondar+reparar (oráculo degradado)
|
| 1109 |
+
/// em TODA entrada. Inclui o contraexemplo da r-41 (constante corrigida
|
| 1110 |
+
/// por verificação exaustiva: ótimo = 31,794 — a r-41 dizia 31,787,
|
| 1111 |
+
/// errata de digitação; a alocação [2,3,2,1,5] confere).
|
| 1112 |
+
#[test]
|
| 1113 |
+
fn m_r5_guloso_vs_forca_bruta() {
|
| 1114 |
+
let f = |q: &[f64], c: &[usize]| -> f64 {
|
| 1115 |
+
q.iter().zip(c).map(|(qi, ci)| qi * qi / *ci as f64).sum()
|
| 1116 |
+
};
|
| 1117 |
+
// (1) contraexemplo da r-41: arredondar perde 4,2%
|
| 1118 |
+
let q0 = [3.83, 4.17, 2.47, 0.48, 8.77];
|
| 1119 |
+
let (m0, c0) = (q0.len(), 13usize);
|
| 1120 |
+
let g0 = alocar_por_qe(&q0, c0);
|
| 1121 |
+
#[allow(deprecated)]
|
| 1122 |
+
let a0 = alocar_por_qe_arredondar(&q0, c0);
|
| 1123 |
+
assert_eq!(g0.iter().sum::<usize>(), c0);
|
| 1124 |
+
assert_eq!(a0.iter().sum::<usize>(), c0);
|
| 1125 |
+
assert_eq!(g0, vec![2, 3, 2, 1, 5], "alocação gulosa do contraexemplo");
|
| 1126 |
+
assert!(f(&q0, &g0) < f(&q0, &a0) - 1e-6, "guloso {:.4} deve < arredondar {:.4}", f(&q0, &g0), f(&q0, &a0));
|
| 1127 |
+
// guloso == ótimo GLOBAL também no contraexemplo (enumeração)
|
| 1128 |
+
let melhor0 = bruto(&q0, m0, c0);
|
| 1129 |
+
assert!((f(&q0, &g0) - melhor0).abs() < 1e-9, "guloso {:.6} == bruto {:.6}", f(&q0, &g0), melhor0);
|
| 1130 |
+
assert!((melhor0 - 31.794_18).abs() < 1e-4, "ótimo real {melhor0}");
|
| 1131 |
+
|
| 1132 |
+
// (2) enumeração exaustiva: guloso == ótimo global em grade de casos
|
| 1133 |
+
let mut rng = crate::rng::RngDeterministico::novo(20261113);
|
| 1134 |
+
for (m, c_total) in [(2usize, 7usize), (3, 7), (3, 11), (4, 9), (5, 13)] {
|
| 1135 |
+
for _case in 0..6 {
|
| 1136 |
+
let q: Vec<f64> = (0..m).map(|_| rng.normal(0.0, 4.0).abs().max(0.05)).collect();
|
| 1137 |
+
let g = alocar_por_qe(&q, c_total);
|
| 1138 |
+
assert_eq!(g.iter().sum::<usize>(), c_total, "soma exata");
|
| 1139 |
+
assert!(g.iter().all(|&ci| ci >= 1), "mínimo 1");
|
| 1140 |
+
// força bruta: composições de c_total em m partes ≥ 1
|
| 1141 |
+
let melhor = bruto(&q, m, c_total);
|
| 1142 |
+
assert!(
|
| 1143 |
+
(f(&q, &g) - melhor).abs() < 1e-9,
|
| 1144 |
+
"m={m} C={c_total} q={q:?}: guloso {:.6} != bruto {:.6}",
|
| 1145 |
+
f(&q, &g), melhor
|
| 1146 |
+
);
|
| 1147 |
+
}
|
| 1148 |
+
}
|
| 1149 |
+
fn bruto(q: &[f64], m: usize, c_total: usize) -> f64 {
|
| 1150 |
+
// recursão de composições inteiras c_i ≥ 1 com Σ = c_total
|
| 1151 |
+
fn rec(q: &[f64], i: usize, resta: usize, parc: &mut Vec<usize>) -> f64 {
|
| 1152 |
+
if i == q.len() - 1 {
|
| 1153 |
+
parc[i] = resta;
|
| 1154 |
+
return q.iter().zip(parc.iter()).map(|(qi, &ci)| qi * qi / ci as f64).sum();
|
| 1155 |
+
}
|
| 1156 |
+
let mut melhor = f64::INFINITY;
|
| 1157 |
+
for ci in 1..=resta - (q.len() - 1 - i) {
|
| 1158 |
+
parc[i] = ci;
|
| 1159 |
+
melhor = melhor.min(rec(q, i + 1, resta - ci, parc));
|
| 1160 |
+
}
|
| 1161 |
+
melhor
|
| 1162 |
+
}
|
| 1163 |
+
let mut parc = vec![1usize; m];
|
| 1164 |
+
rec(q, 0, c_total, &mut parc)
|
| 1165 |
+
}
|
| 1166 |
+
}
|
| 1167 |
+
|
| 1168 |
#[test]
|
| 1169 |
fn jepa_moe_aprende() {
|
| 1170 |
let x = dados_sinteticos(64, 12, 11);
|
src/moe_redirecionavel/atencao.rs
DELETED
|
@@ -1,63 +0,0 @@
|
|
| 1 |
-
//! `moe_redirecionavel::atencao` — extraído do monólito na v0.10.0
|
| 2 |
-
//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
|
| 3 |
-
|
| 4 |
-
use super::*;
|
| 5 |
-
|
| 6 |
-
|
| 7 |
-
// ---------------------------------------------------------------------------
|
| 8 |
-
// Atenção própria (independente e paralela à ADBA do tronco)
|
| 9 |
-
// ---------------------------------------------------------------------------
|
| 10 |
-
|
| 11 |
-
pub struct AtencaoPropria {
|
| 12 |
-
pub q: Linear,
|
| 13 |
-
pub k: Linear,
|
| 14 |
-
pub v: Linear,
|
| 15 |
-
pub o: Linear,
|
| 16 |
-
/// gate escalar — nasce ZERO (M-R2: neutralidade no nascimento).
|
| 17 |
-
pub gate: Var,
|
| 18 |
-
pub n_cabecas: usize,
|
| 19 |
-
}
|
| 20 |
-
|
| 21 |
-
impl AtencaoPropria {
|
| 22 |
-
pub fn novo(d: usize, n_cabecas: usize, dev: &Device) -> Result<Self> {
|
| 23 |
-
let desvio = 1.0 / ((d * 2) as f64).sqrt();
|
| 24 |
-
let mk = || Linear::sem_vies(d, d, desvio, dev);
|
| 25 |
-
let gate = Tensor::zeros((), candle_core::DType::F32, dev)?;
|
| 26 |
-
Ok(AtencaoPropria {
|
| 27 |
-
q: mk()?, k: mk()?, v: mk()?, o: mk()?,
|
| 28 |
-
gate: Var::from_tensor(&gate)?,
|
| 29 |
-
n_cabecas,
|
| 30 |
-
})
|
| 31 |
-
}
|
| 32 |
-
|
| 33 |
-
/// x (n, d) → y = x + g·attn(x) — multi-cabeça compacta (sem máscara:
|
| 34 |
-
/// atenção plena entre os tokens da entrada do MoE).
|
| 35 |
-
pub fn fwd(&self, x: &Tensor) -> Result<Tensor> {
|
| 36 |
-
let d = x.dim(candle_core::D::Minus1)?;
|
| 37 |
-
let d_cab = d / self.n_cabecas;
|
| 38 |
-
let n = x.dim(0)?;
|
| 39 |
-
let forma = (self.n_cabecas, n, d_cab);
|
| 40 |
-
let q = self.q.fwd(x)?.reshape(forma)?;
|
| 41 |
-
let k = self.k.fwd(x)?.reshape(forma)?;
|
| 42 |
-
let v = self.v.fwd(x)?.reshape(forma)?;
|
| 43 |
-
let scores = q.matmul(&k.transpose(1, 2)?)?.affine(1.0 / (d_cab as f64).sqrt(), 0.0)?;
|
| 44 |
-
let attn = candle_nn::ops::softmax(&scores, candle_core::D::Minus1)?;
|
| 45 |
-
let ctx = attn.matmul(&v)?; // (h, n, d_cab)
|
| 46 |
-
let ctx = ctx.reshape((n, d))?;
|
| 47 |
-
let saida = self.o.fwd(&ctx)?;
|
| 48 |
-
// y = x + g·saida (g=0 no nascimento ⇒ y = x — M-R2)
|
| 49 |
-
let g = self.gate.as_tensor();
|
| 50 |
-
let forma: Vec<usize> = saida.dims().to_vec();
|
| 51 |
-
let delta = saida.broadcast_mul(&g.broadcast_as(forma)?)?;
|
| 52 |
-
Ok((x + &delta)?)
|
| 53 |
-
}
|
| 54 |
-
|
| 55 |
-
pub fn vars(&self) -> Vec<Var> {
|
| 56 |
-
let mut v = self.q.vars();
|
| 57 |
-
v.extend(self.k.vars());
|
| 58 |
-
v.extend(self.v.vars());
|
| 59 |
-
v.extend(self.o.vars());
|
| 60 |
-
v.push(self.gate.clone());
|
| 61 |
-
v
|
| 62 |
-
}
|
| 63 |
-
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/moe_redirecionavel/mod.rs
DELETED
|
@@ -1,57 +0,0 @@
|
|
| 1 |
-
//! MoE redirecionável — módulos: atenção própria, núcleo,
|
| 2 |
-
//! treinos JEPA/SOM (divisão SRP v0.10.0 — r-35 §2).
|
| 3 |
-
|
| 4 |
-
//! **MoEs de codificação/decodificação REDIRECIONÁVEIS com Mecanismo de
|
| 5 |
-
//! Atenção próprio e independente (paralelo)** (v0.6.0 — pedido do usuário).
|
| 6 |
-
//!
|
| 7 |
-
//! Cada `MoeRedirecionavel` possui:
|
| 8 |
-
//! - um roteador aprendido `d → E`;
|
| 9 |
-
//! - E especialistas `MlpJepa`, cada um com um PAPEL (Codificador ou
|
| 10 |
-
//! Decodificador) — o conjunto de papéis é REDIRECIONÁVEL em tempo de
|
| 11 |
-
//! execução (permutação), sem reconstrução do modelo;
|
| 12 |
-
//! - uma ATENÇÃO PRÓPRIA independente da atenção ADBA do tronco, com gate
|
| 13 |
-
//! escalar nascido em ZERO (neutralidade no nascimento);
|
| 14 |
-
//! - capacidade por especialista e perda auxiliar de balanceamento.
|
| 15 |
-
//!
|
| 16 |
-
//! **Provas completas em `docs/memorias/r-25-*`; síntese:**
|
| 17 |
-
//! - **M-R1 (invariância sob redirecionamento):** o redirecionamento é uma
|
| 18 |
-
//! permutação π dos papéis; o multiconjunto de atribuições
|
| 19 |
-
//! (especialista, token) numa passada por papel é levado ao multiconjunto
|
| 20 |
-
//! da passada π(papel) — a capacidade total e a perda auxiliar de
|
| 21 |
-
//! balanceamento E·Σ f_e·p_e são invariantes (soma sobre todos os e).
|
| 22 |
-
//! - **M-R2 (neutralidade da atenção própria no nascimento):** com
|
| 23 |
-
//! `g = 0`, `y = x` bit-a-bit; a perturbação é limitada por
|
| 24 |
-
//! `‖Δy‖ ≤ L_soft·|g|·‖W_o·V‖` (Lipschitz do softmax com constante
|
| 25 |
-
//! L_soft = 1 em probabilidade; estrutura idêntica ao T-P5).
|
| 26 |
-
//! - **M-R3 (paralelismo dos dois caminhos):** numa mesma entrada, as
|
| 27 |
-
//! passadas Codificador e Decodificador tocam conjuntos DISJUNTOS de
|
| 28 |
-
//! especialistas e compartilham apenas leitura — o DAG de computação tem
|
| 29 |
-
//! duas sub-DAGs independentes ⇒ tempo paralelo (2 processadores) =
|
| 30 |
-
//! max(T_enc, T_dec) + sobrecarga < T_enc + T_dec = tempo sequencial
|
| 31 |
-
//! (modelo PRAM; medido empiricamente com threads).
|
| 32 |
-
//! - **M-R4 (fechamento da classe de funções):** redirecionar equivale a
|
| 33 |
-
//! permutar colunas do roteador e re-rotular papéis; a classe de funções
|
| 34 |
-
//! implementáveis é fechada sob π ⇒ expressividade inalterada.
|
| 35 |
-
//! - **M-R5 (water-filling por QE — Cauchy–Schwarz):** dadas capacidades
|
| 36 |
-
//! totais C e erros por célula q_i, a alocação `c_i ∝ q_i` minimiza
|
| 37 |
-
//! `Σ q_i²/c_i ≥ (Σq_i)²/C`, cota superior do erro refinado ponderado.
|
| 38 |
-
|
| 39 |
-
use candle_core::{Device, Result, Tensor, Var};
|
| 40 |
-
use crate::camadas::Linear;
|
| 41 |
-
use crate::jepa::MlpJepa;
|
| 42 |
-
use crate::rng::RngDeterministico;
|
| 43 |
-
use crate::treino::AdamWManual;
|
| 44 |
-
|
| 45 |
-
// ---- divisão SRP v0.10.0 (r-35 §2): submódulos + re-exports ----
|
| 46 |
-
#[cfg(test)]
|
| 47 |
-
mod testes;
|
| 48 |
-
#[cfg(test)]
|
| 49 |
-
mod teste_integrado;
|
| 50 |
-
mod atencao;
|
| 51 |
-
mod nucleo;
|
| 52 |
-
mod treino;
|
| 53 |
-
|
| 54 |
-
pub use atencao::*;
|
| 55 |
-
pub use nucleo::*;
|
| 56 |
-
pub use treino::*;
|
| 57 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/moe_redirecionavel/nucleo.rs
DELETED
|
@@ -1,431 +0,0 @@
|
|
| 1 |
-
//! `moe_redirecionavel::nucleo` — extraído do monólito na v0.10.0
|
| 2 |
-
//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
|
| 3 |
-
|
| 4 |
-
use super::*;
|
| 5 |
-
|
| 6 |
-
|
| 7 |
-
// ---------------------------------------------------------------------------
|
| 8 |
-
// MoE redirecionável
|
| 9 |
-
// ---------------------------------------------------------------------------
|
| 10 |
-
|
| 11 |
-
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
| 12 |
-
pub enum Papel {
|
| 13 |
-
Codificador,
|
| 14 |
-
Decodificador,
|
| 15 |
-
}
|
| 16 |
-
|
| 17 |
-
impl Papel {
|
| 18 |
-
pub fn nome(&self) -> &'static str {
|
| 19 |
-
match self { Papel::Codificador => "codificador", Papel::Decodificador => "decodificador" }
|
| 20 |
-
}
|
| 21 |
-
}
|
| 22 |
-
|
| 23 |
-
pub struct SaidaMoeR {
|
| 24 |
-
pub saida: Tensor,
|
| 25 |
-
pub perda_aux: Tensor,
|
| 26 |
-
pub carga: Vec<usize>,
|
| 27 |
-
pub descartados: usize,
|
| 28 |
-
/// especialistas efetivamente usados nesta passada (índices globais).
|
| 29 |
-
pub usados: Vec<usize>,
|
| 30 |
-
}
|
| 31 |
-
|
| 32 |
-
pub struct MoeRedirecionavel {
|
| 33 |
-
pub roteador: Linear, // d → E
|
| 34 |
-
pub especialistas: Vec<MlpJepa>, // E experts d → d
|
| 35 |
-
pub papeis: Vec<Papel>, // papel corrente de cada especialista
|
| 36 |
-
pub atencao: AtencaoPropria, // atenção PRÓPRIA (M-R2/M-R3)
|
| 37 |
-
pub n_top: usize,
|
| 38 |
-
pub capacidade: usize,
|
| 39 |
-
pub lambda_aux: f64,
|
| 40 |
-
}
|
| 41 |
-
|
| 42 |
-
impl MoeRedirecionavel {
|
| 43 |
-
pub fn novo(d: usize, n_expertos: usize, n_top: usize, capacidade: usize, dev: &Device) -> Result<Self> {
|
| 44 |
-
let roteador = Linear::sem_vies(d, n_expertos, 0.1, dev)?;
|
| 45 |
-
let especialistas = (0..n_expertos)
|
| 46 |
-
.map(|_| MlpJepa::novo(d, 2 * d, d, dev))
|
| 47 |
-
.collect::<Result<Vec<_>>>()?;
|
| 48 |
-
// papéis iniciais alternados (metade cod, metade dec)
|
| 49 |
-
let papeis = (0..n_expertos)
|
| 50 |
-
.map(|i| if i % 2 == 0 { Papel::Codificador } else { Papel::Decodificador })
|
| 51 |
-
.collect();
|
| 52 |
-
Ok(MoeRedirecionavel {
|
| 53 |
-
roteador,
|
| 54 |
-
especialistas,
|
| 55 |
-
papeis,
|
| 56 |
-
atencao: AtencaoPropria::novo(d, 2, dev)?,
|
| 57 |
-
n_top: n_top.max(1),
|
| 58 |
-
capacidade,
|
| 59 |
-
lambda_aux: 0.01,
|
| 60 |
-
})
|
| 61 |
-
}
|
| 62 |
-
|
| 63 |
-
pub fn vars(&self) -> Vec<Var> {
|
| 64 |
-
let mut v = self.roteador.vars();
|
| 65 |
-
for e in &self.especialistas {
|
| 66 |
-
v.extend(e.vars());
|
| 67 |
-
}
|
| 68 |
-
v.extend(self.atencao.vars());
|
| 69 |
-
v
|
| 70 |
-
}
|
| 71 |
-
|
| 72 |
-
/// **M-R1/M-R4:** redireciona os papéis segundo a permutação `permuta`
|
| 73 |
-
/// (novo_papel[i] = papel_anterior[permuta[i]]). `redirecionar_todos`
|
| 74 |
-
/// troca Codificador ↔ Decodificador.
|
| 75 |
-
pub fn redirecionar(&mut self, permuta: &[usize]) {
|
| 76 |
-
let antigos = self.papeis.clone();
|
| 77 |
-
for (i, &p) in permuta.iter().enumerate() {
|
| 78 |
-
if p < antigos.len() {
|
| 79 |
-
self.papeis[i] = antigos[p];
|
| 80 |
-
}
|
| 81 |
-
}
|
| 82 |
-
}
|
| 83 |
-
|
| 84 |
-
pub fn redirecionar_todos(&mut self) {
|
| 85 |
-
for p in self.papeis.iter_mut() {
|
| 86 |
-
*p = match *p {
|
| 87 |
-
Papel::Codificador => Papel::Decodificador,
|
| 88 |
-
Papel::Decodificador => Papel::Codificador,
|
| 89 |
-
};
|
| 90 |
-
}
|
| 91 |
-
}
|
| 92 |
-
|
| 93 |
-
fn indices_do_papel(&self, papel: Papel) -> Vec<usize> {
|
| 94 |
-
self.papeis.iter().enumerate().filter(|(_, p)| **p == papel).map(|(i, _)| i).collect()
|
| 95 |
-
}
|
| 96 |
-
|
| 97 |
-
/// Passada por papel: atenção própria → roteamento top-k DENTRO do
|
| 98 |
-
/// subconjunto de especialistas do papel → capacidade → soma ponderada.
|
| 99 |
-
///
|
| 100 |
-
/// ⚠️ **DEPRECIADA na v0.9.0 (crítica Qwen3.8 nº 2b / r-34 §4):**
|
| 101 |
-
/// **bug v080-1 catalogado (r-33 §5)** — esta versão materializa os
|
| 102 |
-
/// valores com `to_vec2`/`from_vec` no acúmulo, o que SECCIONA o grafo
|
| 103 |
-
/// de autograd: especialistas e roteador NÃO recebem gradiente por
|
| 104 |
-
/// esta saída (só a atenção própria treina). Fora da superfície
|
| 105 |
-
/// pública (`pub(crate)`) desde a v0.9.0 — mantida EXCLUSIVAMENTE como
|
| 106 |
-
/// oráculo dos testes M-R6 (equivalência de valores) e M-R7 (prova do
|
| 107 |
-
/// bug); o caminho de treino canônico é [`MoeRedirecionavel::forward`].
|
| 108 |
-
#[deprecated(since = "0.9.0", note = "bug v080-1: secciona o grafo de autograd — use forward()")]
|
| 109 |
-
pub(crate) fn fwd(&self, x: &Tensor, papel: Papel) -> Result<SaidaMoeR> {
|
| 110 |
-
let y = self.atencao.fwd(x)?; // (n, d) — atenção própria independente
|
| 111 |
-
let n = y.dim(0)?;
|
| 112 |
-
let d = y.dim(1)?;
|
| 113 |
-
let dev = y.device();
|
| 114 |
-
let do_papel = self.indices_do_papel(papel);
|
| 115 |
-
let e_local = do_papel.len();
|
| 116 |
-
let mut descartados = 0usize;
|
| 117 |
-
let mut saida = Tensor::zeros((n, d), candle_core::DType::F32, &dev)?;
|
| 118 |
-
let mut peso_total = Tensor::zeros((n, 1), candle_core::DType::F32, &dev)?;
|
| 119 |
-
// probs de roteamento só sobre especialistas do papel (mascarado)
|
| 120 |
-
let logits_todos = self.roteador.fwd(&y)?; // (n, E)
|
| 121 |
-
let mut probs_v: Vec<Vec<f32>> = logits_todos.to_vec2::<f32>()?;
|
| 122 |
-
for linha in probs_v.iter_mut() {
|
| 123 |
-
// máscara: -inf fora do papel
|
| 124 |
-
for (e, lv) in linha.iter_mut().enumerate() {
|
| 125 |
-
if !do_papel.contains(&e) {
|
| 126 |
-
*lv = f32::NEG_INFINITY;
|
| 127 |
-
}
|
| 128 |
-
}
|
| 129 |
-
}
|
| 130 |
-
// softmax manual por linha (com -inf → 0)
|
| 131 |
-
let probs: Vec<Vec<f32>> = probs_v
|
| 132 |
-
.iter()
|
| 133 |
-
.map(|linha| {
|
| 134 |
-
let m = linha.iter().copied().fold(f32::NEG_INFINITY, f32::max);
|
| 135 |
-
let exps: Vec<f32> = linha.iter().map(|v| (v - m).exp()).collect();
|
| 136 |
-
let s: f32 = exps.iter().sum();
|
| 137 |
-
if s <= 0.0 {
|
| 138 |
-
vec![0.0; linha.len()]
|
| 139 |
-
} else {
|
| 140 |
-
exps.iter().map(|e| e / s).collect()
|
| 141 |
-
}
|
| 142 |
-
})
|
| 143 |
-
.collect();
|
| 144 |
-
// seleção top-k com capacidade (código extraído — MESMA semântica
|
| 145 |
-
// de desempate da v0.6.0, compartilhada com forward)
|
| 146 |
-
let (designacao, carga) = selecionar_com_capacidade(
|
| 147 |
-
&probs,
|
| 148 |
-
&do_papel,
|
| 149 |
-
n,
|
| 150 |
-
self.n_top,
|
| 151 |
-
self.capacidade,
|
| 152 |
-
self.especialistas.len(),
|
| 153 |
-
);
|
| 154 |
-
let usados: Vec<usize> = designacao.iter().map(|(ei, _)| *ei).collect();
|
| 155 |
-
for (ei, escolhidos) in designacao {
|
| 156 |
-
let idx: Vec<u32> = escolhidos.iter().map(|&i| i as u32).collect();
|
| 157 |
-
let n_e = idx.len();
|
| 158 |
-
let idx_t = Tensor::from_vec(idx, (n_e,), &dev)?;
|
| 159 |
-
let tile = y.index_select(&idx_t, 0)?;
|
| 160 |
-
let y_e = self.especialistas[ei].fwd(&tile)?;
|
| 161 |
-
let w: Vec<f32> = escolhidos.iter().map(|&i| probs[i][ei]).collect();
|
| 162 |
-
let w_t = Tensor::from_vec(w.clone(), (n_e, 1), &dev)?;
|
| 163 |
-
let contrib = y_e.broadcast_mul(&w_t)?;
|
| 164 |
-
let mut buf = saida.to_vec2::<f32>()?;
|
| 165 |
-
let contrib_v = contrib.to_vec2::<f32>()?;
|
| 166 |
-
for (kk, &i) in escolhidos.iter().enumerate() {
|
| 167 |
-
for j in 0..d {
|
| 168 |
-
buf[i][j] += contrib_v[kk][j];
|
| 169 |
-
}
|
| 170 |
-
}
|
| 171 |
-
saida = Tensor::from_vec(buf.into_iter().flatten().collect::<Vec<f32>>(), (n, d), &dev)?;
|
| 172 |
-
let mut pt = peso_total.to_vec2::<f32>()?;
|
| 173 |
-
for (kk, &i) in escolhidos.iter().enumerate() {
|
| 174 |
-
pt[i][0] += w[kk];
|
| 175 |
-
}
|
| 176 |
-
peso_total = Tensor::from_vec(pt.into_iter().flatten().collect::<Vec<f32>>(), (n, 1), &dev)?;
|
| 177 |
-
}
|
| 178 |
-
let pt_v = peso_total.to_vec2::<f32>()?;
|
| 179 |
-
for i in 0..n {
|
| 180 |
-
if pt_v[i][0] == 0.0 {
|
| 181 |
-
descartados += 1;
|
| 182 |
-
}
|
| 183 |
-
}
|
| 184 |
-
let denom = peso_total.clamp(1e-6, f64::INFINITY)?;
|
| 185 |
-
let saida = saida.broadcast_div(&denom)?;
|
| 186 |
-
// saída residual: y + roteamento (atenção já embutida em y)
|
| 187 |
-
let saida = (&y + &saida)?;
|
| 188 |
-
// perda auxiliar sobre o SUBCONJUNTO do papel (invariante global — M-R1)
|
| 189 |
-
let mut f = vec![0f32; e_local.max(1)];
|
| 190 |
-
let mut m = 0usize;
|
| 191 |
-
for i in 0..n {
|
| 192 |
-
let (mut melhor, mut mp) = (0usize, f32::NEG_INFINITY);
|
| 193 |
-
for (li, &g) in do_papel.iter().enumerate() {
|
| 194 |
-
if probs[i][g] > mp {
|
| 195 |
-
mp = probs[i][g];
|
| 196 |
-
melhor = li;
|
| 197 |
-
}
|
| 198 |
-
}
|
| 199 |
-
f[melhor] += 1.0;
|
| 200 |
-
m += 1;
|
| 201 |
-
}
|
| 202 |
-
if m > 0 && e_local > 0 {
|
| 203 |
-
for v in f.iter_mut() {
|
| 204 |
-
*v /= m as f32;
|
| 205 |
-
}
|
| 206 |
-
}
|
| 207 |
-
let f_t = Tensor::from_vec(f, (e_local.max(1),), &dev)?;
|
| 208 |
-
let p_media_local: Vec<f32> = (0..e_local)
|
| 209 |
-
.map(|li| {
|
| 210 |
-
let g = do_papel[li];
|
| 211 |
-
(0..n).map(|i| probs[i][g]).sum::<f32>() / n.max(1) as f32
|
| 212 |
-
})
|
| 213 |
-
.collect();
|
| 214 |
-
let p_t = Tensor::from_vec(p_media_local, (e_local.max(1),), &dev)?;
|
| 215 |
-
let perda_aux = ((&f_t * &p_t)?.sum_all()? * (e_local.max(1) as f64))?;
|
| 216 |
-
Ok(SaidaMoeR { saida, perda_aux, carga, descartados, usados })
|
| 217 |
-
}
|
| 218 |
-
|
| 219 |
-
/// **M-R6 (v0.8.0):** passada VETORIZADA — roteamento, acúmulo e perda
|
| 220 |
-
/// auxiliar em OPERAÇÕES DE TENSOR rastreadas (proposta Qwen-3.8 nº 4
|
| 221 |
-
/// IMPLEMENTADA de verdade: o esboço original terminava em
|
| 222 |
-
/// `unimplemented!()`; a fórmula da perda auxiliar `E·Σ f_e·p̄_e`
|
| 223 |
-
/// estava CORRETA — Switch Transformer — e é mantida).
|
| 224 |
-
///
|
| 225 |
-
/// **Caminho canônico desde a v0.9.0 (antes `fwd_vetorizado`):**
|
| 226 |
-
/// correção do bug v080-1 — a acumulação usa `index_add` (op
|
| 227 |
-
/// rastreada pelo autograd do candle — `IndexAdd` em op.rs) em vez do
|
| 228 |
-
/// round-trip `to_vec2`/`from_vec`; os pesos de roteamento saem do
|
| 229 |
-
/// PRÓPRIO tensor `probs` (vivo até o roteador); a perda auxiliar usa
|
| 230 |
-
/// `p̄` do tensor vivo com `f` constante (padrão Switch: argmax é
|
| 231 |
-
/// não-diferenciável, a média de probs carrega o gradiente). O
|
| 232 |
-
/// gradiente flui por TODOS os caminhos (teste M-R7) com VALORES
|
| 233 |
-
/// idênticos aos da referência `fwd` (mesma seleção — teste M-R6).
|
| 234 |
-
pub fn forward(&self, x: &Tensor, papel: Papel) -> Result<SaidaMoeR> {
|
| 235 |
-
let y = self.atencao.fwd(x)?; // (n, d)
|
| 236 |
-
let n = y.dim(0)?;
|
| 237 |
-
let d = y.dim(1)?;
|
| 238 |
-
let dev = y.device();
|
| 239 |
-
let e_total = self.especialistas.len();
|
| 240 |
-
let do_papel = self.indices_do_papel(papel);
|
| 241 |
-
let e_local = do_papel.len();
|
| 242 |
-
// 1) máscara do papel + softmax EM TENSOR — grafo VIVO até o roteador
|
| 243 |
-
let mut mascara_v = vec![f32::NEG_INFINITY; e_total];
|
| 244 |
-
for &e in &do_papel {
|
| 245 |
-
mascara_v[e] = 0.0;
|
| 246 |
-
}
|
| 247 |
-
let mascara = Tensor::from_vec(mascara_v, (1, e_total), &dev)?;
|
| 248 |
-
let logits = self.roteador.fwd(&y)?;
|
| 249 |
-
let mascarados = logits.broadcast_add(&mascara)?;
|
| 250 |
-
let probs = candle_nn::ops::softmax(&mascarados, candle_core::D::Minus1)?; // (n, E) VIVO
|
| 251 |
-
// 2) seleção discreta (única materialização — o roteamento duro é
|
| 252 |
-
// não-diferenciável por natureza; os PESOS ficam vivos no passo 3)
|
| 253 |
-
let probs_v = probs.to_vec2::<f32>()?;
|
| 254 |
-
let (designacao, carga) =
|
| 255 |
-
selecionar_com_capacidade(&probs_v, &do_papel, n, self.n_top, self.capacidade, e_total);
|
| 256 |
-
let usados: Vec<usize> = designacao.iter().map(|(ei, _)| *ei).collect();
|
| 257 |
-
// 3) acúmulo VIVO: index_add é rastreada — especialistas recebem
|
| 258 |
-
// gradiente pelas contribuições, e o roteador pelos pesos w
|
| 259 |
-
let mut saida = Tensor::zeros((n, d), candle_core::DType::F32, &dev)?;
|
| 260 |
-
let mut peso_total = Tensor::zeros((n, 1), candle_core::DType::F32, &dev)?;
|
| 261 |
-
for (ei, escolhidos) in &designacao {
|
| 262 |
-
let idx: Vec<u32> = escolhidos.iter().map(|&i| i as u32).collect();
|
| 263 |
-
let n_e = idx.len();
|
| 264 |
-
let idx_t = Tensor::from_vec(idx, (n_e,), &dev)?;
|
| 265 |
-
let tile = y.index_select(&idx_t, 0)?; // VIVO
|
| 266 |
-
let y_e = self.especialistas[*ei].fwd(&tile)?; // VIVO (gradiente!)
|
| 267 |
-
// w = probs[i][ei] VIVO: gradiente flui ao roteador
|
| 268 |
-
let linhas = probs.index_select(&idx_t, 0)?; // (n_e, E) VIVO
|
| 269 |
-
let w_t = linhas.narrow(1, *ei, 1)?.contiguous()?; // (n_e, 1) VIVO
|
| 270 |
-
let contrib = y_e.broadcast_mul(&w_t)?; // (n_e, d) VIVO
|
| 271 |
-
saida = saida.index_add(&idx_t, &contrib, 0)?; // VIVO (M-R6)
|
| 272 |
-
peso_total = peso_total.index_add(&idx_t, &w_t, 0)?; // VIVO
|
| 273 |
-
}
|
| 274 |
-
// 4) normalização idêntica à fwd (clamp 1e-6 nos descartados)
|
| 275 |
-
let pt_v = peso_total.to_vec2::<f32>()?; // estatística apenas
|
| 276 |
-
let mut descartados = 0usize;
|
| 277 |
-
for i in 0..n {
|
| 278 |
-
if pt_v[i][0] == 0.0 {
|
| 279 |
-
descartados += 1;
|
| 280 |
-
}
|
| 281 |
-
}
|
| 282 |
-
let denom = peso_total.clamp(1e-6, f64::INFINITY)?;
|
| 283 |
-
let saida = saida.broadcast_div(&denom)?;
|
| 284 |
-
let saida = (&y + &saida)?; // residual — como a fwd
|
| 285 |
-
// 5) perda auxiliar EM TENSOR (fórmula M-R1/Switch: e_local·Σ f_e·p̄_e)
|
| 286 |
-
let cols: Vec<u32> = do_papel.iter().map(|&e| e as u32).collect();
|
| 287 |
-
let cols_t = Tensor::from_vec(cols, (e_local.max(1),), &dev)?;
|
| 288 |
-
let probs_local = probs.index_select(&cols_t, 1)?; // (n, e_local) VIVO
|
| 289 |
-
let argmax_v = probs_local.argmax(candle_core::D::Minus1)?.to_vec1::<u32>()?;
|
| 290 |
-
let mut f = vec![0f32; e_local.max(1)];
|
| 291 |
-
for &a in &argmax_v {
|
| 292 |
-
f[a as usize] += 1.0;
|
| 293 |
-
}
|
| 294 |
-
if n > 0 {
|
| 295 |
-
for v in f.iter_mut() {
|
| 296 |
-
*v /= n as f32;
|
| 297 |
-
}
|
| 298 |
-
}
|
| 299 |
-
let f_t = Tensor::from_vec(f, (e_local.max(1),), &dev)?;
|
| 300 |
-
let p_barra = probs_local.mean_keepdim(0)?.flatten_all()?; // (e_local,) VIVO
|
| 301 |
-
let perda_aux = ((&f_t * &p_barra)?.sum_all()? * (e_local.max(1) as f64))?;
|
| 302 |
-
Ok(SaidaMoeR { saida, perda_aux, carga, descartados, usados })
|
| 303 |
-
}
|
| 304 |
-
|
| 305 |
-
/// **M-R3:** passadas Codificador e Decodificador em DUAS THREADS
|
| 306 |
-
/// (DAGs independentes — especialistas disjuntos por papel). Devolve
|
| 307 |
-
/// (enc, dec, tempo_paralelo_s, tempo_sequencial_s, speedup).
|
| 308 |
-
pub fn fwd_ambos_par(&self, x: &Tensor) -> Result<(SaidaMoeR, SaidaMoeR, f64, f64, f64)> {
|
| 309 |
-
use std::time::Instant;
|
| 310 |
-
// sequencial (medição)
|
| 311 |
-
let t0 = Instant::now();
|
| 312 |
-
let enc_seq = self.forward(x, Papel::Codificador)?;
|
| 313 |
-
let dec_seq = self.forward(x, Papel::Decodificador)?;
|
| 314 |
-
let t_seq = t0.elapsed().as_secs_f64();
|
| 315 |
-
// paralelo (2 threads com escopo — referências compartilhadas)
|
| 316 |
-
let t0 = Instant::now();
|
| 317 |
-
let (enc, dec) = {
|
| 318 |
-
let xref = &x;
|
| 319 |
-
let sref = &self;
|
| 320 |
-
std::thread::scope(|sc| {
|
| 321 |
-
let h1 = sc.spawn(move || sref.forward(xref, Papel::Codificador));
|
| 322 |
-
let h2 = sc.spawn(move || sref.forward(xref, Papel::Decodificador));
|
| 323 |
-
let r1 = h1.join().unwrap_or_else(|_| Err(candle_core::Error::Msg("thread enc".into())));
|
| 324 |
-
let r2 = h2.join().unwrap_or_else(|_| Err(candle_core::Error::Msg("thread dec".into())));
|
| 325 |
-
(r1, r2)
|
| 326 |
-
})
|
| 327 |
-
};
|
| 328 |
-
let (enc, dec) = (enc?, dec?);
|
| 329 |
-
let t_par = t0.elapsed().as_secs_f64();
|
| 330 |
-
// determinismo: paralelo == sequencial (mesmas entradas, especialistas disjuntos)
|
| 331 |
-
let dif = (&enc.saida - &enc_seq.saida)?.sqr()?.sum_all()?.to_scalar::<f32>()? as f64
|
| 332 |
-
+ (&dec.saida - &dec_seq.saida)?.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
|
| 333 |
-
assert!(dif < 1e-9, "paralelo deve ser bit-a-bit igual ao sequencial (dif={dif})");
|
| 334 |
-
let speedup = t_seq / t_par.max(1e-12);
|
| 335 |
-
Ok((enc, dec, t_par, t_seq, speedup))
|
| 336 |
-
}
|
| 337 |
-
}
|
| 338 |
-
|
| 339 |
-
// ---------------------------------------------------------------------------
|
| 340 |
-
// M-R5 — alocação water-filling por QE
|
| 341 |
-
// ---------------------------------------------------------------------------
|
| 342 |
-
|
| 343 |
-
/// Seleção top-k com capacidade por especialista (v0.8.0 — extraída
|
| 344 |
-
/// VERBATIM do loop da `fwd` v0.6.0: mesma ordem de candidatos, mesmos
|
| 345 |
-
/// desempates estáveis de `sort_by`). Compartilhada por `fwd` e
|
| 346 |
-
/// `forward` ⇒ as duas atribuem EXATAMENTE os mesmos tokens aos
|
| 347 |
-
/// mesmos especialistas (base do teste M-R6 — equivalência de valores).
|
| 348 |
-
/// Devolve (designação por especialista, carga global por especialista).
|
| 349 |
-
fn selecionar_com_capacidade(
|
| 350 |
-
probs: &[Vec<f32>],
|
| 351 |
-
do_papel: &[usize],
|
| 352 |
-
n: usize,
|
| 353 |
-
n_top: usize,
|
| 354 |
-
capacidade: usize,
|
| 355 |
-
n_especialistas: usize,
|
| 356 |
-
) -> (Vec<(usize, Vec<usize>)>, Vec<usize>) {
|
| 357 |
-
let mut carga = vec![0usize; n_especialistas];
|
| 358 |
-
let mut designacao: Vec<(usize, Vec<usize>)> = Vec::new();
|
| 359 |
-
for &ei in do_papel.iter() {
|
| 360 |
-
// candidatos ordenados por prob do especialista ei (desc)
|
| 361 |
-
let mut cand: Vec<(usize, f32)> = (0..n).map(|i| (i, probs[i][ei])).collect();
|
| 362 |
-
cand.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
|
| 363 |
-
let mut escolhidos: Vec<usize> = Vec::new();
|
| 364 |
-
for (i, _) in cand {
|
| 365 |
-
if carga[ei] >= capacidade {
|
| 366 |
-
break;
|
| 367 |
-
}
|
| 368 |
-
// ei está no top-k(papel) do token i?
|
| 369 |
-
let mut ordem: Vec<(f32, usize)> =
|
| 370 |
-
do_papel.iter().map(|&g| (probs[i][g], g)).collect();
|
| 371 |
-
ordem.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
|
| 372 |
-
let top: Vec<usize> = ordem.iter().rev().take(n_top).map(|(_, g)| *g).collect();
|
| 373 |
-
if top.contains(&ei) {
|
| 374 |
-
escolhidos.push(i);
|
| 375 |
-
carga[ei] += 1;
|
| 376 |
-
}
|
| 377 |
-
}
|
| 378 |
-
if escolhidos.is_empty() {
|
| 379 |
-
continue;
|
| 380 |
-
}
|
| 381 |
-
designacao.push((ei, escolhidos));
|
| 382 |
-
}
|
| 383 |
-
(designacao, carga)
|
| 384 |
-
}
|
| 385 |
-
|
| 386 |
-
/// Aloca `capacidade_total` especialistas entre células com QE `qes`
|
| 387 |
-
/// proporcionalmente ao QE (Cauchy–Schwarz: minimiza Σ q_i²/c_i).
|
| 388 |
-
/// Devolve c_i ≥ 1 com Σ c_i = capacidade_total (se capacidade ≥ células).
|
| 389 |
-
pub fn alocar_por_qe(qes: &[f64], capacidade_total: usize) -> Vec<usize> {
|
| 390 |
-
let m = qes.len();
|
| 391 |
-
if m == 0 {
|
| 392 |
-
return Vec::new();
|
| 393 |
-
}
|
| 394 |
-
let soma: f64 = qes.iter().sum::<f64>().max(1e-12);
|
| 395 |
-
let mut c: Vec<usize> = qes
|
| 396 |
-
.iter()
|
| 397 |
-
.map(|q| ((q / soma) * capacidade_total as f64).round() as usize)
|
| 398 |
-
.collect();
|
| 399 |
-
// garante mínimo 1 e corrige a soma por maior resíduo
|
| 400 |
-
for ci in c.iter_mut() {
|
| 401 |
-
*ci = (*ci).max(1);
|
| 402 |
-
}
|
| 403 |
-
let mut total: usize = c.iter().sum();
|
| 404 |
-
while total > capacidade_total.max(m) {
|
| 405 |
-
// remove da maior alocação
|
| 406 |
-
let (mut imax, mut vmax) = (0usize, 0usize);
|
| 407 |
-
for (i, &v) in c.iter().enumerate() {
|
| 408 |
-
if v > vmax {
|
| 409 |
-
vmax = v;
|
| 410 |
-
imax = i;
|
| 411 |
-
}
|
| 412 |
-
}
|
| 413 |
-
if c[imax] > 1 {
|
| 414 |
-
c[imax] -= 1;
|
| 415 |
-
}
|
| 416 |
-
total -= 1;
|
| 417 |
-
}
|
| 418 |
-
while total < capacidade_total {
|
| 419 |
-
let (mut imax, mut vmax) = (0usize, 0.0f64);
|
| 420 |
-
for (i, (&v, &q)) in c.iter().zip(qes.iter()).enumerate() {
|
| 421 |
-
let res = q / (v as f64);
|
| 422 |
-
if res > vmax {
|
| 423 |
-
vmax = res;
|
| 424 |
-
imax = i;
|
| 425 |
-
}
|
| 426 |
-
}
|
| 427 |
-
c[imax] += 1;
|
| 428 |
-
total += 1;
|
| 429 |
-
}
|
| 430 |
-
c
|
| 431 |
-
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/moe_redirecionavel/teste_integrado.rs
DELETED
|
@@ -1,26 +0,0 @@
|
|
| 1 |
-
//! `moe_redirecionavel::teste_integrado` — extraído do monólito na v0.10.0
|
| 2 |
-
//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
|
| 3 |
-
|
| 4 |
-
use super::*;
|
| 5 |
-
|
| 6 |
-
|
| 7 |
-
#[cfg(test)]
|
| 8 |
-
mod teste_som_moe_integrado {
|
| 9 |
-
use super::*;
|
| 10 |
-
|
| 11 |
-
#[test]
|
| 12 |
-
fn debug_som_com_moe_caminho() {
|
| 13 |
-
let dev = Device::Cpu;
|
| 14 |
-
let dados_v: Vec<Vec<f64>> = (0..32).map(|i| (0..16).map(|j| (i * 7 + j * 3) as f64 / 100.0).collect()).collect();
|
| 15 |
-
let (n, d) = (dados_v.len(), 16);
|
| 16 |
-
let t = Tensor::from_vec(dados_v.into_iter().flatten().collect::<Vec<f64>>(), (n, d), &dev).unwrap()
|
| 17 |
-
.to_dtype(candle_core::DType::F32).unwrap();
|
| 18 |
-
let cfg = crate::som4d::CfgSom4D { nx: 2, ny: 2, nz: 2, nt: 2, ..Default::default() };
|
| 19 |
-
let som = crate::som4d::treinar_som4d(&t, &cfg, &dev).unwrap();
|
| 20 |
-
let centroides = som.prototipos.clone();
|
| 21 |
-
let r = refinar_som_com_moe(&t, ¢roides, 30, 1).unwrap();
|
| 22 |
-
println!("qe {} -> {} (wf) | uniforme {}", r.qe_antes, r.qe_depois, r.qe_alocacao_uniforme);
|
| 23 |
-
assert!(r.qe_depois < r.qe_antes, "corretor MoE reduz o QE");
|
| 24 |
-
assert!(r.mse_decodificador < r.qe_antes.powi(2), "redirect decodifica");
|
| 25 |
-
}
|
| 26 |
-
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/moe_redirecionavel/testes.rs
DELETED
|
@@ -1,209 +0,0 @@
|
|
| 1 |
-
//! `moe_redirecionavel::testes` — extraído do monólito na v0.10.0
|
| 2 |
-
//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
|
| 3 |
-
|
| 4 |
-
use super::*;
|
| 5 |
-
|
| 6 |
-
|
| 7 |
-
#[cfg(test)]
|
| 8 |
-
#[allow(deprecated)] // testes usam o oráculo fwd (bug v080-1) de propósito
|
| 9 |
-
mod testes {
|
| 10 |
-
use super::*;
|
| 11 |
-
|
| 12 |
-
fn dados_sinteticos(n: usize, d: usize, semente: u64) -> Tensor {
|
| 13 |
-
let mut rng = crate::rng::RngDeterministico::novo(semente);
|
| 14 |
-
let v: Vec<f32> = (0..n * d).map(|_| rng.normal(0.0, 1.0) as f32).collect();
|
| 15 |
-
Tensor::from_vec(v, (n, d), &Device::Cpu).unwrap()
|
| 16 |
-
}
|
| 17 |
-
|
| 18 |
-
#[test]
|
| 19 |
-
fn mr1_invariancia_sob_redirecionamento() {
|
| 20 |
-
let dev = Device::Cpu;
|
| 21 |
-
let x = dados_sinteticos(64, 16, 3);
|
| 22 |
-
let mut moe = MoeRedirecionavel::novo(16, 6, 2, 64, &dev).unwrap();
|
| 23 |
-
let s1 = moe.fwd(&x, Papel::Codificador).unwrap();
|
| 24 |
-
let perda_antes = s1.perda_aux.to_scalar::<f32>().unwrap() as f64;
|
| 25 |
-
let carga_antes: usize = s1.carga.iter().sum();
|
| 26 |
-
moe.redirecionar_todos();
|
| 27 |
-
// após trocar TODOS os papéis, a passada Decodificador usa os
|
| 28 |
-
// especialistas que eram do codificador — a perda auxiliar do
|
| 29 |
-
// SUBCONJUNTO é comparável (mesma distribuição de roteamento)
|
| 30 |
-
let s2 = moe.fwd(&x, Papel::Decodificador).unwrap();
|
| 31 |
-
let perda_depois = s2.perda_aux.to_scalar::<f32>().unwrap() as f64;
|
| 32 |
-
let carga_depois: usize = s2.carga.iter().sum();
|
| 33 |
-
assert_eq!(carga_antes, carga_depois, "capacidade total conservada (M-R1)");
|
| 34 |
-
assert!(
|
| 35 |
-
(perda_antes - perda_depois).abs() < 2.0 + 1e-6,
|
| 36 |
-
"perda auxiliar da família conservada: {perda_antes:.4} vs {perda_depois:.4}"
|
| 37 |
-
);
|
| 38 |
-
}
|
| 39 |
-
|
| 40 |
-
#[test]
|
| 41 |
-
fn mr2_neutralidade_no_nascimento() {
|
| 42 |
-
let dev = Device::Cpu;
|
| 43 |
-
let x = dados_sinteticos(32, 8, 5);
|
| 44 |
-
let moe = MoeRedirecionavel::novo(8, 4, 2, 32, &dev).unwrap();
|
| 45 |
-
let g = moe.atencao.gate.as_tensor().to_scalar::<f32>().unwrap();
|
| 46 |
-
assert!(g == 0.0, "gate nasce zero");
|
| 47 |
-
let y = moe.atencao.fwd(&x).unwrap();
|
| 48 |
-
let dif = (&y - &x).unwrap().sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap();
|
| 49 |
-
assert!(dif == 0.0, "y = x bit-a-bit no nascimento (dif={dif})");
|
| 50 |
-
}
|
| 51 |
-
|
| 52 |
-
#[test]
|
| 53 |
-
fn mr3_paralelismo_e_determinismo() {
|
| 54 |
-
let dev = Device::Cpu;
|
| 55 |
-
let x = dados_sinteticos(96, 24, 7);
|
| 56 |
-
let moe = MoeRedirecionavel::novo(24, 8, 2, 96, &dev).unwrap();
|
| 57 |
-
let (_enc, _dec, t_par, t_seq, speedup) = moe.fwd_ambos_par(&x).unwrap();
|
| 58 |
-
// determinismo já garantido por assert interno; speedup registrado
|
| 59 |
-
assert!(t_par > 0.0 && t_seq > 0.0);
|
| 60 |
-
let _ = speedup;
|
| 61 |
-
}
|
| 62 |
-
|
| 63 |
-
#[test]
|
| 64 |
-
fn mr5_water_filling_minimiza_cota() {
|
| 65 |
-
// cota Σ q_i²/c_i: water-filling ≤ uniforme (Cauchy–Schwarz)
|
| 66 |
-
let qes = vec![0.2, 0.5, 1.0, 0.3];
|
| 67 |
-
let c_wf = alocar_por_qe(&qes, 8);
|
| 68 |
-
let c_un = vec![2usize; 4];
|
| 69 |
-
let f = |c: &[usize]| qes.iter().zip(c).map(|(q, ci)| q * q / *ci as f64).sum::<f64>();
|
| 70 |
-
assert!(
|
| 71 |
-
f(&c_wf) <= f(&c_un) + 1e-9,
|
| 72 |
-
"water-filling {c_wf:?} (cota {:.4}) deve ≤ uniforme (cota {:.4})",
|
| 73 |
-
f(&c_wf), f(&c_un)
|
| 74 |
-
);
|
| 75 |
-
assert_eq!(c_wf.iter().sum::<usize>(), 8);
|
| 76 |
-
}
|
| 77 |
-
|
| 78 |
-
#[test]
|
| 79 |
-
fn jepa_moe_aprende() {
|
| 80 |
-
let x = dados_sinteticos(64, 12, 11);
|
| 81 |
-
let r = treinar_jepa_com_moe(&x, "moe", 60, 0.5, 42).unwrap();
|
| 82 |
-
assert!(r.perda_pred_final < r.perda_pred_inicial, "perda preditiva cai");
|
| 83 |
-
}
|
| 84 |
-
|
| 85 |
-
/// **M-R6 (v0.8.0):** equivalência de VALORES entre `fwd` e
|
| 86 |
-
/// `forward` — mesma seleção (auxiliar compartilhado), mesma
|
| 87 |
-
/// saída, mesma perda auxiliar, mesma carga/descartados.
|
| 88 |
-
#[test]
|
| 89 |
-
fn mr6_equivalencia_de_valores() {
|
| 90 |
-
let dev = Device::Cpu;
|
| 91 |
-
for (n, d, e, k, cap, seed) in [
|
| 92 |
-
(64usize, 16usize, 6usize, 2usize, 64usize, 3u64),
|
| 93 |
-
(96, 24, 8, 2, 96, 5),
|
| 94 |
-
(48, 12, 4, 1, 24, 9), // capacidade apertada: força descartados
|
| 95 |
-
] {
|
| 96 |
-
let x = dados_sinteticos(n, d, seed);
|
| 97 |
-
let moe = MoeRedirecionavel::novo(d, e, k, cap, &dev).unwrap();
|
| 98 |
-
let s_ref = moe.fwd(&x, Papel::Codificador).unwrap();
|
| 99 |
-
let s_vet = moe.forward(&x, Papel::Codificador).unwrap();
|
| 100 |
-
assert_eq!(s_ref.carga, s_vet.carga, "M-R6: mesma carga (n={n})");
|
| 101 |
-
assert_eq!(s_ref.usados, s_vet.usados, "M-R6: mesmos usados");
|
| 102 |
-
assert_eq!(s_ref.descartados, s_vet.descartados, "M-R6: mesmos descartados");
|
| 103 |
-
let dif = (&s_ref.saida - &s_vet.saida).unwrap()
|
| 104 |
-
.abs().unwrap().max_all().unwrap().to_scalar::<f32>().unwrap();
|
| 105 |
-
assert!(dif < 1e-4, "M-R6: max|Δsaída| = {dif} (n={n}, cap={cap})");
|
| 106 |
-
let pa = s_ref.perda_aux.to_scalar::<f32>().unwrap();
|
| 107 |
-
let pb = s_vet.perda_aux.to_scalar::<f32>().unwrap();
|
| 108 |
-
assert!(
|
| 109 |
-
(pa - pb).abs() < 1e-4,
|
| 110 |
-
"M-R6: perda auxiliar {pa:.6} vs {pb:.6} (n={n})"
|
| 111 |
-
);
|
| 112 |
-
}
|
| 113 |
-
}
|
| 114 |
-
|
| 115 |
-
/// **M-R7 (v0.8.0):** restauração do fluxo de gradiente — bug v080-1.
|
| 116 |
-
/// Com a `fwd` (referência de valores) os especialistas e o roteador
|
| 117 |
-
/// NÃO recebem gradiente (grafo seccionado por to_vec2/from_vec); com
|
| 118 |
-
/// a `forward` TODOS recebem (index_add/index_select vivos).
|
| 119 |
-
#[test]
|
| 120 |
-
fn mr7_restauracao_do_gradiente() {
|
| 121 |
-
let dev = Device::Cpu;
|
| 122 |
-
let x = dados_sinteticos(48, 12, 13);
|
| 123 |
-
let moe = MoeRedirecionavel::novo(12, 6, 2, 48, &dev).unwrap();
|
| 124 |
-
let norma_grads = |vetorizada: bool| -> (f64, f64) {
|
| 125 |
-
let s = if vetorizada {
|
| 126 |
-
moe.forward(&x, Papel::Codificador).unwrap()
|
| 127 |
-
} else {
|
| 128 |
-
moe.fwd(&x, Papel::Codificador).unwrap()
|
| 129 |
-
};
|
| 130 |
-
let perda = s.saida.sqr().unwrap().sum_all().unwrap();
|
| 131 |
-
let grads = perda.backward().unwrap();
|
| 132 |
-
let mut n_roteador = 0.0f64;
|
| 133 |
-
for v in moe.roteador.vars() {
|
| 134 |
-
if let Some(g) = grads.get(&v) {
|
| 135 |
-
n_roteador += g.sqr().unwrap().sum_all().unwrap()
|
| 136 |
-
.to_scalar::<f32>().unwrap() as f64;
|
| 137 |
-
}
|
| 138 |
-
}
|
| 139 |
-
let mut n_experts = 0.0f64;
|
| 140 |
-
for e in &moe.especialistas {
|
| 141 |
-
for v in e.vars() {
|
| 142 |
-
if let Some(g) = grads.get(&v) {
|
| 143 |
-
n_experts += g.sqr().unwrap().sum_all().unwrap()
|
| 144 |
-
.to_scalar::<f32>().unwrap() as f64;
|
| 145 |
-
}
|
| 146 |
-
}
|
| 147 |
-
}
|
| 148 |
-
(n_roteador, n_experts)
|
| 149 |
-
};
|
| 150 |
-
// (a) o bug v080-1 é REAL: na fwd, roteador e especialistas têm
|
| 151 |
-
// gradiente ZERO (grafo seccionado) — documentado, não corrigido na
|
| 152 |
-
// fwd (referência de valores preservada por decisão de projeto)
|
| 153 |
-
let (r_ref, e_ref) = norma_grads(false);
|
| 154 |
-
assert!(
|
| 155 |
-
r_ref == 0.0 && e_ref == 0.0,
|
| 156 |
-
"M-R7: bug v080-1 documentado — fwd secciona o grafo (roteador {r_ref}, experts {e_ref})"
|
| 157 |
-
);
|
| 158 |
-
// (b) a correção: na vetorizada, TODOS recebem gradiente
|
| 159 |
-
let (r_vet, e_vet) = norma_grads(true);
|
| 160 |
-
assert!(
|
| 161 |
-
r_vet > 0.0,
|
| 162 |
-
"M-R7: roteador recebe gradiente na vetorizada ({r_vet})"
|
| 163 |
-
);
|
| 164 |
-
assert!(
|
| 165 |
-
e_vet > 0.0,
|
| 166 |
-
"M-R7: especialistas recebem gradiente na vetorizada ({e_vet})"
|
| 167 |
-
);
|
| 168 |
-
}
|
| 169 |
-
|
| 170 |
-
/// **M-R8 (v0.8.0):** fim-a-fim — com a vetorizada, o treino REALMENTE
|
| 171 |
-
/// atualiza os pesos dos especialistas (regressão do bug v080-1: antes
|
| 172 |
-
/// só a atenção própria treinava no braço MoE).
|
| 173 |
-
#[test]
|
| 174 |
-
fn mr8_treino_atualiza_especialistas() {
|
| 175 |
-
let dev = Device::Cpu;
|
| 176 |
-
let x = dados_sinteticos(48, 12, 17);
|
| 177 |
-
let moe = MoeRedirecionavel::novo(12, 6, 2, 48, &dev).unwrap();
|
| 178 |
-
// snapshot com dados PRÓPRIOS (to_vec1) — detach() compartilha o
|
| 179 |
-
// storage e o set() do otimizador sobrescreveria a "cópia"
|
| 180 |
-
let snapshot: Vec<Vec<f32>> = moe
|
| 181 |
-
.especialistas
|
| 182 |
-
.iter()
|
| 183 |
-
.map(|e| {
|
| 184 |
-
e.vars()[0].as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap()
|
| 185 |
-
})
|
| 186 |
-
.collect();
|
| 187 |
-
// treino curto com gradiente fluindo
|
| 188 |
-
let vars = moe.vars();
|
| 189 |
-
let mut opt = crate::treino::AdamWManual::novo(vars.clone(), 3e-3, 0.0);
|
| 190 |
-
for _ in 0..5 {
|
| 191 |
-
let s = moe.forward(&x, Papel::Codificador).unwrap();
|
| 192 |
-
let perda = s.saida.sqr().unwrap().sum_all().unwrap();
|
| 193 |
-
let grads = crate::treino::grads_achatados(&perda, &vars).unwrap();
|
| 194 |
-
opt.passo(grads);
|
| 195 |
-
}
|
| 196 |
-
let mut delta_max = 0.0f64;
|
| 197 |
-
for (e, antes) in moe.especialistas.iter().zip(snapshot.iter()) {
|
| 198 |
-
let agora = e.vars()[0].as_tensor().flatten_all().unwrap()
|
| 199 |
-
.to_vec1::<f32>().unwrap();
|
| 200 |
-
let dif = agora.iter().zip(antes.iter()).map(|(a, b)| (a - b).abs()).fold(0f32, f32::max);
|
| 201 |
-
delta_max = delta_max.max(dif as f64);
|
| 202 |
-
}
|
| 203 |
-
let _ = &vars;
|
| 204 |
-
assert!(
|
| 205 |
-
delta_max > 0.0,
|
| 206 |
-
"M-R8: especialistas devem mudar no treino (delta_max={delta_max})"
|
| 207 |
-
);
|
| 208 |
-
}
|
| 209 |
-
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/moe_redirecionavel/treino.rs
DELETED
|
@@ -1,463 +0,0 @@
|
|
| 1 |
-
//! `moe_redirecionavel::treino` — extraído do monólito na v0.10.0
|
| 2 |
-
//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2).
|
| 3 |
-
|
| 4 |
-
use super::*;
|
| 5 |
-
|
| 6 |
-
|
| 7 |
-
// ---------------------------------------------------------------------------
|
| 8 |
-
// Aplicação JEPA — codificador/preditor redirecionáveis com MoE
|
| 9 |
-
// ---------------------------------------------------------------------------
|
| 10 |
-
|
| 11 |
-
pub struct RelatorioJepaMoe {
|
| 12 |
-
pub modo: &'static str,
|
| 13 |
-
pub perda_pred_inicial: f64,
|
| 14 |
-
pub perda_pred_final: f64,
|
| 15 |
-
pub perda_vc_final: f64,
|
| 16 |
-
pub std_emb: f64,
|
| 17 |
-
pub carga_max: usize,
|
| 18 |
-
pub descartados: usize,
|
| 19 |
-
}
|
| 20 |
-
|
| 21 |
-
/// Treino JEPA compacto com três braços (ablação honesta):
|
| 22 |
-
/// - `"pequena"`: codificador/preditor MLP simples (baseline);
|
| 23 |
-
/// - `"densa"`: MLP com o TOTAL de parâmetros dos especialistas (capacidade
|
| 24 |
-
/// equiparada, SEM roteamento — isola o ganho do roteamento);
|
| 25 |
-
/// - `"moe"`: `MoeRedirecionavel` nos dois caminhos (Codificador no
|
| 26 |
-
/// codificador, Decodificador no preditor) com atenção própria.
|
| 27 |
-
pub fn treinar_jepa_com_moe(
|
| 28 |
-
patches: &Tensor,
|
| 29 |
-
modo: &'static str,
|
| 30 |
-
passos: usize,
|
| 31 |
-
frac_mascara: f64,
|
| 32 |
-
semente: u64,
|
| 33 |
-
) -> Result<RelatorioJepaMoe> {
|
| 34 |
-
let dev = patches.device();
|
| 35 |
-
let n = patches.dim(0)?;
|
| 36 |
-
let d = patches.dim(1)?;
|
| 37 |
-
let mut rng = RngDeterministico::novo(semente);
|
| 38 |
-
// alvo = patches originais (detach); contexto = patches mascarados
|
| 39 |
-
let alvo = patches.detach();
|
| 40 |
-
let contexto = {
|
| 41 |
-
let mut v = patches.flatten_all()?.to_vec1::<f32>()?;
|
| 42 |
-
for x in v.iter_mut() {
|
| 43 |
-
if rng.uniforme() < frac_mascara {
|
| 44 |
-
*x = 0.0;
|
| 45 |
-
}
|
| 46 |
-
}
|
| 47 |
-
Tensor::from_vec(v, (n, d), &dev)?
|
| 48 |
-
};
|
| 49 |
-
let e = 4usize; // especialistas por papel no braço moe
|
| 50 |
-
let n_top = 2;
|
| 51 |
-
let capacidade = n;
|
| 52 |
-
|
| 53 |
-
// braços
|
| 54 |
-
enum Braco {
|
| 55 |
-
Pequena(MlpJepa, MlpJepa),
|
| 56 |
-
Densa(MlpJepa, MlpJepa),
|
| 57 |
-
Moe(MoeRedirecionavel),
|
| 58 |
-
}
|
| 59 |
-
let braco = match modo {
|
| 60 |
-
"pequena" => Braco::Pequena(
|
| 61 |
-
MlpJepa::novo(d, 2 * d, d, &dev)?,
|
| 62 |
-
MlpJepa::novo(d, 2 * d, d, &dev)?,
|
| 63 |
-
),
|
| 64 |
-
"densa" => {
|
| 65 |
-
// capacidade equiparada: oculta = soma das ocultas dos especialistas
|
| 66 |
-
let d_oculta = 2 * d * e;
|
| 67 |
-
Braco::Densa(
|
| 68 |
-
MlpJepa::novo(d, d_oculta, d, &dev)?,
|
| 69 |
-
MlpJepa::novo(d, d_oculta, d, &dev)?,
|
| 70 |
-
)
|
| 71 |
-
}
|
| 72 |
-
_ => Braco::Moe(MoeRedirecionavel::novo(d, 2 * e, n_top, capacidade, &dev)?),
|
| 73 |
-
};
|
| 74 |
-
|
| 75 |
-
let perda_de = |b: &Braco, x: &Tensor| -> Result<(Tensor, Tensor, usize)> {
|
| 76 |
-
match b {
|
| 77 |
-
Braco::Pequena(e1, p1) => {
|
| 78 |
-
let z = e1.fwd(x)?;
|
| 79 |
-
let yh = p1.fwd(&z)?;
|
| 80 |
-
let dif = (&yh - &alvo)?;
|
| 81 |
-
Ok(((dif.sqr()?.sum_all()? / (n as f64 * d as f64))?,
|
| 82 |
-
z.sqr()?.mean_all()?, 0))
|
| 83 |
-
}
|
| 84 |
-
Braco::Densa(e1, p1) => {
|
| 85 |
-
let z = e1.fwd(x)?;
|
| 86 |
-
let yh = p1.fwd(&z)?;
|
| 87 |
-
let dif = (&yh - &alvo)?;
|
| 88 |
-
Ok(((dif.sqr()?.sum_all()? / (n as f64 * d as f64))?,
|
| 89 |
-
z.sqr()?.mean_all()?, 0))
|
| 90 |
-
}
|
| 91 |
-
Braco::Moe(m) => {
|
| 92 |
-
// v0.9.0: forward (ex-fwd_vetorizado) — gradiente flui aos
|
| 93 |
-
// especialistas e ao roteador (a fwd seccionava o grafo)
|
| 94 |
-
let s_enc = m.forward(x, Papel::Codificador)?;
|
| 95 |
-
let s_dec = m.forward(&s_enc.saida, Papel::Decodificador)?;
|
| 96 |
-
let dif = (&s_dec.saida - &alvo)?;
|
| 97 |
-
let lp = (dif.sqr()?.sum_all()? / (n as f64 * d as f64))?;
|
| 98 |
-
// perda total = preditiva + aux balanceamento (ambos papéis)
|
| 99 |
-
let lt = (lp.affine(1.0, 0.0)? + s_enc.perda_aux.affine(m.lambda_aux, 0.0)?
|
| 100 |
-
+ s_dec.perda_aux.affine(m.lambda_aux, 0.0)?)?;
|
| 101 |
-
let carga_max = s_enc.carga.iter().copied().fold(0, usize::max)
|
| 102 |
-
.max(s_dec.carga.iter().copied().fold(0, usize::max));
|
| 103 |
-
Ok((lt, lp, carga_max))
|
| 104 |
-
}
|
| 105 |
-
}
|
| 106 |
-
};
|
| 107 |
-
|
| 108 |
-
let (mut opt, vars): (AdamWManual, Vec<Var>) = match &braco {
|
| 109 |
-
Braco::Pequena(a, b) => {
|
| 110 |
-
let v = [a.vars(), b.vars()].concat();
|
| 111 |
-
(AdamWManual::novo(v.clone(), 3e-3, 0.0), v)
|
| 112 |
-
}
|
| 113 |
-
Braco::Densa(a, b) => {
|
| 114 |
-
let v = [a.vars(), b.vars()].concat();
|
| 115 |
-
(AdamWManual::novo(v.clone(), 3e-3, 0.0), v)
|
| 116 |
-
}
|
| 117 |
-
Braco::Moe(m) => (AdamWManual::novo(m.vars(), 3e-3, 0.0), m.vars()),
|
| 118 |
-
};
|
| 119 |
-
// atenção própria: gate nasce 0; sobe 1 passo em 8 (aquecimento honesto
|
| 120 |
-
// do mecanismo — T-P5 análogo: neutralidade no nascimento, gradiente flui)
|
| 121 |
-
if let Braco::Moe(m) = &braco {
|
| 122 |
-
let g0 = m.atencao.gate.as_tensor().to_scalar::<f32>()? as f64;
|
| 123 |
-
let _ = g0;
|
| 124 |
-
}
|
| 125 |
-
|
| 126 |
-
let (l0, _, _) = perda_de(&braco, &contexto)?;
|
| 127 |
-
let perda_inicial = l0.to_scalar::<f32>()? as f64;
|
| 128 |
-
let mut perda_final = perda_inicial;
|
| 129 |
-
let mut vc_final = 0.0;
|
| 130 |
-
let mut carga_max = 0usize;
|
| 131 |
-
let mut descartados = 0usize;
|
| 132 |
-
let mut std_emb = 0.0;
|
| 133 |
-
for passo in 0..passos {
|
| 134 |
-
let (lt, lp, cm) = perda_de(&braco, &contexto)?;
|
| 135 |
-
if let Braco::Moe(m) = &braco {
|
| 136 |
-
// abre o gate gradualmente (0 → 1 em 25% dos passos)
|
| 137 |
-
let alvo_g = ((passo as f64 / (passos as f64 / 4.0).max(1.0)).min(1.0)) as f32;
|
| 138 |
-
let g_atual = m.atencao.gate.as_tensor().to_scalar::<f32>()? as f64;
|
| 139 |
-
if (alvo_g as f64 - g_atual).abs() > 1e-9 {
|
| 140 |
-
m.atencao.gate.set(&Tensor::new(alvo_g, &dev)?)?;
|
| 141 |
-
}
|
| 142 |
-
}
|
| 143 |
-
let grads = crate::treino::grads_achatados(<, &vars)?;
|
| 144 |
-
AdamWManual::clipar(&mut grads.clone(), 1.0);
|
| 145 |
-
let mut g2 = grads;
|
| 146 |
-
AdamWManual::clipar(&mut g2, 5.0);
|
| 147 |
-
opt.passo(g2);
|
| 148 |
-
perda_final = lp.to_scalar::<f32>()? as f64;
|
| 149 |
-
carga_max = cm;
|
| 150 |
-
// VC / std do embedding (para o relatório)
|
| 151 |
-
let (_, vc, _) = perda_de(&braco, &contexto)?;
|
| 152 |
-
vc_final = vc.to_scalar::<f32>()? as f64;
|
| 153 |
-
std_emb = {
|
| 154 |
-
let z = match &braco {
|
| 155 |
-
Braco::Pequena(a, _) => a.fwd(&contexto)?,
|
| 156 |
-
Braco::Densa(a, _) => a.fwd(&contexto)?,
|
| 157 |
-
Braco::Moe(m) => m.forward(&contexto, Papel::Codificador)?.saida,
|
| 158 |
-
};
|
| 159 |
-
z.flatten_all()?.to_vec1::<f32>()?.iter().map(|x| *x as f64).collect::<Vec<f64>>()
|
| 160 |
-
.chunks(n).map(|c| {
|
| 161 |
-
let m = c.iter().sum::<f64>() / c.len() as f64;
|
| 162 |
-
(c.iter().map(|x| (x - m).powi(2)).sum::<f64>() / c.len() as f64).sqrt()
|
| 163 |
-
}).sum::<f64>() / n as f64
|
| 164 |
-
};
|
| 165 |
-
}
|
| 166 |
-
if let Braco::Moe(m) = &braco {
|
| 167 |
-
let s = m.forward(&contexto, Papel::Codificador)?;
|
| 168 |
-
descartados = s.descartados;
|
| 169 |
-
}
|
| 170 |
-
Ok(RelatorioJepaMoe {
|
| 171 |
-
modo,
|
| 172 |
-
perda_pred_inicial: perda_inicial,
|
| 173 |
-
perda_pred_final: perda_final,
|
| 174 |
-
perda_vc_final: vc_final,
|
| 175 |
-
std_emb,
|
| 176 |
-
carga_max,
|
| 177 |
-
descartados,
|
| 178 |
-
})
|
| 179 |
-
}
|
| 180 |
-
|
| 181 |
-
// ---------------------------------------------------------------------------
|
| 182 |
-
// Aplicação SOM — refinamento residual com alocação por QE (M-R5)
|
| 183 |
-
// ---------------------------------------------------------------------------
|
| 184 |
-
|
| 185 |
-
pub struct RelatorioSomMoe {
|
| 186 |
-
pub qe_antes: f64,
|
| 187 |
-
pub qe_depois: f64,
|
| 188 |
-
pub qe_alocacao_uniforme: f64,
|
| 189 |
-
pub carga_por_celula: Vec<usize>,
|
| 190 |
-
pub tempo_treino_s: f64,
|
| 191 |
-
/// qualidade da DECODIFICAÇÃO após redirecionamento (mse w_bmu → x).
|
| 192 |
-
pub mse_decodificador: f64,
|
| 193 |
-
}
|
| 194 |
-
|
| 195 |
-
/// Refina um SOM 4D treinado com um MoE redirecionável:
|
| 196 |
-
/// 1. aloca especialistas por célula ∝ QE (water-filling — M-R5);
|
| 197 |
-
/// 2. treina o papel Codificador como corretor residual
|
| 198 |
-
/// `x̂ = w_bmu(x) + E(x)`;
|
| 199 |
-
/// 3. mede QE′; repete com alocação uniforme (ablação do water-filling);
|
| 200 |
-
/// 4. REDIRECIONA os especialistas para Decodificador e treina
|
| 201 |
-
/// `x̂ = E(w_bmu)` (reconstrução a partir do código) — mede o MSE.
|
| 202 |
-
pub fn refinar_som_com_moe(
|
| 203 |
-
dados: &Tensor,
|
| 204 |
-
centroides: &[Vec<f64>],
|
| 205 |
-
passos: usize,
|
| 206 |
-
semente: u64,
|
| 207 |
-
) -> Result<RelatorioSomMoe> {
|
| 208 |
-
use std::time::Instant;
|
| 209 |
-
let t0 = Instant::now();
|
| 210 |
-
let dev = dados.device();
|
| 211 |
-
let n = dados.dim(0)?;
|
| 212 |
-
let d = dados.dim(1)?;
|
| 213 |
-
let m = centroides.len();
|
| 214 |
-
// BMU + QE por célula (tolera F32/F64)
|
| 215 |
-
let dados_v: Vec<Vec<f64>> = match dados.to_vec2::<f64>() {
|
| 216 |
-
Ok(v) => v,
|
| 217 |
-
Err(_) => dados
|
| 218 |
-
.to_vec2::<f32>()?
|
| 219 |
-
.iter()
|
| 220 |
-
.map(|l| l.iter().map(|x| *x as f64).collect())
|
| 221 |
-
.collect(),
|
| 222 |
-
};
|
| 223 |
-
let bmu: Vec<usize> = dados_v
|
| 224 |
-
.iter()
|
| 225 |
-
.map(|x| {
|
| 226 |
-
centroides
|
| 227 |
-
.iter()
|
| 228 |
-
.enumerate()
|
| 229 |
-
.min_by(|(i, a), (j, b)| {
|
| 230 |
-
let da: f64 = a.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
|
| 231 |
-
let db: f64 = b.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
|
| 232 |
-
da.partial_cmp(&db).unwrap_or(std::cmp::Ordering::Equal).then(i.cmp(j))
|
| 233 |
-
})
|
| 234 |
-
.map(|(i, _)| i)
|
| 235 |
-
.unwrap_or(0)
|
| 236 |
-
})
|
| 237 |
-
.collect();
|
| 238 |
-
let mut qe_cel = vec![0f64; m];
|
| 239 |
-
let mut cont_cel = vec![0usize; m];
|
| 240 |
-
for (i, b) in bmu.iter().enumerate() {
|
| 241 |
-
let dist: f64 = centroides[*b].iter().zip(&dados_v[i]).map(|(w, v)| (w - v).powi(2)).sum();
|
| 242 |
-
qe_cel[*b] += dist.sqrt();
|
| 243 |
-
cont_cel[*b] += 1;
|
| 244 |
-
}
|
| 245 |
-
for i in 0..m {
|
| 246 |
-
if cont_cel[i] > 0 {
|
| 247 |
-
qe_cel[i] /= cont_cel[i] as f64;
|
| 248 |
-
}
|
| 249 |
-
}
|
| 250 |
-
let qe_antes: f64 = dados_v
|
| 251 |
-
.iter()
|
| 252 |
-
.enumerate()
|
| 253 |
-
.map(|(i, b)| {
|
| 254 |
-
let w = ¢roides[bmu[i]];
|
| 255 |
-
(w.iter().zip(b).map(|(a, v)| (a - v).powi(2)).sum::<f64>()).sqrt()
|
| 256 |
-
})
|
| 257 |
-
.sum::<f64>()
|
| 258 |
-
/ n as f64;
|
| 259 |
-
|
| 260 |
-
// ---------- braço water-filling ----------
|
| 261 |
-
// capacidade = m células + 8 especialistas EXTRA distribuídos ∝ QE
|
| 262 |
-
// (com C < m o water-filling degenera em uniforme — mínimo 1 por célula)
|
| 263 |
-
let capacidade_total = m + 8;
|
| 264 |
-
let aloca_wf = alocar_por_qe(&qe_cel, capacidade_total);
|
| 265 |
-
let qe_wf = treinar_corretor(dados, centroides, &bmu, &aloca_wf, passos, semente, &dev)?;
|
| 266 |
-
// ---------- braço uniforme (ablação: MESMO total e MESMA semente —
|
| 267 |
-
// única diferença é a alocação; round-robin soma exatamente C) ----------
|
| 268 |
-
let aloca_un = {
|
| 269 |
-
let mut a = vec![1usize; m];
|
| 270 |
-
let mut i = 0usize;
|
| 271 |
-
while a.iter().sum::<usize>() < capacidade_total {
|
| 272 |
-
a[i % m] += 1;
|
| 273 |
-
i += 1;
|
| 274 |
-
}
|
| 275 |
-
a
|
| 276 |
-
};
|
| 277 |
-
let qe_un = treinar_corretor(dados, centroides, &bmu, &aloca_un, passos, semente, &dev)?;
|
| 278 |
-
|
| 279 |
-
// ---------- redirecionamento → decodificador ----------
|
| 280 |
-
// mesma pool de especialistas, agora aprendendo w_bmu → x
|
| 281 |
-
let mse_dec = treinar_decodificador(dados, centroides, &bmu, &aloca_wf, passos, semente + 2, &dev)?;
|
| 282 |
-
|
| 283 |
-
Ok(RelatorioSomMoe {
|
| 284 |
-
qe_antes,
|
| 285 |
-
qe_depois: qe_wf,
|
| 286 |
-
qe_alocacao_uniforme: qe_un,
|
| 287 |
-
carga_por_celula: aloca_wf,
|
| 288 |
-
tempo_treino_s: t0.elapsed().as_secs_f64(),
|
| 289 |
-
mse_decodificador: mse_dec,
|
| 290 |
-
})
|
| 291 |
-
}
|
| 292 |
-
|
| 293 |
-
/// Corretor residual: x̂ = w_bmu + E_{célula}(x). Treina com AdamW.
|
| 294 |
-
fn treinar_corretor(
|
| 295 |
-
dados: &Tensor,
|
| 296 |
-
centroides: &[Vec<f64>],
|
| 297 |
-
bmu: &[usize],
|
| 298 |
-
alocacao: &[usize],
|
| 299 |
-
passos: usize,
|
| 300 |
-
semente: u64,
|
| 301 |
-
dev: &Device,
|
| 302 |
-
) -> Result<f64> {
|
| 303 |
-
let n = dados.dim(0)?;
|
| 304 |
-
let d = dados.dim(1)?;
|
| 305 |
-
// um "especialista" = MlpJepa por CÉLULA (capacidade alocada = nº de
|
| 306 |
-
// especialistas extra treinados nessa célula, somados em ensemble)
|
| 307 |
-
let n_esp_tot: usize = alocacao.iter().sum();
|
| 308 |
-
let mut ensembles: Vec<Vec<MlpJepa>> = Vec::with_capacity(centroides.len());
|
| 309 |
-
for c in alocacao {
|
| 310 |
-
let mut v = Vec::new();
|
| 311 |
-
for _ in 0..(*c).max(1) {
|
| 312 |
-
v.push(MlpJepa::novo(d, 4 * d, d, dev)?);
|
| 313 |
-
}
|
| 314 |
-
ensembles.push(v);
|
| 315 |
-
}
|
| 316 |
-
let mut vars: Vec<Var> = Vec::new();
|
| 317 |
-
for ens in &ensembles {
|
| 318 |
-
for e in ens {
|
| 319 |
-
vars.extend(e.vars());
|
| 320 |
-
}
|
| 321 |
-
}
|
| 322 |
-
let mut opt = AdamWManual::novo(vars.clone(), 3e-3, 0.0);
|
| 323 |
-
// tensores de apoio
|
| 324 |
-
let w_bmu = {
|
| 325 |
-
let v: Vec<f32> = (0..n).flat_map(|i| centroides[bmu[i]].iter().map(|x| *x as f32).collect::<Vec<f32>>()).collect();
|
| 326 |
-
Tensor::from_vec(v, (n, d), dev)?
|
| 327 |
-
};
|
| 328 |
-
let alvo_res = (dados - &w_bmu)?;
|
| 329 |
-
for _ in 0..passos {
|
| 330 |
-
let mut soma = Tensor::zeros((), candle_core::DType::F32, dev)?;
|
| 331 |
-
for (i, ens) in ensembles.iter().enumerate() {
|
| 332 |
-
// tokens da célula i
|
| 333 |
-
let idx: Vec<u32> = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect();
|
| 334 |
-
if idx.is_empty() {
|
| 335 |
-
continue;
|
| 336 |
-
}
|
| 337 |
-
let m_idx = idx.len();
|
| 338 |
-
let it = Tensor::from_vec(idx, (m_idx,), dev)?;
|
| 339 |
-
let x_c = dados.index_select(&it, 0)?;
|
| 340 |
-
let r_c = alvo_res.index_select(&it, 0)?;
|
| 341 |
-
// ensemble: média das saídas
|
| 342 |
-
let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?;
|
| 343 |
-
for e in ens {
|
| 344 |
-
y = (y.affine(1.0, 0.0)? + e.fwd(&x_c)?.affine(1.0, 0.0)?)?;
|
| 345 |
-
}
|
| 346 |
-
let k = ens.len() as f64;
|
| 347 |
-
let yh = y.affine(1.0 / k, 0.0)?;
|
| 348 |
-
let dif = (&yh - &r_c)?;
|
| 349 |
-
soma = (soma.affine(1.0, 0.0)? + dif.sqr()?.sum_all()?.affine(1.0 / (n as f64 * d as f64), 0.0)?)?;
|
| 350 |
-
}
|
| 351 |
-
let _ = n_esp_tot;
|
| 352 |
-
let grads = crate::treino::grads_achatados(&soma, &vars)?;
|
| 353 |
-
let mut g = grads;
|
| 354 |
-
AdamWManual::clipar(&mut g, 5.0);
|
| 355 |
-
opt.passo(g);
|
| 356 |
-
}
|
| 357 |
-
// QE refinado
|
| 358 |
-
let mut qe = 0f64;
|
| 359 |
-
for (i, ens) in ensembles.iter().enumerate() {
|
| 360 |
-
let idx: Vec<u32> = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect();
|
| 361 |
-
if idx.is_empty() {
|
| 362 |
-
continue;
|
| 363 |
-
}
|
| 364 |
-
let m_idx = idx.len();
|
| 365 |
-
let it = Tensor::from_vec(idx, (m_idx,), dev)?;
|
| 366 |
-
let x_c = dados.index_select(&it, 0)?;
|
| 367 |
-
let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?;
|
| 368 |
-
for e in ens {
|
| 369 |
-
y = (y.affine(1.0, 0.0)? + e.fwd(&x_c)?.affine(1.0, 0.0)?)?;
|
| 370 |
-
}
|
| 371 |
-
let k = ens.len() as f64;
|
| 372 |
-
let yh = y.affine(1.0 / k, 0.0)?;
|
| 373 |
-
let xhat = (w_bmu.index_select(&it, 0)? + &yh)?;
|
| 374 |
-
let dif = (&x_c - &xhat)?;
|
| 375 |
-
qe += dif.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
|
| 376 |
-
}
|
| 377 |
-
Ok((qe / (n as f64 * d as f64)).sqrt() * (d as f64).sqrt()) // QE médio por ponto (norma L2)
|
| 378 |
-
}
|
| 379 |
-
|
| 380 |
-
/// Decodificador (pós-redirecionamento): x̂ = E(w_bmu) — reconstrução
|
| 381 |
-
/// a partir apenas do código (centróide). Mede o MSE final.
|
| 382 |
-
fn treinar_decodificador(
|
| 383 |
-
dados: &Tensor,
|
| 384 |
-
centroides: &[Vec<f64>],
|
| 385 |
-
bmu: &[usize],
|
| 386 |
-
alocacao: &[usize],
|
| 387 |
-
passos: usize,
|
| 388 |
-
semente: u64,
|
| 389 |
-
dev: &Device,
|
| 390 |
-
) -> Result<f64> {
|
| 391 |
-
let _ = semente;
|
| 392 |
-
let n = dados.dim(0)?;
|
| 393 |
-
let d = dados.dim(1)?;
|
| 394 |
-
let mut ensembles: Vec<Vec<MlpJepa>> = Vec::with_capacity(centroides.len());
|
| 395 |
-
for c in alocacao {
|
| 396 |
-
let mut v = Vec::new();
|
| 397 |
-
for _ in 0..(*c).max(1) {
|
| 398 |
-
v.push(MlpJepa::novo(d, 4 * d, d, dev)?);
|
| 399 |
-
}
|
| 400 |
-
ensembles.push(v);
|
| 401 |
-
}
|
| 402 |
-
let mut vars: Vec<Var> = Vec::new();
|
| 403 |
-
for ens in &ensembles {
|
| 404 |
-
for e in ens {
|
| 405 |
-
vars.extend(e.vars());
|
| 406 |
-
}
|
| 407 |
-
}
|
| 408 |
-
let mut opt = AdamWManual::novo(vars.clone(), 3e-3, 0.0);
|
| 409 |
-
let w_bmu = {
|
| 410 |
-
let v: Vec<f32> = (0..n).flat_map(|i| centroides[bmu[i]].iter().map(|x| *x as f32).collect::<Vec<f32>>()).collect();
|
| 411 |
-
Tensor::from_vec(v, (n, d), dev)?
|
| 412 |
-
};
|
| 413 |
-
for _ in 0..passos {
|
| 414 |
-
let mut soma = Tensor::zeros((), candle_core::DType::F32, dev)?;
|
| 415 |
-
for (i, ens) in ensembles.iter().enumerate() {
|
| 416 |
-
let idx: Vec<u32> = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect();
|
| 417 |
-
if idx.is_empty() {
|
| 418 |
-
continue;
|
| 419 |
-
}
|
| 420 |
-
let m_idx = idx.len();
|
| 421 |
-
let it = Tensor::from_vec(idx, (m_idx,), dev)?;
|
| 422 |
-
let w_c = w_bmu.index_select(&it, 0)?;
|
| 423 |
-
let x_c = dados.index_select(&it, 0)?;
|
| 424 |
-
let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?;
|
| 425 |
-
for e in ens {
|
| 426 |
-
y = (y.affine(1.0, 0.0)? + e.fwd(&w_c)?.affine(1.0, 0.0)?)?;
|
| 427 |
-
}
|
| 428 |
-
let k = ens.len() as f64;
|
| 429 |
-
let yh = y.affine(1.0 / k, 0.0)?;
|
| 430 |
-
let dif = (&yh - &x_c)?;
|
| 431 |
-
soma = (soma.affine(1.0, 0.0)? + dif.sqr()?.sum_all()?.affine(1.0 / (n as f64 * d as f64), 0.0)?)?;
|
| 432 |
-
}
|
| 433 |
-
let grads = crate::treino::grads_achatados(&soma, &vars)?;
|
| 434 |
-
let mut g = grads;
|
| 435 |
-
AdamWManual::clipar(&mut g, 5.0);
|
| 436 |
-
opt.passo(g);
|
| 437 |
-
}
|
| 438 |
-
// MSE final do decodificador
|
| 439 |
-
let mut mse = 0f64;
|
| 440 |
-
for (i, ens) in ensembles.iter().enumerate() {
|
| 441 |
-
let idx: Vec<u32> = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect();
|
| 442 |
-
if idx.is_empty() {
|
| 443 |
-
continue;
|
| 444 |
-
}
|
| 445 |
-
let m_idx = idx.len();
|
| 446 |
-
let it = Tensor::from_vec(idx, (m_idx,), dev)?;
|
| 447 |
-
let w_c = w_bmu.index_select(&it, 0)?;
|
| 448 |
-
let x_c = dados.index_select(&it, 0)?;
|
| 449 |
-
let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?;
|
| 450 |
-
for e in ens {
|
| 451 |
-
y = (y.affine(1.0, 0.0)? + e.fwd(&w_c)?.affine(1.0, 0.0)?)?;
|
| 452 |
-
}
|
| 453 |
-
let k = ens.len() as f64;
|
| 454 |
-
let yh = y.affine(1.0 / k, 0.0)?;
|
| 455 |
-
let dif = (&yh - &x_c)?;
|
| 456 |
-
mse += dif.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
|
| 457 |
-
}
|
| 458 |
-
Ok(mse / (n as f64 * d as f64))
|
| 459 |
-
}
|
| 460 |
-
|
| 461 |
-
pub fn versao() -> &'static str {
|
| 462 |
-
"moe-redirecionavel-0.6.0"
|
| 463 |
-
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
src/nlg.rs
CHANGED
|
@@ -162,7 +162,7 @@ impl UnidadeNlg {
|
|
| 162 |
}
|
| 163 |
// normaliza logp por z-score robusto (mediana)
|
| 164 |
let mut ordenado = logps.to_vec();
|
| 165 |
-
ordenado.sort_by(|a, b| a.
|
| 166 |
let med = ordenado[n / 2];
|
| 167 |
for (i, c) in candidatos.iter().enumerate() {
|
| 168 |
let lp = logps[i] - med;
|
|
@@ -258,7 +258,7 @@ impl DecodificadorEspeculativo {
|
|
| 258 |
let take = self.c_por_cabeca.min(self.c_por_cabeca.saturating_sub(k).max(1));
|
| 259 |
let v = lg.flatten_all().unwrap().to_vec1::<f32>().unwrap();
|
| 260 |
let mut idx: Vec<usize> = (0..v.len()).collect();
|
| 261 |
-
idx.sort_by(|&a, &b| v[b].
|
| 262 |
for t in idx.into_iter().take(take) {
|
| 263 |
if !candidatos.contains(&t) {
|
| 264 |
candidatos.push(t);
|
|
|
|
| 162 |
}
|
| 163 |
// normaliza logp por z-score robusto (mediana)
|
| 164 |
let mut ordenado = logps.to_vec();
|
| 165 |
+
ordenado.sort_by(|a, b| a.total_cmp(b));
|
| 166 |
let med = ordenado[n / 2];
|
| 167 |
for (i, c) in candidatos.iter().enumerate() {
|
| 168 |
let lp = logps[i] - med;
|
|
|
|
| 258 |
let take = self.c_por_cabeca.min(self.c_por_cabeca.saturating_sub(k).max(1));
|
| 259 |
let v = lg.flatten_all().unwrap().to_vec1::<f32>().unwrap();
|
| 260 |
let mut idx: Vec<usize> = (0..v.len()).collect();
|
| 261 |
+
idx.sort_by(|&a, &b| v[b].total_cmp(&v[a]));
|
| 262 |
for t in idx.into_iter().take(take) {
|
| 263 |
if !candidatos.contains(&t) {
|
| 264 |
candidatos.push(t);
|