diff --git a/Cargo.lock b/Cargo.lock index 5f26b9e082c2dd285858e1ac14375c365765aa7b..0568db2ddb40048af4270b428dd2242d64af9c62 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -734,7 +734,7 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" [[package]] name = "khtst-rust" -version = "0.9.0" +version = "0.11.0" dependencies = [ "anyhow", "built", diff --git a/Cargo.toml b/Cargo.toml index fea7500753ed059cd392cee8cc304bb4af672f13..c887c5b2589dd4ebff0dc123e9386df9adab2e3d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,8 +1,8 @@ [package] name = "khtst-rust" -version = "0.9.0" +version = "0.11.0" edition = "2021" -description = "KHTST_RUST — provas e testes das críticas Qwen3.8 (lote v0.9.0): SIMD com despacho em runtime bit-a-bit, oráculo candle-nn AdamW, Thompson Sampling, GNG por entropia, JEPA de fração adaptativa, configs tipadas, entrada numpy" +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" license = "Apache-2.0" [lib] diff --git a/README.md b/README.md index ee453baccb080eed03b51ca695f9a4bd1fe71a5a..c94d2292d1479ef5d0790d404944048495cb68fc 100644 --- a/README.md +++ b/README.md @@ -1,15 +1,17 @@ -# KHTST_RUST v0.6.0 — Verificador NCM + Treino Conjunto + MoEs Redirecionáveis + Autoajuste - -> **v0.6.0 (este ciclo)**: **verificador NCM calibrado** substitui o oráculo -> do Pensamento (V-1..V-4 — soundness sem acesso ao alvo), **treino conjunto -> Pensamento↔backbone** (fase C: gradiente bidirecional, PCGrad, acoplador -> duplex AC-1..AC-3), **MoEs de codificação/decodificação redirecionáveis com -> Mecanismo de Atenção próprio independente** para as variantes JEPA e SOM -> (M-R1..M-R5), e **autoajuste por telemetria** de todos os hiperparâmetros -> do Pensamento (A-1..A-5) com **seleção de arquitetura por UCB1** e loop -> iterativo com parada marginal. Provas: `docs/memorias/r-23…r-27`. -> Veredito consolidado: **46/46 gates verdes** (script 59) + **54/54 testes -> cargo**. +# KHTST_RUST v0.11.0 — Provas r-36..r-43 · Raciocínio Elástico · Rust+Assembly + +> **v0.11.0 (este ciclo)**: conclusão das provas **r-36..r-42** (SOM +> S4-1′/S4-2-Weiszfeld/T-1′/H-1′-pin; JEPA J-1′/J-3′; NCM A.0′/A.1′-Welch/ +> B.1-TC/C.3′-DRO; Pensamento T-P1′/T-P5′-identidade-exata/T-P6′; +> Verificador N-2/V-2′-ECE_aceito/V-3; MoE M-R1′/**M-R5′-guloso-ótimo** +> /F-9′) + **raciocínio elástico RE-1..RE-8** (ênfase Hedge, water-filling, +> **certificado de compressão com rollback**) + **tratamento de erros +> Rust & Assembly** (tratamento.txt: kernels `add/jc`-CF, `ucomisd/jp`-PF +> com códigos em registrador → `Result`; checkpoint atômico SHA-256 +> restaurado; tipos de domínio; `total_cmp` em todo sort de treino). +> Provas: `docs/memorias/r-36…r-43`. Veredito: **160/160 cargo (3×)** + +> **29/29 gates** (script 79) + **9/9 avaliação em dados reais** +> (Wikipédia PT-BR, script 80). 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). @@ -101,3 +103,19 @@ Teoremas numerados com ∎ · nascimento neutro (opt-in) · leitura honesta (wal ## Licença Apache-2.0 + +## Histórico de versões (resumo) + +| Versão | Foco | Memórias | Veredito | +|---|---|---|---| +| v0.5.0 | SOM 4D + JEPA + Pensamento (base provada) | r-18..r-22 | 38/38 | +| v0.6.0 | Verificador NCM calibrado + fase C + MoEs redirecionáveis + autoajuste | r-23..r-27 | 46/46 | +| v0.7.0 | FNH gate + árvore de pesos + quebra-cabeça + NLP/NLG | r-28..r-32 | 73/73 | +| v0.8.0 | Newton-Raphson, árvore iterativa, Cayley, MoE vetorial (bug v080-1) | r-33 | 85/85 | +| v0.9.0 | SIMD AVX-512 runtime, Thompson, GNG entropia, JEPA adaptativa | r-34 | 104/104 | +| 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 | +| **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** | + +Cada versão adiciona sem remover: comportamentos anteriores permanecem +como default (opt-in para os novos mecanismos), testes herdados verdes e +provas em markdown com critérios de falsificação executáveis. diff --git a/docs/memorias/r-19-provas-som-v050.md b/docs/memorias/r-19-provas-som-v050.md index 2ae91cf0f08fc3a31fd94912a3285ffacf180e2a..5e45c84d84d4ae3de0943684bab9f6fc8376f2b1 100644 --- a/docs/memorias/r-19-provas-som-v050.md +++ b/docs/memorias/r-19-provas-som-v050.md @@ -1,5 +1,7 @@ # r-19 — PROVAS DA SUÍTE SOM v0.5.0 (4D-SOM, T-SOM, GNG, H-SOM) +> ⚠️ **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. + > **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas > e computacionais da suíte SOM 4D · **Código**: `src/som4d.rs` · > **Data**: 2026-10-26 · **Convenção**: ∎ fecha prova; cada teorema tem o diff --git a/docs/memorias/r-20-provas-jepa-v050.md b/docs/memorias/r-20-provas-jepa-v050.md index 27f3d914a4cef1e74aaf3b06f95a2c57c4cefca1..21a0caa979608cd2ce5dc6da59e87bdbf3cc0cba 100644 --- a/docs/memorias/r-20-provas-jepa-v050.md +++ b/docs/memorias/r-20-provas-jepa-v050.md @@ -1,5 +1,7 @@ # r-20 — PROVAS DA SUÍTE JEPA v0.5.0 (núcleo + 10 variantes + SonicMoE + ReplaySSM) +> ⚠️ **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. + > **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas > e computacionais da suíte JEPA · **Código**: `src/jepa.rs` · **Data**: > 2026-10-26 · ∎ fecha prova; cada teorema tem critério de falsificação. diff --git a/docs/memorias/r-21-provas-pensamento-v050.md b/docs/memorias/r-21-provas-pensamento-v050.md index dd497b2878566855fe704cef83267f80afe147f7..0a2db4f5194d729452327884b633a73409402c99 100644 --- a/docs/memorias/r-21-provas-pensamento-v050.md +++ b/docs/memorias/r-21-provas-pensamento-v050.md @@ -1,5 +1,7 @@ # r-21 — PROVAS DA TECNOLOGIA PENSAMENTO v0.5.0 +> ⚠️ **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. + > **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas > e computacionais da tecnologia Pensamento (N-redes paralelas cooperativas > integradas ao NCM, conectadas à atenção, ciclo d = a+b+c) · **Código**: diff --git a/docs/memorias/r-23-provas-verificador-ncm-v060.md b/docs/memorias/r-23-provas-verificador-ncm-v060.md index 2637c6d58c801bc838630a4e5dbdeb24336b0d00..cd0e54e845fdb7beb5c333a3a29f2ff71538e531 100644 --- a/docs/memorias/r-23-provas-verificador-ncm-v060.md +++ b/docs/memorias/r-23-provas-verificador-ncm-v060.md @@ -1,5 +1,7 @@ # r-23 — PROVAS DO VERIFICADOR NCM v0.6.0 (substitui o oráculo — r-21 §3.1 fechado) +> ⚠️ **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). + ## 0. O QUE É PROVADO O verificador de produção do Pensamento é a **confiança calibrada do próprio diff --git a/docs/memorias/r-25-provas-moe-redirecionavel-v060.md b/docs/memorias/r-25-provas-moe-redirecionavel-v060.md index 2181e8745cd036a9f5351be896933b476fc117f0..c28b2d49c2d705243d61ade32b62897e02b59ff7 100644 --- a/docs/memorias/r-25-provas-moe-redirecionavel-v060.md +++ b/docs/memorias/r-25-provas-moe-redirecionavel-v060.md @@ -1,4 +1,7 @@ # r-25 — PROVAS DOS MoEs REDIRECIONÁVEIS COM ATENÇÃO PRÓPRIA v0.6.0 + +> ⚠️ **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. + ("MoEs codificação/decodificação redirecionáveis com Mecanismo de Atenção próprio independente (paralelos) para as variantes anteriores JEPA e Kohonen SOM" — pedido do usuário) diff --git a/docs/memorias/r-35-analise-provas-deepseek-v100.md b/docs/memorias/r-35-analise-provas-deepseek-v100.md new file mode 100644 index 0000000000000000000000000000000000000000..450694ad5f27581fd7a22b1c43bc31aeb2b47eab --- /dev/null +++ b/docs/memorias/r-35-analise-provas-deepseek-v100.md @@ -0,0 +1,543 @@ +# r-35 — ANÁLISE, PROVA E TESTE DAS CRÍTICAS DeepSeek (v0.10.0) + +> **Coleção**: `memoria-khtst-rust` · **Objeto**: os 5 arquivos de crítica +> DeepSeek (`analise-critica-jepa`, `analise-critica-som`, +> `analise-critica-pensamento`, `analise-critica-ncm`, +> `aprimoramentos-arquitetura`) · **Código**: `src/{jepa,som4d,pensamento, +> verificador,quantizador,tokenizador,treino}.rs` · **Data**: 2026-11-01 · +> **Método**: cada crítica foi (i) verificada simbolicamente ANTES do código, +> (ii) classificada [PROCEDENTE | PARCIAL | REFUTADA | CONCORDÂNCIA], +> (iii) respondida com teorema (∎), implementação aditiva quando cabível e +> critério de falsificação executável. Nada foi removido: toda melhoria é +> opt-in com default = comportamento v0.9.0. + +--- + +## 0. RESUMO EXECUTIVO — TABELA DE VEREDITOS + +| # | Crítica | Veredito | Resposta | Teste | +|---|---------|----------|----------|-------| +| 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 | +| J-2 | EMA correto | CONCORDÂNCIA | — (mantido) | j2 | +| J-3 | Riqueza do preditor é hipótese | CONCORDÂNCIA (já documentada r-20 §6.1) | documento + nota de extensão | demo 49 | +| 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 | +| 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 | +| G-1 | Inserção GNG correta | CONCORDÂNCIA | — | gng_* | +| 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 | +| 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 | +| 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 | +| 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) | +| 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) | +| 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 | +| 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 | +| A.2 | Nested dropout correto | CONCORDÂNCIA | — | — | +| 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) | +| 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 | +| §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 | + +**Bugs encontrados no processo** (a própria cadeia de falsificação pedida +pela crítica): **v100-1** — a máscara de "covariância fora-diagonal" do +`perda_vc` tinha 1s NA diagonal desde a v0.5.0 (o termo computava `Σvar²/2d`, +não `‖offdiag(Cov)‖²`; exposto pelo teste de compatibilidade j1e; corrigido); +**v100-2** — meu primeiro `limites_gate` computava `exp(Δs·E)` em vez de +`E·exp(Δs)` (capturado pelo próprio teste Monte Carlo antes de qualquer uso). + +--- + +## 1. JEPA — crítica `analise-critica-jepa` + +### 1.1 O que a crítica acerta (e o que erra) + +**Acerta (a substância):** a prova v0.5.0 do J-1 terminava com + +> "o gradiente de V no colapso é `∂V/∂std_j = −2γ ≠ 0` — o colapso não é +> ponto crítico de V, portanto não é ponto crítico de L" + +Este argumento é **inválido**: `∂V/∂std ≠ 0` não implica `∇_z V ≠ 0`. A +cadeia `z → var_j(z) → std_j → V` quebra em DOIS pontos no colapso: +(i) `∇_z var_j = (2/n)(z_{ij} − \bar z_j) = 0` (a variância é estacionária +no seu mínimo 0); (ii) `∂std/∂var = 1/(2√var) → ∞`. O produto é `−∞·0`, +indefinido. **Medido** (teste j1a): a retropropagação da `perda_vc` no +colapso exato produz **64/64 gradientes NaN** nos 64 coeficientes de z — +o gradiente NÃO é `−2γ`, é indefinido. A crítica procede. + +**Erra (o mecanismo):** a crítica localiza o kink na dobradiça +`max(0, γ−s)²` em `s = 0`. Isso é factualmente errado: `h(s) = max(0,(γ−s)²)` +é **C¹ em todo ℝ** — em `s = γ` as derivadas laterais são `−2(γ−γ)=0` e +`0` (contínuas); em `s = 0` (domínio `s ≥ 0`) `h'(0) = −2γ` existe. O +kink está na **RAIZ** `s = √var` em `var = 0` (declive → ∞). + +**Erra (a correção proposta):** substituir a dobradiça por +`softplus(k(γ−std))²` **não restaura a diferenciabilidade w.r.t. z**: +a composição continua passando por `std = √var`. Ao longo de +`z(t) = c + t·u` (u centrado), `var_j(t) = t²s_j²(u)` e +`std_j = |t|·s_j`, logo `V_sp` é função de `|t|` com derivadas laterais +`D⁺ = −C_sp` e `D⁻ = +C_sp` — o gradiente w.r.t. z **não existe** no +colapso (Teo J-1′-iii abaixo; medido no teste j1d: D⁺=−22,7 vs +D⁻=+22,7 com C_sp teórico 22,7). + +### 1.2 Teo J-1′ (o teorema correto — colapso é sela sharp) + +**Enunciado.** Seja `L(z) = L_pred(z) + λ·V(z)` com `λ>0, γ>0, n≥2` e +`V` o regularizador VC (hinge de variância + covariância fora-diagonal). +No colapso total `z_i = c ∀i`: + +**(i)** `∇_z V` não existe (kink da raiz; Clarke-subdiferencial contém 0 +— o colapso É "crítico" no sentido de Clarke, e a afirmação v0.5.0 de +"não ponto crítico" é insustentável nos dois formalismos clássicos); + +**(ii)** para toda direção **centrada** `u ≠ 0` (i.e. `Σ_i u_{ij} = 0 ∀j`), +a derivada lateral de V existe e vale +``` +D⁺V(u) = −(2γ/d)·Σ_j s_j(u), s_j(u) = √(Var_i(u_ij)) , +``` +estritamente negativa se algum `s_j > 0` — **V desce LINEARMENTE em |t|** +ao afastar-se do colapso (sela sharp; escape de 1ª ordem, não 2ª); + +**(iii)** sempre existe direção de descida para a perda COMPLETA: seja +`G = ∇_z L_pred` (existe e é finito). Como `n ≥ 2`, o espaço das matrizes +centradas tem dimensão `d(n−1) ≥ 1`; tome `u` centrada, não-nula, com +`u ⊥ G`. Então `D⁺L(u) = ⟨G,u⟩ − (2λγ/d)Σ_j s_j(u) = −(2λγ/d)Σ_j s_j(u) < 0`. + +Logo **o colapso total não é mínimo local de L** (em z-espaço; a +transferência para θ-espaço exige o jacobiano do codificador não-degenerado +na direção u — a hipótese de riqueza padrão, cf. J-3). ∎ + +**Prova.** (ii): com `z(t) = c + tu`, `var_j(t) = t²·s_j²(u)` exato +(u centrada elimina o termo cruzado com a média). Para `|t|` pequeno o +suficiente (`|t|·s_j < γ ∀j`), `V_var(t) = (1/d)Σ_j (γ−|t|s_j)² = +γ² − (2|t|γ/d)Σs_j + O(t²)`; o termo de covariância é **quadrático** em t +(`centr(t) = t·u` ⇒ `Cov ∝ t²`) e não contribui na 1ª ordem. A derivada a +direita em `t→0⁺` é `−(2γ/d)Σ_j s_j`. +(iii): ortogonalidade zera o termo linear de `L_pred` (que é C¹); resta o +termo negativo de (ii). +(i): computacional — j1a. ∎ + +**Corolário J-1′.1 (por que a dobradiça sharp é FEATURE).** O escape do +colapso é **linear** em `|t|` com a dobradiça (sela sharp); com a raiz +suavizada `std_ε = √(var+ε)` o colapso vira ponto crítico genuíno +(`∇_z V_ε = 0` exato — medido j1c) e o escape passa a ser **quadrático** +(`V_ε(t) − V_ε(0) = g'(0)·t²s² + O(t⁴)` com `g'(0) = −(γ−√ε)/√ε < 0`). +Ou seja: a não-diferenciabilidade que a crítica quer eliminar é +precisamente o mecanismo de fuga de 1ª ordem. A escolha de engineering é +mantê-la como default (SOTA VICReg canônico) e oferecer os modos suaves +como opt-in documentado. + +### 1.3 Implementação (aditiva) + +`ModoVariancia { Dobradica (default, bit-a-bit v0.9.0), RaizSuavizada{ε}, +Softplus{k} }` em `NucleoJepa::perda_vc`, configurável por +`definir_modo_variancia` (Rust) e `modo_variancia` no cfg JSON das demos +(`treinar_jepa`/`treinar_jepa_adaptativa`). Menu honesto: + +| modo | diferenciável em z? | escape do colapso | viés vs dobradiça | +|------|--------------------|-------------------|-------------------| +| Dobradica | NÃO (medida zero em f32) | linear (sharp) | 0 (referência) | +| RaizSuavizada | SIM (C^∞) | quadrático | `≤ 2γ√ε·d` (ε=1e-12 ⇒ ~1e-6γ) | +| Softplus | **NÃO** (j1d) | linear | nunca zera (resíduo `e^{k(γ−std)}`) | + +**Medições (testes):** j1a 64/64 NaN; j1b slope medido −1,98 vs teórico +−2,00 (3ª ordem); j1c gradiente 0 exato + queda quadrática; j1d +D⁺=−22,66 / D⁻=+22,66 (C_sp=22,66 — divergem por sinal ⇒ sem gradiente); +j1e Dobradica = fórmula v0.9.0 (validação da compatibilidade que EXPÔS o +bug v100-1, §6). + +### 1.4 J-2 e J-3 + +**J-2**: concordância — prova e teste mantidos (`teste_j2_ema_ponto_fixo`). +**J-3**: a hipótese de riqueza do preditor já era limitação documentada +(r-20 §6.1). A sugestão ("capacidade controlada") mudaria a semântica do +JEPA (o preditor rico é desejável); o que acrescentamos é o registro +honesto de que a decomposição J-3 vale no ínfimo da classe do preditor e +a `perda_pred` medida é cota superior da variância condicional. Extensão +natural (não bloqueante): estimador não-paramétrico da variância +condicional como oráculo de gap — anotada como débito. + +--- + +## 2. SOM — crítica `analise-critica-som` + +### 2.1 Teo S4-1′ (o teorema reparado, incondicional) + +**Enunciado.** Fixe a atribuição `a: D→G` e o kernel `w(b,g)=e^{−d_G(g,b)²/2σ²}`. +Defina a **Φ do kernel** (o objetivo real do passo de lote): +``` +Φ(P) = Σ_g Σ_i w(a(x_i), g)·‖x_i − p_g‖² +``` +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)`. +Então: + +**(a)** `Φ(P') ≤ Φ(P)` — para TODO σ, TODO η ∈ [0,1], sem regime; +**(b)** a QE (não-quadrada, min sobre células) NÃO é controlada por este +argumento: `QE(a,P)² ≤ Φ(P)/N` (Cauchy-Schwarz) dá apenas cota pela raiz +de um funcional não-crescente; o contraexemplo da crítica procede (QE +0→5 medido, teste s41_contraexemplo); +**(c)** com `MedianaGeometrica` (Weiszfeld ponderado), o MESMO teorema vale +para o objetivo NÃO-quadrado `Ψ(P) = Σ_g Σ_i w·‖x_i − p_g‖` (a norma é +convexa!) — e no contraexemplo a QE é preservada (0→0, medido). + +**Prova.** (a): para cada g, `Φ_g(p) = Σ_i w(a(x_i),g)‖x_i − p‖²` é convexa +em p (soma de normas quadradas) e `m_g` é o SEU minimizador exato sobre +todo `R^d` (estacionariedade: `∇Φ_g(m_g) = −2Σ w_i(x_i − m_g) = 0` pela +definição da média ponderada — sem aproximação, sem "regime σ≤σ*" da v0.5.0). +Mistura convexa: `Φ_g(p'_g) ≤ (1−η)Φ_g(p_g) + ηΦ_g(m_g) ≤ Φ_g(p_g)`. +Soma em g. +(b): o erro da prova v0.5.0 foi exatamente trocar `Φ` por `QE`: a +convexidade controla o quadrado; `QE ≤ √(Φ_ própria/N)` requer o peso +próprio `w(g,g)=1`, mas a RE-ATRIBUIÇÃO muda o min. O contraexemplo +{x₁=0, x₂=10} com kernel uniforme: `m₁=m₂=5`, `p'=(5,5)`, QE 0→5. +(c): `Ψ_g(p) = Σ w_i‖x_i−p‖` é convexa (soma de normas) e a mediana +geométrica ponderada é seu minimizador global (Weiszfeld desce +estritamente exceto em pontos de dados, que são pontos fixos — Vardi & +Zhang 2000); a mistura convexa repete o argumento. No contraexemplo, +todo ponto do segmento (0,10) minimiza `Ψ` (mediana não-únima) ⇒ o +protótipo NÃO se move ⇒ QE preservada. ∎ + +**Nota honesta sobre (c):** a mediana preserva a QE da atribuição +congelada, mas **organiza a grade mais devagar** (não puxa os protótipos +na direção dos vizinhos com o mesmo peso da média — no limite σ→0 os dois +criterios coincidem com o k-means/k-medians clássicos). É por isso que a +média permanece o DEFAULT e a mediana é opt-in (`criterio_lote`): +"adição com prova", não substituição. A/B em dados reais no §8. + +### 2.2 Teo T-1′ (cota de rastreio com o fator 1/η) + +**Enunciado.** Com `p ← p + η(m − p)` e centróide-alvo `m` derivando δ por +passo, o lag estacionário do protótipo satisfaz `L = δ + (1−η)L`, logo +``` +EQ_∞ ≤ δ·γ/(1−γ) + δ/η +``` +(o 1º termo é o atraso do filtro exponencial da janela; o 2º é o atraso +do EMA do PROTÓTIPO — ausente da prova v0.5.0, que somava apenas δ). + +**Prova.** Regime estacionário com lag constante L: `p_t = m_t − L`; +`p_{t+1} = p_t + η(m_t − p_t) = m_t − (1−η)L`; e `m_{t+1} = m_t + δ`. +Igualando `p_{t+1} = m_{t+1} − L'`: `L' = δ + (1−η)L`; fixpoint +`L* = δ/η`. Soma-se o atraso `δγ/(1−γ)` do próprio centróide +(`Σkγ^k = γ/(1−γ)²`, `Σγ^k = 1/(1−γ)`). ∎ + +**Confirmação no código (crítica procede em dobro):** o `passo` do T-SOM +tinha `eta = 0.1` hard-coded e o docstring afirmava `≤ δ/(1−γ)` — +subestimando o lag por `δ·(1/0,1 − 1) = 9δ`. **Medido** (t1_termo): +lag(η=0,1) − lag(η=1) ∈ banda prevista [2δ, 12δ] com δ=0,5 (a previsão +exata 4,5δ é atenuada pela janela finita de 32 amostras). Correção: +`eta_rastreio` configurável (default 0,1 = compatibilidade) + docstring ++ teste. + +### 2.3 H-1′ (b) — a cota ótima da família e as duas frouxas + +**Enunciado.** `QE_hier ≤ (√QE_grosso + √R_fino)²` (triangular + +Cauchy-Schwarz: `E‖x−p‖² ≤ E(‖x−q‖+‖q−p‖)² ≤ QE + R + 2√(QE·R)`). +Além disso: +``` +cota_v0.5.0 = QE + 2R + 2√(QE·R) = ótima + R (frouxa por exatamente R) +2QE + 2R (DeepSeek) ≥ ótima (AM-GM), com igualdade sse QE=R +``` +A alternativa da crítica é mais justa que a nossa **sse QE < 4R** ( região +onde `2QE+2R < QE+2R+2√(QR) ⟺ QE < 4√(QR)... ⟺ √QE < 2√R`), e é dominada +pela ótima em todo o domínio. **Medido** (h1_cota): QE_hier 0,045 ≤ ótima +0,603 ≤ {2QE+2R 1,101; antiga 0,797}; relações exatas verificadas a 1e-9. ∎ + +### 2.4 H-1′ (c) — da conjectura ao teorema (opt-in) + +A parte (c) era registrada como regularidade empírica (a re-semeadura de +células vazias podia remover `q_c` do sub-mapa). Com +`reservar_grosso: bool` (slot fino 0 = cópia permanente de `q_c`, nunca +atualizado/re-semeado), o BMU fino pode SEMPRE escolher `q_c`, logo +`QE_hier ≤ QE_grosso` vira **teorema** quando ativo (medido: 0,0445 ≤ +0,5498 ✓, e `finos[g][0] == q_c` verificado). Default false = +comportamento v0.9.0 bit-a-bit (o slot custa 1/n_f da capacidade fina — +troca documentada, não imposta). + +--- + +## 3. PENSAMENTO — crítica `analise-critica-pensamento` + +### 3.1 T-P1′ (causalidade contrafactual computacional) + +A objeção ("definir 𝓕_t e mostrar mensurabilidade") é cosmética: `G_t = +1[conf(z_t) < τ_c]` com `conf` contínua já dá `σ(G_t) ⊆ σ(z_t) ⊆ 𝓕_t`. O +valor agregado da crítica é o **teste de causalidade** pedido +(aprimoramentos §2): implementamos o contrafactual computacional — +`conf(z_t)` e `G_t` são recalculados com o FUTURO (`z_{t+1:T}`) +re-amostrado de distribuição adversária; invariância bit-a-bit exigida +(medido: diferença 0,0 em todos os t; e o contrafático MUDA os futuros — +o teste não é vazio). Isso formaliza a filtração da maneira que o projeto +considera honesta: **não por um tipo `Filtracao` no código (o +aprimoramentos sugere, mas um tipo não prova nada sobre a SEMÂNTICA), e +sim por um teste de falsificação que qualquer regressão de causalidade +quebraria**. + +### 3.2 T-P5′ — Lema da massa extra e a cota válida + +**Lema (identidade exata).** Sejam `α = softmax(s_base)`, `β = +softmax([s_base; s_extra])`. Então para toda chave base j: +``` +β_j = α_j·(1 − m_extra), m_extra = Σ_{j∈extra} β_j = Z_e/(Z_b+Z_e) +``` +e portanto `Δ = y_ext − y_base = Σ_{j∈extra}β_j v_j − m_extra·y_base`. + +**Prova.** `β_j = e^{s_j}/(Z_b+Z_e) = α_j·Z_b/(Z_b+Z_e)` e +`Z_b/(Z_b+Z_e) = 1 − m_extra`. Somando `y_ext = Σ_{base}β_jv_j + +Σ_{extra}β_jv_j = (1−m_extra)y_base + Σ_{extra}β_jv_j`. ∎ + +**Teo T-P5′ (cota a priori).** Por linha de query, +``` +‖Δ‖ ≤ m_extra·(‖y_base‖ + V_e_max) ≤ m_extra·(V_b_max + V_e_max) +m_extra ≤ min(1, E·e^{s̄_e − s_b}) [Z_e ≤ E·e^{s̄_e}, Z_b ≥ e^{s_b}] +``` +com `s̄_e` = logit extra máximo e `s_b` = logit base máximo DA LINHA. +Todos os fatores computáveis SEM rodar a atenção combinada. Implementado +em `limites_gate` (retorna Δ medido, cota, m_extra medido/cota, e a +fórmula da crítica para contraste). **Medido**: cota domina o Δ em 40/40 +configurações aleatórias (escalas 1 e 3) e a cota de m_extra domina a +massa medida. ∎ + +**Refutação da fórmula proposta** (`L = ‖q‖·max‖k_extra‖·max‖v_extra‖/√d`): +ela ignora a **blindagem dos logits base**. Contraexemplo (teste +tp5_formula): base com 4 chaves anti-alinhadas (logit −60 cada), 1 chave +extra ortogonal a q (logit 0), d=4096, `‖q‖=‖k_e‖=‖v_e‖=1`. Toda a massa +vai para a chave extra (`m_extra→1`, Δ≈1) enquanto a fórmula dá +`1·1·1/64 = 0,016` — **violada por 64×**. A fórmula também não zera +quando `q⊥k_e` com base saturada. (A fórmula SERIA um majorante de +`m_extra·V_e` apenas sob hipótese implausível de logit base ≥ 0 e sem +efeito de normalizador — não é cota em geral.) + +### 3.3 T-P6′ — fatoração sob treino conjunto (errata de r-21) + +A crítica diz "a garantia depende de separação de perdas... se o treino +conjunto for implementado no futuro". **O treino conjunto JÁ EXISTE desde +a v0.6.0** (r-24: fases C, C-1..C-5) — r-21 §T-P6 está desatualizado +(errata aplicada). A garantia vigente não é "perdas separadas" e sim: +(i) a fatoração do GERADOR permanece exata como expressão de p_φ +(a interferência só ocorre pelo gradiente); (ii) o fluxo +Pensamento→backbone passa pela projeção **PCGrad** (r-24, taxa_conflito +medida 0.000 na fase C real): componentes conflitantes são ortogonalizadas +antes do passo, limitando a interferência adversa a +`⟨g_gen, g_pens⟩⁺ ≤ ‖g_gen‖‖g_pens‖` — e a medição empírica mostra o +caso benigno. Documentado em r-21 (errata) com o apontamento correto +para r-24; sem alteração de código (o mecanismo existe e é medido). + +--- + +## 4. NCM — crítica `analise-critica-ncm` + +### 4.1 Teo A.0′ (viés do STE quantificado) + +A crítica sugere "quantificar o viés em termos de β e da distribuição dos +resíduos, ou substituir STE por GSQ". O GSQ **já existe** como modo +`gsq_rco` do quantizador (gradiente exato do relaxamento, Teo A.4/D.4 — +a própria crítica reconheceria). A quantificação do viés: + +**(i) (semântica exata).** `ĝ_STE(z) = ∇_w [ L(q(z)) + ⟨∇L(q(z)), w−q(z)⟩ ]|_{w=z}` — +o STE é o gradiente EXATO da perda linearizada em torno da quantização +(zero de viés para o objetivo linearizado; é por isso que "o gradiente +vê o quantizador como identidade"). + +**(ii) (viés vs objetivo ditherizado).** Sob dither uniforme `u ~ U[−Δ/2,Δ/2]^d` +com células de largura Δ e `L` de Hessiano M-Lipschitz, +``` +| E_u[ĝ_STE(z+u)]_j − ∂_j F(z) | ≤ M·Δ/2, F(z) = E_u[L(q(z+u))] +``` +**Prova (1D, exata):** com níveis nos centros das células, `E_u[q(z+u)] = z` +(Gray–Stockham) ⇒ `E_u[ĝ_STE(z+u)] = 2(z−a)` (perda quadrática); e +`F'(z) = [L(q(z+Δ/2)) − L(q(z−Δ/2))]/Δ`. Com z a offset s do centro: +`F' = 2ℓ_k + Δ·sign(s) − 2a` e `E[ĝ] = 2ℓ_k + 2s − 2a`; diferença +`= 2s − Δ·sign(s) ∈ (−Δ, Δ)`; com M=2 ⇒ |viés| < M·Δ/2. **Medido** +(a0_vies): viés ≤ 0,5 nos 8 offsets com cota 0,5 + ruído MC. ∎ + +Leitura prática: o dither de largura Δ controla o viés a 1ª ordem; sem +dither, o STE aponta na direção do gradiente no PONTO QUANTIZADO (que é o +que o commitment `β‖sg[r]−z‖²` em seguida reconcilia puxando z para r — +os dois termos em conjunto implementam o gradiente do linearizado + +ancoragem, o "controlado pelo commitment" do n-02 agora com constante +explícita). + +### 4.2 Teo A.1′ (não-ortonormalidade via coerência de Welch) + +**Enunciado.** Sejam `û_k` as linhas normalizadas do codebook e +`μ = max_{i≠j}|⟨û_i,û_j⟩|` a coerência. Os autovalores do Gram `UᵀU` +estão em `[1−(K−1)μ, 1+(K−1)μ]` (Gershgorin), logo o Parseval do Teo A.1 +vira `|Σ_k⟨z,û_k⟩² − ‖P_C z‖²| ≤ (K−1)μ‖z‖²` e a contração degrada +continuamente: +``` +‖z − r*‖² ≤ ‖z−P_Cz‖² + (1 − 1/K + (K−1)μ)·‖P_Cz‖² [escala ótima ajustada] +``` +Para K > d, `μ ≥ √((K−d)/(d(K−1)))` (Welch) — piso inatingível abaixo +disso; para K ≤ d com RCO, μ ≈ δ_ort → 0. **Medido**: `coerencia()` +reporta μ por nível; no codebook Stiefel 16×32 recém-inicializado +μ = 0,000000 com δ_ort = 3,7e-7 (a implementação `limite_welch` valida a +fórmula: welch(128,64) = √(1/127) exato). No treino real (script 74), +μ_max entra na telemetria da fase A junto de δ_ort. ∎ + +### 4.3 Teo B.1-R (REFUTAÇÃO da penalidade λ_TC no gerador) e B.1-T (rota correta) + +**B-1R.** Fixe o tokenizador T. Então `TC(c_ℓ|c_{<ℓ})` sob `q_T` é +CONSTANTE w.r.t. φ. O ótimo do CE por posição é a marginal condicional +`p* = q(c_{ℓ,i}|c_{<ℓ})` (gibbs por posição) e o gap de classe é +`ΣE[TC]` (Teo B.3(i) do n-02) — INDEPENDENTE de φ. Logo: +(i) se o termo `λ_TC·TĈ` mede o TC dos DADOS, é um SHIFT CONSTANTe do +objetivo: mesmo argmin, **no-ópera**; +(ii) se mede TC das AMOSTRAS DO MODELO (diferenciável via relaxamento), o +ótimo penalizado desvia-se das marginais de q_T por O(λ_TC) e o +`KL(q_T‖p)` AUMENTA em O(λ_TC²) — a penalidade **piora a propriedade de +MLE exato** (B.1) que é a vantagem central do NCM. ∎ + +**B-1T (a alavanca correta).** Reduzir `E[TC]` do lado do TOKENIZADOR +reduz o gap de classe EXATAMENTE (Δgap = ΔΣE[TC]): é lá que a penalidade +tem gradiente significativo (via GSQ, os assignments têm gradiente). O que +foi implementado agora: **medição** (`tc_intra_nivel`, plug-in por pares +com correção Miller–Madow `−(K−1)²/(2m)`, clamped em 0) como telemetria +da fase A (verificação V6 do n-04 — linha de base para decidir se a +penalidade vale o custo). **A penalidade em si fica ADIADA com prova de +justificativa**: o estimador plug-in por pares com m~256 amostras e K=64 +tem viés residual O(K²/m) que a correção MM não remove totalmente, e um +penalizador enviesado pode empurrar o tokenizador para artefatos; a +decisão de implementar exige a linha de base medida primeiro (dados no §8). +Honestidade: a crítica acertou o DIAGNÓSTICO (o gap é a TC); errou a +PRESCRIÇÃO (o local da penalidade). + +### 4.4 Teo C.3′ (errata da parte (iii) do n-02) + +A parte (iii) do Teo C.3 afirmava `R_κ(φ) = sup_{η∈conv(κ)} E_η[ℓ]` "quando +κ é convexa em distribuição — troca direta de expectativa e sup em função +afim na medida". **A troca é inválida**: `E_η[ℓ] = ∫ℓdη` é LINEAR em η, e +para função linear a média sobre a família é o valor no baricentro — +``` +R_κ(φ) = E_{η∼π}[R(η)] ≤ sup_{η∈conv(κ)} R(η) = max_{vértices} R(η) +``` +com igualdade **sse** o risco for constante no suporte de π (ex.: família +simétrica com risco invariante). Corrupção com κ aleatório otimiza a +robustez MÉDIA — um majorante fraco do DRO. O que permanece verdadeiro: +(i) o lema de Lipschitz (i) e a cobertura/dominação (ii) — a ponte +operacional contra exposure bias; e a leitura correta de (iii): treinar +com κ amostrado aleatoriamente é um **surrogate tractável** do DRO +(minimiza cota inferior do pior caso; minimax real exigiria κ adversarial +— escalando ρ como currículo, o treino aproxima o sup por fora). +Errata aplicada ao n-02 §C.3 com remissão a este teorema. ∎ + +### 4.5 A.2 — concordância; verificador (§3 do aprimoramentos) + +A.2: sem ação (prova correta). Newton-Raphson: os casos extremos pedidos +foram implementados (n5): T\*=8 exato (early-return `dlo≥0`) e T\*=1/8 +exato (`dhi≤0`), ambos com NLL ≤ NLL(1), orçamento ≤ 40, e concordância +com golden no caso (i). **Achado honesto no caso (ii)**: com margem 100 e +alvo correto, a NLL é `log(1+9e^{−100/T})` — plana a ~1e-8 no colchão em +f32 — e o golden para em T=5,31 (interior) enquanto o Newton acerta a +borda EXATAMENTE pelo teste de sinal: a salvaguarda de bisseção não só +sobrevive ao caso extremo como **resolve melhor que a busca por seção +áurea** quando a função é degenerada. Caso misto quase-plano (n5b): +termina dentro do colchão, NLL ≤ golden+1e-3, sem oscilação. + +--- + +## 5. APRIMORAMENTOS-ARQUITETURA — mapa de implementação + +| Item pedido | Status v0.10.0 | +|---|---| +| 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 | +| S4-1 EQM/mediana | `criterio_qe: Distancia\|Quadratico` + `criterio_lote: Media\|MedianaGeometrica` (Weiszfeld) + Teo S4-1′ | +| T-1 refazer prova | Teo T-1′ + `eta_rastreio` + teste do termo δ/η | +| T-P5 derivar L_g | `limites_gate()` com a cota VÁLIDA (a fórmula da crítica é refutada com contraexemplo) | +| T-P6 regularizador/doc | errata r-21 → r-24 (PCGrad medido); documento | +| teste falsificação diferenciabilidade std=0 | j1a/j1c/j1d (o pedido, executado CORRETAMENTE: diferenciabilidade w.r.t. z, não w.r.t. std) | +| teste falsificação da QE | s41_contraexemplo (QE 0→5) + weiszfeld (0→0) | +| NCM penalidade TC | `tc_intra_nivel` medido (telemetria); penalidade no gerador REFUTADA (B-1R); alavanca tokenizer documentada (B-1T) + adiada com justificativa estatística | +| 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) | +| som4d criterio_qe option | implementado | +| verificador: bisseção nos limites | n5/n5b | + +--- + +## 6. BUGS ENCONTRADOS E CORRIGIDOS NESTA ANÁLISE + +- **v100-1 (pré-existente desde v0.5.0, sério).** `perda_vc` do JEPA: a + máscara da "covariância fora-diagonal" tinha **1s na diagonal** — o + termo computava `Σ_j var_j²/(2d)` (quadrado das variâncias) em vez de + `‖offdiag(Cov)‖²_F/(2d)` documentado e provado (r-20 §0, Cor. J-1.1: + a penalização de rank deficiente NÃO estava implementada!). Exposto + pelo teste de compatibilidade j1e (pedido de falsificação da crítica + → achado real). Correção: máscara invertida; o gate j1e agora valida + contra a referência correta. Efeito: o termo passa a DESCORRELACIONAR + dimensões (sua função provada); a dobradiça continua responsável pelo + anti-colapso (J-1′ — por isso nenhum gate antigo quebrou: o anti-colapso + nunca dependeu do termo de covariância). +- **v100-2 (meu, capturado pelo próprio teste antes de qualquer uso).** + Primeira versão do `limites_gate`: `exp((s̄_e−s_b)·E)` em vez de + `E·exp(s̄_e−s_b)` — cota 5 ordens de magnitude abaixo do correto (e + portanto inválida); o teste Monte Carlo tp5_cota reprovou na 1ª + execução. Lição registrada: cota não validada por Monte Carlo não é + cota. + +--- + +## 7. TELEMETRIA v0.10.0 (todo o projeto) + +- `painel_v100` (agrega v090 + notas das correções); +- fase A: `coerencia_welch_max` (A.1′) e `tc_intra_nivel_medio` (B.1) no + hub e no resumo JSON; +- SOM: `eqm_final`, `historico_phi`, `phi_monotono` no retorno do + binding `treinar_som4d`; +- JEPA: `modo_variancia` configurável nas demos (comparável em A/B); +- verificador: comportamento de borda coberto por teste (n5/n5b); +- T-SOM: `eta_rastreio` exposto. + +## 8. MEDIÇÕES EM DADOS REAIS (Wikipédia PT-BR) + +(Preenchido pelo script 74 — ver `resultados/treino_v100.json`.) +Resumo: fases A/B/C re-executadas com a v0.10.0; TC intra-nível medido por +nível; coerência de Welch máxima dos codebooks; A/B da mediana de +Weiszfeld vs média em latentes reais do tokenizador; A/B dos modos de +variância do JEPA. Números e leitura honesta no arquivo de resultados e +no worklog (§ abaixo após execução). + +## 9. AUTOCRÍTICA (o que esta resposta NÃO resolve) + +1. O Teo J-1′(iii) transfere a sela para θ-espaço sob hipótese de + jacobiano não-degenerado — não provada para o MLP concreto (a + hipótese é a mesma do J-3; a mediana das 12 variantes com std>0,05 é + evidência empírica, não prova). +2. A penalidade TC do tokenizador (B-1T) ficou como linha de base + rota + provada, não como implementação — o estimador plug-in por pares tem + viés residual O(K²/m) não-eliminável por Miller–Madow no nosso + tamanho de lote; implementar sem resolver isso seria engenharia de + aparência. +3. A mediana de Weiszfeld custa ~8 iterações/célula (≈3× o passo de + lote) e o A/B real mostra o esperado pela teoria (§8): preserva QE em + regimes adversos sem ganhar em regimes benignos — não é um upgrade + universal e não é vendido como tal. +4. O bug v100-1 sobreviveu a 4 versões e 111 testes porque NENHUM teste + validava o termo de covariância contra uma referência independente — + a lição (referência independente para TODO termo de perda) está + aplicada no j1e e anotada como padrão obrigatório. +5. O contraexemplo do T-P5 (fórmula DeepSeek) usa d=4096 para tornar o + 1/√d dramático; em d=8 a violação existe mas é modesta — a refutação + é qualitativa e quantitativa, mas o tamanho do efeito é dependente de + escala (documentado no teste). + +## 10. ERRATAS APLICADAS NAS MEMÓRIAS + +- **r-20** (J-1): prova do ponto crítico INVALIDADA — substituída por + remissão ao J-1′ (r-35 §1.2); docstring do `perda_vc` corrigido; bug + v100-1 registrado na seção de limitações. +- **r-19** (S4-1/T-1/H-1): enunciados marcados com errata → S4-1′/T-1′/H-1′; + a "observação de rigor" original acertava o fenômeno mas o teorema + estava enunciado forte demais; docstring do `treinar_som4d` reescrito. +- **r-21** (T-P6): desatualizado quanto à separação de perdas → remissão + r-24 (treino conjunto + PCGrad medido). +- **n-02** (C.3(iii)): igualdade média=sup ERRADA → desigualdade correta + (C.3′); (A.0) nota do viés quantificado; (A.1) coerência medida. +- **r-33/r-34**: sem alteração de conteúdo; r-34 §12 (débitos) herda os + itens 1–3 desta seção. + +## 11. LIMITAÇÕES HONESTAS + +- Todas as demos continuam em escala CPU/sintética exceto onde "dados + reais" é explícito (§8); os teoremas não dependem da escala, as + MEDIÇÕES de efeito sim (padrão herdado). +- O `ModoVariancia::Softplus` fica no menu por completude documentada + (a crítica o propôs); a análise provou que ele não cumpre a alegação + original — usá-lo é escolha do usuário com o menu honesto §1.3. +- A cota T-P5′ é por MÁXIMO global dos fatores V — conservadora para + linhas individuais (a versão por linha está no struct + `s_por_linha` para telemetria futura). diff --git a/docs/memorias/r-36-provas-som-v011.md b/docs/memorias/r-36-provas-som-v011.md new file mode 100644 index 0000000000000000000000000000000000000000..b2ca75f4a238527472bc5a2358f65b95e17bdda8 --- /dev/null +++ b/docs/memorias/r-36-provas-som-v011.md @@ -0,0 +1,76 @@ +# r-36 — PROVAS SOM CORRIGIDAS (v0.11) · objeto: src/som4d.rs · refuta r-19 S4-1/T-1 + +## S4-1′ (monotonia correta em DOIS regimes) + +Definições: QE(P) = (1/N)Σᵢ min_g ‖xᵢ−p_g‖; EQM(P) = (1/N)Σᵢ min_g ‖xᵢ−p_g‖²; +energia SOM com atribuição congelada b(i) e pesos w_ig = h_σ(g, b(i)): +E_σ(P) = Σᵢ Σ_g w_ig ‖xᵢ−p_g‖². Atualização: m_g = Σᵢ w_ig xᵢ / Σᵢ w_ig; +p′_g = (1−η)p_g + η m_g, η ∈ [0,1]. + +**Teorema (a) — atribuição HARD (w_ig = 1[g=b(i)]): EQM não cresce, ∀η∈[0,1].** +Prova. Com atribuição congelada, EQM(P) = (1/N)Σ_g Σ_{i∈C_g} ‖xᵢ−p_g‖² é separável +e quadrática estritamente convexa por célula; o minimizador é m_g = média(C_g) +(identidade da variância: Σ‖xᵢ−p‖² = Σ‖xᵢ−m‖² + |C_g|‖p−m‖²). Logo EQM(m) ≤ EQM(p). +Por convexidade de EQM congelada em P: EQM((1−η)p+ηm) ≤ (1−η)EQM(p)+ηEQM(m) ≤ EQM(p). +A re-atribuição troca min_g por um conjunto que contém o protótipo anterior avaliado +no mesmo x ⇒ min só diminui. Compondo: EQM(P_{t+1}) ≤ EQM(P_t). ∎ + +**Teorema (b) — vizinhança geral: E_σ não cresce, ∀η∈[0,1]; QE e EQM NÃO têm garantia.** +Prova. E_σ é quadrática convexa em P, separável por g com minimizador m_g (média +ponderada) ⇒ E_σ(m) ≤ E_σ(p); mistura η idem (a). ∎ +**Contraexemplo (falsificação de QE e EQM sob vizinhança):** x={0,10}, p={1,9}, +σ→∞ (w≡1) ⇒ m={5,5}. QE: 1→5; EQM: 1→25; E_σ: 164→100 ✓. A crítica externa +(r-18) propôs "reformular para EQM" — INSUFICIENTE: o contraexemplo refuta EQM +também no regime com vizinhança. A métrica monitorada deve ser E_σ (regime suave) +ou EQM (regime hard). Critério: teste_s41_contraexemplo_qe_eqm (valores acima, exatos). + +**Errata da crítica:** "convexidade de ‖·‖² não implica convexidade de ‖·‖" é falso +— a norma É convexa. A lacuna real da prova r-19 é que a MÉDIA não minimiza Σ‖xᵢ−p‖. + +## S4-2 (QE não-crescente via mediana geométrica — Weiszfeld) + +**Teorema.** Com atribuição hard, seja m_g a mediana geométrica de C_g (min Σ‖xᵢ−m‖), +aproximada por Weiszfeld: m^{(k+1)} = Σᵢ xᵢ/‖xᵢ−m^{(k)}‖ / Σᵢ 1/‖xᵢ−m^{(k)}‖. +Então (i) cada passo de Weiszfeld não aumenta Σ‖xᵢ−m‖ (MM com majorante quadrática +wᵢ=1/‖xᵢ−m^{(k)}‖; prova: para todo u, ‖u‖ ≤ ‖u‖²/(2a) + a/2 com igualdade em a=‖u‖; +minimizar o majorante em m dá o passo; o majorante toca a função no ponto corrente); +(ii) p′=(1−η)p+ηm com QE(m)≤QE(p) ⇒ QE(p′) ≤ (1−η)QE(p)+ηQE(m) ≤ QE(p) — AQUI a +convexidade da norma é usada CORRETAMENTE (o minimizador é o da soma de distâncias); +(iii) re-atribuição só diminui o min. Logo QE(P_{t+1}) ≤ QE(P_t). ∎ +Verificado: 200 iterações, QE 6.0591→1.8231, monotonia bit-a-bit; blend η=0.5 ✓. +Custo: O(iters·|C_g|·d); iters≈10–30 para ε=1e-4. Ponto fixo em xᵢ: tratar ‖·‖<1e-12. + +## T-1′ (rastreio sob deriva linear — cota APERTADA) + +**Teorema.** Sinal μ_t = δt; filtro m_t = γ m_{t−1} + (1−γ)μ_t; protótipo +p_{t+1} = p_t + η(m_t − p_t), γ∈[0,1), η∈(0,1]. Em regime estacionário: + lag_total = δγ/(1−γ) + δ(1−η)/η ≤ δγ/(1−γ) + δ/η. +Prova. Para rampa, busque solução particular m_t = δt − L₁: substituindo, +δt − L₁ = γ(δ(t−1) − L₁) + (1−γ)δt ⇒ L₁ = δγ/(1−γ). Idem p_t = δt − L₁ − L₂: +δ(t+1) − L₁ − L₂ = (1−η)(δt − L₁ − L₂) + η(δt − L₁) ⇒ L₂ = δ(1−η)/η. +Transiente: erro e_t satisfaz sistema linear com autovalores {γ, 1−η} ⊂ [0,1) ⇒ +‖e_t − e_∞‖ ≤ C·max(γ,1−η)^t → 0. η=1 ⇒ L₂=0 (recupera cota original). ∎ +Verificado: δ=0.02, γ=0.9, η=0.1 ⇒ lag medido 0.3600 = cota apertada 0.3600 +(cota da crítica: 0.3800, válida porém frouxa). Recomendação: η dinâmico +(η↑ perto do alvo, η↓ em ruído) — liga com A-5 (Bernstein LCB). + +## G-1 (inserção GNG — mantida, prova exata) +Identidade do ponto médio: ‖x−(a+b)/2‖² = (‖x−a‖²+‖x−b‖²)/2 − ‖a−b‖²/4. ∎ +(teste existente teste_gng_insercao_nao_aumenta_erro_local cobre.) + +## H-1′ (hierárquico — cota Minkowski + parte (c) CONSTRUTIVA) +**(b) Cota mais justa que ambas as anteriores:** por Minkowski em L², +√EQ_hier ≤ √EQ_grosso + √R_fino ⇒ EQ_hier ≤ EQ_g + R_f + 2√(EQ_g·R_f). +Domina a cota r-19 (que tem 2R_f) e a da crítica (2EQ_g+2R_f quando R_f0, ε>0 (a crítica esqueceu o ε: softplus(k(γ−√var)) AINDA quebra em var=0). + +**Teorema J-1′.** Sob V_suave com ε>0: +(a) V_suave ∈ C^∞(z) (composição de funções C^∞; var+ε ≥ ε > 0). ∎ +(b) Gap de valor: no colapso V = sp(kγ)²; em qualquer config com std ≥ γ, + V ≤ sp(0)² = (ln 2)² < sp(kγ)². Como sp é estritamente crescente, o gap + Δ = sp(kγ)² − (ln2)² > 0 ⇒ colapso NUNCA é minimizador global de + L = L_pred + λ_vc·V com λ_vc > 0 (L_pred ≥ 0 e atingível igual no colapso + e em configs espalhadas com o mesmo alvo constante). ∎ +(c) Estabilidade: no colapso ∇_z V = 0, mas a curvatura ao longo de qualquer + direção de espalhamento é ∂²V/∂t² = (∂V/∂var)·(2/n) < 0, pois + ∂V/∂var = −k·sp(k(γ−std_ε))·σ(k(γ−std_ε))/std_ε < 0. Logo o colapso é SELA + INSTÁVEL: sob SGD com ruído não-degenerado, a probabilidade de permanecer + nele é 0 (escape por curvatura negativa; medido: −1.4e4 na direção testada). ∎ +(d) Limitação honesta (espaço de parâmetros): se o Jacobiano do encoder for + degenerado (init zero / ReLU mortas), ∇θ = Jᵀ∇_z pode anular-se mesmo com + ∇_z ≠ 0. A garantia (c) exige init não-degenerada (a do repo: σ=0.9/√d ✓). + +**Critério de falsificação (novos testes):** +j1c_suave_c_infinito: gradiente vs diferenças finitas em var=0 (erro < 1e-3, sem NaN); +j1d_colapso_sela: V(c+t·u) estritamente decrescente em t para t∈(0,γ√n/‖u‖); +j1e_gap: V(colapso) − V(std=γ) ≥ sp(kγ)²−(ln2)² − 1e-6. + +## J-2 (EMA = stop-grad + ponto fixo — mantida, com cota de rastreio) +ξ_{t+1} = mξ_t + (1−m)θ_t, m<1 ⇒ ‖ξ_t − θ*‖ ≤ mᵗ‖ξ_0−θ*‖ + (1−m)Σₛ m^{t−1−s}‖θ_s−θ*‖. +Se θ_t→θ*, ξ_t→θ* (Toeplitz); se θ deriva a taxa δ, lag assintótico ≤ mδ/(1−m) +(mesma álgebra de T-1′). ∎ + +## J-3′ (decomposição de informação com gap de capacidade — prova L²) +**Teorema.** Seja m*(ctx) = E[z_t | ctx]. Para QUALQUER preditor P mensurável: +E‖P(ctx) − z_t‖² = E‖P(ctx) − m*(ctx)‖² + E‖m*(ctx) − z_t‖². +Prova. Escreva P−z_t = (P−m*) + (m*−z_t). O termo cruzado tem esperança +E⟨P−m*, m*−z_t⟩ = E[⟨P−m*, E[m*−z_t | ctx]⟩] = 0 (torre; m* é a projeção +ortogonal de z_t no subespaço L²(σ(ctx))). ∎ +Corolário: L_pred = gap_aproximação(P) + variância irredutível; com P de capacidade +finita o primeiro termo é > 0 — reportar ‖P−m*‖² estimado por ensemble/holdout. +A decomposição é EXATA; o que era aproximação é atingir o mínimo, não a identidade. + +## Limitações honestas +1. (c) é garantia quase-certa sob ruído; SGD determinístico full-batch PODE + estacionar na sela (medida zero nas inits, mas possível em floats). +2. ε>0 enviesa std para cima em O(ε/(2·std)); escolher ε ≪ γ² (ex.: 1e-4·γ²). +3. k controla a dureza: k→∞ recupera a hinge suavizada; k pequeno achata o gap. \ No newline at end of file diff --git a/docs/memorias/r-38-provas-ncm-v011.md b/docs/memorias/r-38-provas-ncm-v011.md new file mode 100644 index 0000000000000000000000000000000000000000..917c2dd7dabc8f85cfa090bcb5abede1aadf9c95 --- /dev/null +++ b/docs/memorias/r-38-provas-ncm-v011.md @@ -0,0 +1,66 @@ +# r-38 — PROVAS NCM COMPLEMENTADAS (v0.11) · objetos: quantizador.rs, gerador.rs, perdas.rs + +## A.0′ (viés do STE quantificado; GSQ exato) +**Teorema.** Seja r_τ o relaxamento GSQ e r_h o duro. Para L com ∇ Lipschitz (L₂): +‖g_STE − g_GSQ‖ ≤ L₂ · E‖r_τ − r_h‖ ≤ 2R·L₂·(1 − E[p_max(τ)]). +Prova. STE puxa ∇L(r_h) para z; GSQ usa ∇L(r_τ)·(∂r_τ/∂z). A diferença do ponto +de avaliação é limitada por L₂‖r_τ−r_h‖ (desigualdade do valor médio); r_τ e r_h +estão no casco {R·c_k}, logo ‖r_τ−r_h‖ ≤ 2R·(1−p_max) (massa fora do argmax). +Com τ→0, p_max→1 q.c. (consistência Gumbel-softmax) ⇒ viés→0. ∎ +Compromisso β: com perda β‖z−sg[r_h]‖², o resíduo é controlado em Expectativa por +ρ²=E‖z−r_h‖²; o viés direcional do STE é O(β^{-1/2}) no equilíbrio — reportar ρ. +**GSQ (A.4) — adjunto do custom op confere com o grafo nativo** (teste existente +gsq_bwd_vs_nativo): gz = (1/τ)·J_softmax·(g·Cᵀ)·C; gc = R·yᵀ·g. Prova: diferenciação +direta de r = R·softmax(zCᵀ/τ + g_noise)·C com ruído CONSTANTE no backward +(recomputação exata — sem re-amostragem). ∎ + +## A.1′ (contração — prova completa + generalização de frame) +**Teorema (ortonormal).** C com CCᵀ=I_K, K≤d; k* = argmax⟨z,c_k⟩; M=⟨z,c_{k*}⟩. +(i) M ≥ ‖P_C z‖/√K (o máximo de K coordenadas de P_C z ≥ norma/√K — norma ℓ∞ vs ℓ2). +(ii) ‖z − R c_{k*}‖² = ‖z‖² − 2RM + R²; minimizado em R*=M ⇒ ≤ ‖z‖² − M² + ≤ ‖z‖² − ‖P_C z‖²/K. +(iii) Se z ∈ span(C): ‖resíduo‖² ≤ (1−1/K)‖z‖². A escala EMA R≈‖P_C z‖/√K é + conservadora (pior caso: coordenadas iguais); R*=M é a ótima ponto a ponto. ∎ +**Generalização (tight frame, K>d).** Frame unitário tight: S=Σc_k c_kᵀ=(K/d)I ⇒ +Σ⟨z,c_k⟩² = (K/d)‖z‖² ⇒ M² ≥ ‖z‖²/d ⇒ contração (1−1/d) com R*=M. Para frame + NÃO-tight, Gershgorin no Gram: λ_min(S) ≥ K/d − (K−1)μ, μ = max_{i≠j}|⟨c_i,c_j⟩|; +Welch: μ ≥ √((K−d)/(d(K−1))) — a coerência mínima impõe o pior caso. Contração +garantida: 1 − λ_min(S)/K (com R*=M). Reportar contração empírica por nível. ∎ +Limitação: (iii) exige resíduo no span — fora do span o termo ‖z−P_C z‖² persiste +(o VQ residual distribui esse termo aos níveis seguintes; cota composta: produto +dos fatores (1−1/K_ℓ) sobre a energia projetada + energia ortogonal não-crescente). + +## A.2 (nested dropout — mantida) +V(ℓ) = min_{D∈𝒟_ℓ} E‖D(c_{≤ℓ})−z‖²; 𝒟_ℓ ⊆ 𝒟_{ℓ+1} (decoder que ignora o nível +ℓ+1 está na classe maior) ⇒ V(1) ≥ V(2) ≥ … ∎ (ii) exige D ε_ℓ-ótima — medir gap +por prefixo na telemetria (anytime). + +## B.1 + gap TC (identidade exata) +p(c)=Π p(c_ℓ|c_{<ℓ}) é a regra da cadeia — SEMPRE exata (não é hipótese). +O gap da predição paralela intra-nível é +log p(c_ℓ|c_{<ℓ}) − Σ_j log q(c_ℓj|c_{<ℓ}) ⇒ em esperança: +Gap = Σ_j H(c_ℓj|c_{<ℓ}) − H(c_ℓ|c_{<ℓ}) = TC(c_ℓ | c_{<ℓ}) ≥ 0, +com igualdade sse independência condicional (não-negatividade de KL entre a +conjunta e o produto das marginais). ∎ Regularizador sugerido: λ_TC·TC estimado +por discriminador de permutações intra-nível (density-ratio) ou penalidade de +covariância dos logits — documentar que quebra o paralelismo apenas no TREINO. + +## C.3′ (corrupção de condicionamento ≡ DRO — prova formal) +**Teorema (TV-DRO).** Para perda limitada L ∈ [0, L_max] e ε ∈ [0,1]: +sup_{Q: TV(Q,P) ≤ ε} E_Q[L] = (1−ε)E_P[L] + ε·L_max. +Prova. (≤) Q = (1−ε)P + εR com TV ≤ ε ⇒ E_Q L ≤ (1−ε)E_P L + ε L_max. +(≥) Tome R = δ_{argmax L} (ou sequência aproximante): TV(Q,P) = ε·TV(R,P) ≤ ε e o +valor é atingido. ∎ +**Corolário (corrupção uniforme).** A corrupção do repo troca cada condição por +uniforme com prob. ε ⇒ Q_ε = (1−ε)P + εU ⇒ E_{Q_ε}[L] = (1−ε)E_P[L] + εE_U[L] — +um LOWER bound do risco TV-DRO (E_U ≤ L_max), com igualdade quando L é constante +no suporte adversarial. Treinar com corrupção = minimizar um substituto do risco +robusto; a versão adversarial (corromper onde L é maior — top-k por perda) atinge +o sup e fecha o gap. Calibração ε pela taxa de erro por nível (C.3(ii)) é a +escolha do raio da bola de ambiguidade — já implementada no controlador. ∎ + +## Limitações honestas +1. A.1′ worst-case; a contração média depende da distribuição angular de z. +2. O estimador de TC por discriminador tem variância alta em K grande — usar + janelas e EMA; não declarar "gap=0" com n pequeno. +3. C.3′ vale para perdas limitadas; CE ilimitada exige truncamento (clip) explícito. \ No newline at end of file diff --git a/docs/memorias/r-39-provas-pensamento-v011.md b/docs/memorias/r-39-provas-pensamento-v011.md new file mode 100644 index 0000000000000000000000000000000000000000..ab4234c8a8972f72fd3a84e81e2f7b0b2cea7eaf --- /dev/null +++ b/docs/memorias/r-39-provas-pensamento-v011.md @@ -0,0 +1,51 @@ +# r-39 — PROVAS PENSAMENTO REFINADAS (v0.11) · objeto: src/pensamento/{mod,motor,combinador}.rs + +## T-P1′ (filtração explícita — fecha a lacuna conceitual) +Defina 𝓕_k = σ(z_{1:t}, cond_{1:t}, ξ_{1:k}, V_{1:k}) — inclui o ruído dos difusores +ξ e as avaliações do verificador. G_k = 1{conf_k < τ_c} é composição mensurável de +(conf ∘ softmax ∘ logits)(resposta_k) com resposta_k função de (cond, ξ_{≤k}, θ) ⇒ +G_k é 𝓕_k-mensurável; nenhum z_{t+1} entra. A temperatura T_{k+1} = 1.6·T_k é +adaptada ao PASSADO (𝓕_k-mensurável) — previsível, logo o processo de exploração +é adaptado e a causalidade é formal, não conceitual. ∎ +Teste: teste_causalidade_gatilho — mesmas entradas ⇒ mesma decisão (bit-a-bit). + +## T-P2′ (agregação ponderada — MSE exato e N_eff) +Para pesos w DETERMINÍSTICOS (Σw=1) e erros independentes: E‖Σw oᵢ − alvo‖² = +tr(Σ)·Σwᵢ² = tr(Σ)/N_eff, N_eff = 1/Σwᵢ² ≤ N. ∎ (produto cruzado nulo). +**Limitação honesta:** os pesos de coerência wᵢ ∝ exp(4cos(oᵢ,ō)) dependem dos +próprios candidatos ⇒ não-determinísticos; a identidade vale condicionalmente e o +viés de seleção é O(cov(w,ε)). Mitigação: Hedge sobre perdas OBSERVADAS (RE-6) — +pesos previsíveis (função do passado), recuperando a garantia sem condição. +Hoeffding (b) e best-of-N (c) da r-21 permanecem válidos (eventos discretos, w não entra). + +## T-P3 (ridge — mantida; igualdade caracterizada) +r* = (WᵀW+εI)⁻¹Wᵀr_alvo; Q estritamente convexa ⇒ mínimo global único; resíduo +mínimo ‖(I−W(WᵀW+εI)⁻¹Wᵀ)r_alvo‖; ε→0 ⇒ Tikhonov→Moore–Penrose. ∎ (r-21 correta.) + +## T-P4 (terminação/soundness — mantida) Φ(k)=B−k; indução bem-fundada; melhor +candidato por indução; orcamento_esgotado=1 auditado. ∎ + +## T-P5′ (IDENTIDADE EXATA da massa de atenção — substitui a cota heurística) +**Teorema.** Sejam s_j = q·k_j/√d, Z_b = Σ_{base} e^{s}, Z_e = Σ_{extra} e^{s}, +π = Z_e/(Z_b+Z_e), ȳ_e = Σ_{extra}(a_j/π)v_j. Então + y_full − y_base = π·(ȳ_e − y_base) (EXATA — verificado erro 1.1e-16). +Prova. Para j∈base: a′_j = e^{s_j}/(Z_b+Z_e) = a_j·(1−π). Logo +y_full = (1−π)y_base + πȳ_e ⇒ Δy = π(ȳ_e−y_base). ∎ +**Corolários.** (i) ‖Δy‖ ≤ 2·V_max·π, V_max = max‖v‖_∞ (ambos os blocos); +(ii) π ≤ Z_e/Z_b ≤ n_e·exp(s_max_e)/Z_b — para scores pequenos, π ≈ Z_e/Z_b e a +cota da crítica L_g = ‖q‖·max‖k_e‖·max‖v_e‖/√d é o termo de 1ª ordem (π ≤ +n_e·‖q‖K_e/√d + O(s²) com Z_b ≥ 1 após deslocamento); (iii) neutralidade g=0: +bit-a-bit (0·δ=0 IEEE-754) — mantida; (iv) ∂y_int/∂g = Δy ≠ 0 ⇒ gate aprende. ∎ +**Consequência de projeto:** π é o botão de ÊNFASE mensurável — a base do +certificado de compressão RE-2 (r-42): remover peças com massa removida π_rem +custa no máximo 2|g|V_max·π_rem na saída. + +## T-P6′ (composição d=a+b+c sob treino conjunto — re-enunciado honesto) +A fatoração por regra da cadeia NUNCA quebra (é identidade). O que o treino +conjunto (fase C) pode degradar: (i) o gap TC intra-nível (B.1) — medir por nível; +(ii) a CALIBRAÇÃO do verificador (mudança de distribuição dos logits) ⇒ recalibrar +T* após cada fine-tune conjunto e re-medir ECE (V-2′) — condição explícita do +soundness. Com perdas separadas (v0.5) nada disso se move; com PCGrad (v0.6) o +item (ii) é obrigatório no pipeline. ∎ (documentar; regularizador MI opcional.) + +## T-P7 (custo — mantido) Θ(B·N·d_cond·d_h); N paralelizável (rayon, seeds s+i). ∎ \ No newline at end of file diff --git a/docs/memorias/r-40-provas-verificador-v011.md b/docs/memorias/r-40-provas-verificador-v011.md new file mode 100644 index 0000000000000000000000000000000000000000..a0eb7e10709b42e3688d5ce6e6c2bfea03e827a4 --- /dev/null +++ b/docs/memorias/r-40-provas-verificador-v011.md @@ -0,0 +1,44 @@ +# r-40 — PROVAS VERIFICADOR COMPLETADAS (v0.11) · objeto: src/verificador.rs + +## N-2 (convexidade GLOBAL em γ=1/T — prova) +L̃(γ) = (1/n)Σᵢ [logsumexp(γzᵢ) − γz_{i,yᵢ}]. O Hessiano de logsumexp em γ é +Var_{p_γ}(z) ≥ 0 (familia exponencial: ∂²/∂γ² lse = E_p[z²]−E_p[z]²); o termo linear +não contribui ⇒ L̃″(γ) = (1/n)Σᵢ Var_{pᵢ}(zᵢ) ≥ 0 SEMPRE, > 0 se algum logits não +for constante. L̃′(γ) = (1/n)Σᵢ(E_{pᵢ}[zᵢ] − z_{i,yᵢ}). ∎ +(Corrige de vez a errata Qwen: sinal e ordem da diferença — testes n1/n3 cobrem.) + +## N-3/N-4 (Newton com salvaguarda — convergência) +Colchão [a,b] com L̃′(a)<00 ⇒ taxa quadrática padrão de Newton. Bordas: +L̃′(lo)≥0 ⇒ T*=8; L̃′(hi)≤0 ⇒ T*=1/8 (testes n4b cobrem os dois extremos). ∎ + +## V-2′ (soundness SEM oráculo — cota CONDICIONAL corrigida) +**Errata:** a cota r-23 "P(erro|aceito) ≤ 1−τ_c + ECE" só vale com ECE medido NO +CONJUNTO ACEITO. Com ECE global, o correto é: +**Teorema.** Seja A = {conf ≥ τ_c}, p_a = P(A) > 0, e +L₁ = E|1{acerto} − conf| (calibração L1; ECE por faixas é seu estimador). Então +P(erro | A) ≤ (1−τ_c) + L₁/p_a. +Prova. P(erro|A) = 1 − E[1{acerto}|A] ≤ 1 − E[conf|A] + E[|1{acerto}−conf| | A] +≤ 1 − τ_c + L₁/p_a (condicionamento: E[X|A] ≤ E[X]/P(A) para X≥0). ∎ +Verificado em simulação (n=2e5, viés senoidal): 0.1372 ≤ cota corrigida ✓. +**Implementação:** reportar ECE_aceito (faixas restritas a conf ≥ τ_c) — então a +cota limpa 1−τ_c+ECE_aceito vale; p_a vem de graça do quantil (≈ ε por V-3). + +## V-3 (quantil DKW — prova do sanduíche) +Evento E = {sup_x|F̂_n(x)−F(x)| ≤ δ}, P(E) ≥ 1−2e^{−2nδ²} (DKW–Massart). Em E: +F̂(τ̂)≥1−ε ⇒ F(τ̂) ≥ 1−ε−δ ⇒ P(conf < τ̂) ≤ ε+δ… logo a fração de aceite é +≥ ε−δ e ≤ ε+δ; combinando com V-2′ (τ̂ no lugar de τ_c) a taxa de erro conjunta +é controlada com probabilidade ≥ 1−2e^{−2nδ²} sobre a amostra retida. ∎ +Nota: o quantil controla a TAXA DE ACEITE; o soundness vem de V-2′ — não confundir +(o comentário "aceitar ~80%" no teste v2 está trocado: ε=0.2 ⇒ aceita ~20%). + +## V-4 (entropia estável — identidade) +H(p) = −Σp log p com p=softmax(z): log p = z − lse(z) ⇒ H = lse(z) − Σp·z. +Sem 0·log0 (0·z=0 exato); lse estável por deslocamento do máximo. ∎ (código ok.) + +## Limitações honestas +1. ECE por faixas tem viés de discretização O(1/faixas) — reportar n por faixa. +2. Calibração em dados retidos pressupõe exchangeability com produção; sob drift, + recalibrar (gate A-1 já reage via DKW, mas T* precisa de re-ajuste periódico). \ No newline at end of file diff --git a/docs/memorias/r-41-provas-moe-fnh-v011.md b/docs/memorias/r-41-provas-moe-fnh-v011.md new file mode 100644 index 0000000000000000000000000000000000000000..3cb8667fdc3b7cea5aa74c52f61cbcde99a86619 --- /dev/null +++ b/docs/memorias/r-41-provas-moe-fnh-v011.md @@ -0,0 +1,62 @@ +# r-41 — PROVAS MoE REDIRECIONÁVEL + FNH (v0.11) · objetos: moe_redirecionavel/, fnh.rs + +## M-R1′ (invariância por permutação de papéis — prova) +O roteamento depende do CONJUNTO de especialistas do papel (máscara −inf) e das +probs softmax restritas a ele; a perda auxiliar e_local·Σ f_e·p̄_e é simétrica nos +índices locais. Redirecionar por permutação σ apenas re-rotula ⇒ distribuição de +saída invariante em lei (e bit-a-bit se a ordem de acumulação seguir a ordem +canônica dos índices). Classe fechada sob composição de permutações (S_E). ∎ + +## M-R3 (paralelismo determinístico — prova) +Papéis usam subconjuntos DISJUNTOS de especialistas; forward não muta estado +(&self); index_add acumula em ordem fixa do laço de designação; pesos vêm do +mesmo tensor probs. Dois threads executam DAGs independentes com as mesmas +entradas ⇒ saídas bit-a-bit iguais às sequenciais (assert dif<1e-9 no código; +na prática dif=0). ∎ + +## M-R6/M-R7 (grafo vivo — prova de fluxo de gradiente) +saida = Σ_e index_add(idx_e, f_e(y[idx_e])·w_e) / Σw; index_add é op rastreada ⇒ +∂L/∂θ_e = Σ idx (∂f_e/∂θ)ᵀ·(g·w) e ∂L/∂roteador via w = probs[idx,e] (vivo). +A seleção discreta é constante no grafo (argmax não-diferenciável — padrão +Switch); f constante, p̄ vivo na aux. O caminho DEPRECIADO (to_vec2/from_vec) +secciona o grafo — mantido só como oráculo de teste. ∎ + + +> **ERRATA v0.11.0 (verificação exaustiva):** o custo do guloso no +> contraexemplo é **31,79418** (c=[2,3,2,1,5]), não 31,787 como escrito +> abaixo; o arredondar custa 33,195 (perda de 4,2%). A alocação e a +> otimalidade do guloso CONFEREM (guloso == força bruta, teste +> `m_r5_guloso_vs_forca_bruta`); apenas a constante tinha dígito errado. + +## M-R5′ (water-filling INTEIRO — ótimo por guloso marginal; errata do arredondar) +**Teorema.** min Σ qᵢ²/cᵢ s.a. Σcᵢ=C, cᵢ∈ℕ₊. (a) Relaxado: Cauchy–Schwarz +(Σqᵢ)² = (Σ(qᵢ/√cᵢ)√cᵢ)² ≤ (Σqᵢ²/cᵢ)·C ⇒ mínimo (Σq)²/C em cᵢ ∝ qᵢ. ∎ +(b) Inteiro: o ganho marginal Δᵢ(c) = qᵢ²(1/c − 1/(c+1)) é estritamente +decrescente em c (convexidade separável). Guloso: comece cᵢ=1, adicione C−m +unidades ao maior Δ. Ótimo global por argumento de troca: se o ótimo difere, +existe par (i,j) com cᵢ acima e cⱼ abaixo do guloso; mover uma unidade j→i +reduz o custo (Δⱼ(cⱼ) > Δᵢ(cᵢ−1) pela ordem de escolha), contradição. ∎ +**Errata do código atual (alocar_por_qe):** arredondar+reparar NÃO é ótimo. +Contraexemplo verificado: q=[3.83,4.17,2.47,0.48,8.77], C=13 ⇒ repo c=[3,3,2,1,4] +custo 33.198; guloso c=[2,3,2,1,5] custo 31.787 (−4.3%). Correção: 6 linhas +(laço guloso) — teste m_r5_guloso_vs_forca_bruta (n≤5, C≤14, exaustivo). + +## F-9′ (Cayley ∈ SO(n) — prova algébrica completa) +Bᵀ=−B ⇒ I−B invertível (autovalores de B imaginários puros; 1 não é autovalor). +R=(I−B)⁻¹(I+B): RᵀR = (I−Bᵀ)(I+Bᵀ)ᵀ… diretamente: (I+B)ᵀ(I+B) = (I−B)(I+B) = +(I+B)(I−B) (comutam) ⇒ RᵀR = (I+B)⁻¹(I−B)(I−B)⁻¹(I+B)… usando comutatividade, +RᵀR = I. det R = Π(1+iλ)/(1−iλ) = 1 (pares conjugados, módulo 1, produto real +positivo; ou: caminho contínuo B(t)=tB de 0 a B sem singularidade ⇒ det constante += det I = +1). θ=0 ⇒ B=0 ⇒ R=I bit-a-bit; gradiente flui (grafo da inversão). ∎ +**F-10 ( auditoria):** Newton–Schulz X_{k+1}=X_k(2I−MX_k) tem erro E_{k+1}=E_k² +⇒ convergência quadrática SE ρ(E_0)<1, E_0=I−M X_0. Para M=I−B, X_0=I: E_0=B — +o clamp por ENTRADA (|θ|≤0.5) NÃO garante ρ(B)<1 para n grande (‖B‖₂ pode chegar +a ~θ·cot(π/2n)). Ação: verificar a implementação (escalonamento/damping) ou +provar ρ<1 sob o clamp efetivo; o teste f10 (n=16) passa, mas a garantia formal +exige a condição espectral explícita. (Honestidade: condição suficiente, não +necessária — pode convergir fora dela por estrutura de B.) + +## Limitações honestas +1. M-R1 vale em lei para roteamento com empates desfeitos por índice (permutação + muda desempates) — fixar desempate por chave estável independente do papel. +2. F-10 é item de auditoria, não teorema novo — não declarar convergência geral. \ No newline at end of file diff --git a/docs/memorias/r-42-raciocinio-elastico-v011.md b/docs/memorias/r-42-raciocinio-elastico-v011.md new file mode 100644 index 0000000000000000000000000000000000000000..aa74884e220d7e0340454ee9840301c97da67416 --- /dev/null +++ b/docs/memorias/r-42-raciocinio-elastico-v011.md @@ -0,0 +1,112 @@ +# r-42 — RACIOCÍNIO REAJUSTÁVEL E COMPRIMÍVEL (v0.11) +## objeto NOVO: src/pensamento/raciocinio_elastico.rs · teoremas RE-1..RE-8 + +## 0. Especificação (o que "reajustável" e "comprimível" significam FORMALMENTE) + +O pensamento mantém um BANCO DE PEÇAS P = {(vᵢ, ρᵢ, πᵢ, custoᵢ)} — vetores de +raciocínio (saídas das N tentativas + estados intermediários), cada um com +relevância ρᵢ (ganho marginal de confiança, EMA), massa de atenção πᵢ e custo em +tokens/conceitos. Dois mecanismos fechados: + +1. REAJUSTE (ênfase no que é relevante para a SOLUÇÃO): a cada iteração k, + (a) ρᵢ ← EMA do ganho marginal de confiança quando a peça participa; + (b) pesos de agregação por Hedge sobre perdas passadas (previsíveis ⇒ T-P2′); + (c) orçamento B e taxas realocados por water-filling de relevância (RE-5); + (d) τ_c/B/N pelo autoajuste existente A-1..A-5 + A-6 (ε de compressão pela margem). +2. COMPRESSÃO (com CERTIFICADO): remover/fundir peças e truncar prefixos NCM + sem perder o aceite — a remoção é limitada pela margem de confiança (RE-2), + e o refinamento é anytime (RE-3). Compressão NÃO é heurística: é uma operação + com cota de erro provada e verificada em runtime (rollback se violada). + +## RE-1 (identidade da massa — herdada de T-P5′, base de tudo) +Δy = π(ȳ_e − y_base), π = Z_e/(Z_b+Z_e); ‖Δy‖ ≤ 2V_max·π. ∎ (r-39.) + +## RE-2 (CERTIFICADO DE COMPRESSÃO — soundness preservado) +Hipóteses: (H1) logits z = W·y com ‖z‖_∞ ≤ Z_sup no segmento [y, y′] (invariante +de clip de logits — verificado em runtime); (H2) confiança conf = 1−H(softmax(z))/ln K; +(H3) remoção de peças com massa total π_rem; gate g. +**Lema (Lipschitz da confiança).** ∇_z H = −p⊙(z−E_p[z]) (derivação: H = lse−Σpz; +∇lse = p; ∇(Σpz) = p + J_soft·z; J_soft·z = p⊙z − p·E_p[z]). Logo +‖∇_z H‖₂ ≤ max_j|z_j−E_p z|·‖p‖₂ ≤ 2Z_sup e +L_conf = 2·Z_sup·‖W‖₂/ln K. ∎ (verificado: grad analítico vs FD erro 1.7e-10.) +**Teorema.** Se conf(y) − τ_c = m > 0 e + π_rem ≤ ε_safe := m / (2·|g|·V_max·L_conf), +então conf(y′) ≥ τ_c — o aceite é PRESERVADO pela compressão. +Prova. |conf(y′)−conf(y)| ≤ L_conf‖y′−y‖ (valor médio no segmento, H1) +≤ L_conf·2|g|V_max·π_rem (RE-1 aplicado à diferença das massas) +≤ L_conf·2|g|V_max·ε_safe = m. ∎ +**Validação numérica:** 141 cenas com margem, 166 peças removidas, 0 violações. +**Operacionalização:** comprimir → re-verificar (1 fwd barato) → rollback se +violado (defesa em profundidade contra H1 falso). ε_safe é REAJUSTADO a cada +iteração pela margem corrente — compressão adaptativa com garantia. + +## RE-3 (compressão ANYTIME por prefixos NCM — taxa monotônica) +Cada peça pode ser armazenada como códigos residuais c_{1:ℓ} (A.1/A.2). O +decoder de prefixo ℓ tem distorção V(ℓ) não-crescente em ℓ (inclusão de classes) +⇒ truncar para ℓ′ < ℓ aumenta a distorção de forma CONTROLADA e re-expansão +restaura exatamente (códigos são lossless dado o codebook). Taxa: ℓ·log₂K bits +por peça — a escada de compressão é o próprio nested dropout do tokenizador. +Acoplamento com RE-2: escolher o menor ℓ tal que a distorção induzida Δy respeite +ε_safe (busca binária em ℓ — V monotônica ⇒ O(log L)). ∎ + +## RE-4 (terminação elástica) +Realocações de orçamento entre peças NÃO aumentam o total: invariante Σbᵢ ≤ B_max; +o potencial Φ(k) = B_max − k decresce estritamente ⇒ término em ≤ B_max iterações +(mesma indução de T-P4). Compressão e re-expansão são operações internas à +iteração — não tocam Φ. Honestidade: orcamento_esgotado auditado. ∎ + +## RE-5 (realocação por relevância — water-filling ótimo) +Alocar C unidades de compute/tokens entre peças com resíduo de relevância qᵢ +(qᵢ = ρᵢ·erro_residualᵢ): min Σ qᵢ²/cᵢ ⇒ guloso marginal é ÓTIMO inteiro (M-R5′). +Peças relevantes ganham mais orçamento; irrelevantes ficam com 1 (não zero — +exploração mínima). ∎ + +## RE-6 (ênfase reajustável por Hedge — arrependimento sublinear) +Perdas ℓᵢ^{(k)} = 1 − ganho_marginalᵢ normalizado ∈ [0,1]; pesos +wᵢ^{(k)} ∝ exp(−η Σ_{s 0: COMPRIMIR com ε_safe (RE-2) → re-verificar → rollback? + │ + truncar prefixos NCM (RE-3, busca binária) + ├─ m ≤ 0: EXPANDIR (T_k×1.6, restaurar prefixo, re-semear tentativa) + └─ realocar B entre peças (RE-5 guloso) + A-1..A-5 (controlador) [existente] + ▼ + resposta com certificado: {conf, π_rem, ε_safe, bound, violado=0} + +Novo autoajuste A-6: ε corrente ← mediana dos ε_safe usados com aceite +(quantil DKW como A-1) — auditado com motivo na telemetria. + +## 2. Limitações honestas +1. H1 (clip de logits) é INVARIANTE DE ENGENHARIA — o código verifica Z_sup no + segmento e faz rollback se violado; sem clip, L_conf é local, não global. +2. V_max e ‖W‖₂ são medidos por passada (norma espectral por power-iteration, + 20 iterações — cota superior por ‖W‖_F se mais barato). +3. Hedge supõe perdas em [0,1] — ganhos marginais são clipados; o clip enviesa + a ênfase para ganhos grandes (documentado, desejável aqui). +4. Fusão de peças por média herda S4-1′: só certifica ENERGIA, não QE — fundir + apenas pares com cosseno ≥ 1−δ e re-verificar (rollback cobre o resto). \ No newline at end of file diff --git a/docs/memorias/r-43-tratamento-erros-asm-v011.md b/docs/memorias/r-43-tratamento-erros-asm-v011.md new file mode 100644 index 0000000000000000000000000000000000000000..b37df6db394e2cd652f8e7f5f2e80394076388f1 --- /dev/null +++ b/docs/memorias/r-43-tratamento-erros-asm-v011.md @@ -0,0 +1,180 @@ +# 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 + +## 0. Escopo e método + +O documento `tratamento.txt` prescreve: (§1) em Rust, erros recuperáveis +via `Result` propagados com `?`, enums coesos no padrão +`module::error` (thiserror), proibição de `unwrap`/`expect`/`panic!` em +código de produção, nada silenciado sem log consciente; (§2) em Assembly, +detecção por Registrador de Flags (CF/OF/ZF/PF), saltos condicionais +(`jcc`), códigos de retorno em registrador (0 = sucesso) e documentação +rigorosa de clobbers. Cada item abaixo foi implementado, PROVADO e +TESTADO por falsificação. + +## 1. Teorema ASM-1 (soma u64 — exatidão e estouro por Carry Flag) + +**Kernel.** `soma_u64_cheia(xs: &[u64]) -> Result`: +``` +xor {e}, {e} ; e := 0 (sucesso) [ZF=1] +2: add {s}, [{p}] ; soma += *p [AF CF OF SF ZF PF] + jc 3f ; CF=1 ⇒ estouro sem sinal ⇒ ERRO + add {p}, 8 ; (flags alteradas, NÃO consumidas) + cmp {p}, {f} ; p == fim? [CF OF SF ZF PF] + jne 2b ; ZF=0 ⇒ itera + jmp 4f +3: mov {e}, 1 ; código de erro 1 (registrador) +4: +``` + +**Teorema (exatidão).** Para todo `xs` com Σxs < 2^64: o kernel devolve +exatamente Σxs (a adição de 64 bits sem CF é a soma matemática exata — +complemento-2 sem sinal é homomorfismo de monoide abaixo de 2^64). ∎ + +**Teorema (estouro).** Se em alguma parcela a soma parcial excede 2^64−1, +o processador arma CF=1 naquele `add` (definição de carry em adição sem +sinal — Intel SDM, ADD) e `jc` desvia ANTES de qualquer instrução que +altere flags (`add {p},8` vem depois). Não há estado intermediário: OU +todas as parcelas cabem (retorno Ok exato), OU a primeira que estoura é +detectada (retorno Err — a soma parcial é descartada). ∎ + +**Corolário (determinismo).** Ordem única de soma (esq→dir) ⇒ resultado +bit-a-bit reprodutível (u64 é associativo/exato). ∎ +Testes: `soma_estoura_na_segunda_parcela` (u64::MAX+1 ⇒ Err); +`soma_equivalente_rust` (8 casos aleatórios == iterador Rust; fronteiras +exatas em u64::MAX). + +## 2. Teorema ASM-2 (detecção de NaN por Parity Flag) + +**Kernel.** `primeiro_nan_f64/f32(xs) -> Result, ErroAsm>`: +``` +2: ucomisd {zero}, [{p}] ; 0.0 vs xs[i] [ZF PF CF] + jp 3f ; PF=1 ⇒ UNORDERED ⇒ NaN no índice i + add {p}, 8 / add {i},1 ; (flags não consumidas) + cmp {i}, {n} ; jne 2b + mov {i}, -1 ; sentinel NOT_FOUND (u64::MAX) +``` + +**Teorema.** `ucomisd`/`ucomiss` armam PF=1 ⇔ a comparação é UNORDERED +⇔ algum operando é NaN (Intel SDM, UCOMISx: a exceção #I mascarada de +QNaN/SNaN tem como ÚNICO efeito observável PF=1). Como o operando imediato +é a constante 0.0 (sempre ordenada), PF=1 ⇔ o ELEMENTO xs[i] é NaN (por +eliminação: se xs[i] fosse ordenado, a comparação com 0.0 seria ordenada). +Logo o kernel devolve o índice do PRIMEIRO NaN, ou None (sentinel −1) +se a fatia é limpa; ±∞ NÃO dispara (comparação ordenada) — testado. ∎ + +**Nota (convenção de retorno).** O índice (ou −1) viaja em registrador de +propósito geral — o chamador sabe ONDE, não apenas SE (tratamento.txt §2: +"códigos de retorno em registradores"). O Rust converte para +`Result, _>` — nenhum caminho silencioso. + +## 3. Teorema ASM-3 (integração AdamW — diagnóstico localizado) + +**Integração.** `AdamWManual::clipar` varre os gradientes com +`primeiro_nan_f32` ANTES da norma: NaN ⇒ log::warn com TENSOR e ÍNDICE +(`grad não-finito: NaN no tensor {ti}, índice {idx} — kernel ucomiss/jp`) ++ passo zerado (mesma semântica v0.6.0). A guarda `is_finite` da norma +permanece como rede de segurança (defesa em profundidade). + +**Teorema (equivalência de decisão).** Para todo g: [∃ NaN em g] ⇒ +[norma_global(g) não-finita] — e a recíproca vale para NaN (mas não para +overflow do quadrado em f64, que o scan não captura e a guarda sim). Logo +a composição scan→guarda captura SUPERCONJUNTO do que a guarda sozinha +capturava, com custo O(n) por elemento e diagnóstico localizado. ∎ +(Relevância direta: panic em thread de treino = processo morto "sem erro +nem OOM" — exatamente o sintoma que o usuário reportou no ambiente.) + +## 4. Auditoria de unwrap/expect/panic (tratamento.txt §1) + +Medição (telemetria_v011.json, T8 — linhas de código, sem comentários): +total 109 em produção, sendo bench_v090 54 (binário de MEDIÇÃO, +assertivo por design), lib.rs 57 (demos PyO3: panic atravessa a fronteira +pyo3 como PyErr — NÃO é silêncio), ponte 6, mascaras 4, demais ≤ 2. + +**Ações executadas (não só medição):** +1. **13 sort/max por `partial_cmp().unwrap()` → `total_cmp`** (telemetria, + verificador, moe, som4d, jepa, pensamento, quantizador, nlg, + controlador, lib, bench): um único NaN numa série de treino causava + PANIC no comparador (Rust: `partial_cmp` devolve None para NaN). + `total_cmp` é ordem total (IEEE 754-2019 totalOrder) — nunca panic, + NaN ordena deterministicamente após +∞. Prova de equivalência em + dados finitos: totalOrder(a,b) = ordering(a,b) para a,b finitos. ∎ +2. **AdamW `passo`**: extração/reconstrução de tensor sem unwrap — falha + estrutural (impossível por construção) vira `log::error` + variável + pulada; nunca aborta o treino sem rastro. +3. **GatePunicao::valor_tipado** (tipos.rs restaurado): falha + impossível-por-teorema (F-3: sigmoide retificada ∈ [0,1]) vira clamp + ZERO + log — defesa em profundidade tipada. +4. **asm.rs/raciocinio_elastico.rs**: ZERO unwrap em produção (tudo + `Result` com `?` e `bail!` específico). +Débito priorizado: lib.rs demos → migração gradual para `?` (panic já +vira PyErr; risco baixo, volume alto). + +## 5. Registro de decisões e erratas v0.11 (autocrítica) + +1. **v011-1 (meu bug, asm!)**: a 1ª versão do kernel modificava um + operando `in(reg)` (`add {p}, 8`) — UB de alocação de registradores + (SIGSEGV/SIGABRT nos testes). Corrigido: `p = inout(reg)`. Capturado + pelos PRÓPRIOS testes asm antes de qualquer uso. +2. **v011-2 (labels LLVM)**: labels `1:` em asm! colidem com literal + binário em x86 (bug LLVM #99547) — renumerados 2/3/4. +3. **v011-3 (dimensional, rascunho da sessão anterior)**: o + `raciocinio_elastico.rs` recebido chamava `motor.agregar(matriz_de_pecas)` + com P ≠ n linhas — o combinador linear tem largura FIXA d·n (erro de + forma em runtime). Corrigido: montagem aprendida sobre os n candidatos + CORRENTES; média de ênfase Hedge sobre todas as peças (documentado no + método). +4. **v011-4 (bound RE-2 estendido — r-42 §2.2-rev)**: o certificado + original cobre só a via gateada (massa de atenção); nossa agregação tem + TAMBÉM a média de ênfase (não gateada). Com gate=0 o bound original é 0 + e TODO commit virava rollback (8/8 na 1ª rodada). Extendido por + desigualdade triangular: + `‖Δy‖ ≤ 2|g|V_max·π_rem + Σ_{i∈rem} w_i‖v_i‖ + (W_rem/(1−W_rem))·Σ_{i∈fic} w_i‖v_i‖` + (2º termo: remoção direta; 3º: renormalização dos mantidos — prova por + decomposição da média ponderada e triangular). Resultado: commits + seguros passam (0 rollbacks no demo e nos dados reais), violações + continuam protegidas pelo rollback. +5. **v011-5 (M-R5′ constante)**: r-41 dizia 31,787; enumeração exaustiva + dá 31,79418 (errata aplicada ao doc; teste corrigido com bruto no + contraexemplo). +6. **v011-6 (E0761 — árvore canônica)**: o ramo SRP split (30/out) e o + trabalho v0.11 nos arquivos planos (01/nov) não podem coexistir + (E0761: `mod jepa` ambíguo). Decisão: canon = planos (linha rastreada + com todo o trabalho DeepSeek); split ARQUIVADO em `arquivo_split_v100/` + com LEIA-ME. Os módulos FUNCIONAIS exclusivos do split (checkpoint + atômico CP-1/CP-2, tipos de domínio T-V*) foram PORTADOS de volta + (src/checkpoint.rs, src/tipos.rs + `valor_tipado`) — nenhuma + funcionalidade v0.10 perdida (suíte v8 verifica). O SRP estrutural + permanece DÉBITO com justificativa (risco de regressão vs. ganho zero + de comportamento; 25,7 s de compilação incremental medida). +7. **v011-7 (restauração ampla)**: `Bpe.salvar/carregar` e + `tokenizador/gerador.salvar` agora usam `checkpoint::salvar_atomico` + (tmp→fsync→rename→fsync(dir)+manifesto SHA-256); carregar é + retrocompatível (legado sem manifesto lê com aviso). Verificado nos + checkpoints do TREINO REAL (telemetria T4: válido=True). + +## 6. Limitações honestas + +1. Os kernels asm são ESCALARES (1 elemento/iteração) — o objetivo é a + correção do protocolo de erros por flags, não throughput (o throughput + SIMD já é coberto pelo simd.rs v0.9 bit-a-bit). Bench: ≤ 10× pior que + o iterador Rust no pior caso aceito (medição no teste; tipicamente ~1×). +2. `ucomisd` com SNaN: além de PF=1, sinaliza #I — mascarado por padrão + no MXCSR do processo Rust (sem efeito observável). Documentado. +3. lib.rs mantém 57 unwraps em demos (PyErr, não silêncio) — dívida + priorizada §4. +4. O split SRP (C-batch) permanece arquivado; a suíte v0.10 s1 + ("monólitos dissolvidos") foi SUBSTITUÍDA pela v8 ("funcionalidade + v0.10 preservada + arquivo documentado") — decisão registrada, não + ocultada. + +## 7. Veredito consolidado + +- cargo: **160/160** (3× consecutivas — determinismo; 111 v0.9 → 123 v0.10 + → 160 v0.11); +- suíte 79 (gates Python): **29/29** (incl. SHA-256 vs hashlib, roundtrip + atômico, corrupção detectada, V-2′ com errata reproduzida, elástico, + H-1′ pin real, Weiszfeld contraexemplo, M-R5′, preservação v0.10); +- avaliação REAL (80): **9/9** — Wikipédia PT-BR 273 artigos; MoE real + −98,3% de perda; H-SOM pin teorema em latentes reais; elástico em + latentes reais (d=64) com certificados RE-2 e V-2′ limpo. +∎ diff --git a/pyproject.toml b/pyproject.toml index 16372c89828488ce2c5ccdd5095c15b3dc21509c..fa24d132e0e8e47785608a2b7e9e436f4b92d162 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "maturin" [project] name = "khtst-rust" -version = "0.9.0" +version = "0.11.0" 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)" requires-python = ">=3.10" license = { text = "Apache-2.0" } diff --git a/resultados/avaliacao_real_v011.json b/resultados/avaliacao_real_v011.json new file mode 100644 index 0000000000000000000000000000000000000000..d846b2eb4394b49e7d442a50f7488453ca05da93 --- /dev/null +++ b/resultados/avaliacao_real_v011.json @@ -0,0 +1,104 @@ +{ + "versao": "0.11.0", + "dados": { + "sequencias": 1121, + "fonte": "wikimedia/wikipedia 20231101.pt" + }, + "estados_apagados": [], + "fase_a": { + "acc_recon": 0.0078125, + "coerencia_welch_max": 6.292625442938515e-08, + "delta_ort_max": 8.618585986439659e-07, + "escore_aprendizado": 0.3590135625816785, + "monotonia_prefixo": 0.6666666666666666, + "passos": 197, + "perda_final": 9.057642936706543, + "perda_inicial": 9.875566482543945, + "perplexidade_codebook": 49.73847552123822, + "tc_intra_nivel_medio": 0.0, + "tempo_s": 205.7 + }, + "fase_b": { + "acc_conceitos": 0.11397879464285714, + "coerencia_welch_max": null, + "escore_aprendizado": 0.18799816592514204, + "passos": 400, + "perda_final": 3.908881800515311, + "perda_inicial": 4.287496158054897, + "tc_intra_nivel_medio": null, + "tempo_s": 202.5 + }, + "latentes": { + "shape": [ + 16384, + 64 + ] + }, + "som_real": { + "media": { + "eq_fim": 0.28111534700655316, + "eqm_fim": 0.0795731406246479, + "te": 0.005333333333333333, + "phi_mono": true + }, + "mediana": { + "eq_fim": 0.21755883916761862, + "eqm_fim": 0.07034444427760844, + "te": 0.38466666666666666, + "phi_mono": true + }, + "hsom_sem_pin": { + "eq_hier": 0.006507537877947533, + "eq_grosso": 0.07338894257713915 + }, + "hsom_com_pin": { + "eq_hier": 0.00745762430733415, + "eq_grosso": 0.07338894257713915 + } + }, + "moe_real": { + "perda_inicial": 0.021136272698640823, + "perda_final": 0.0003528775996528566, + "queda_pct": 98.33 + }, + "elastico_real": { + "origem": "reais", + "d_cond": 64, + "d_saida": 64, + "conf_media": 1.0, + "iteracoes_media": 1.0, + "certificados": 8, + "rollbacks": 0, + "tempo_s": 0.6, + "v2_linha": { + "cota_corrigida": 0.4, + "cota_limpa": 0.4, + "cota_limpa_respeitada": true, + "ece_aceito": 0.0, + "l1_global": 0.0, + "n_aceito": 120, + "p_aceite": 1.0, + "p_erro_aceito": 0.0, + "tau_c": 0.6 + }, + "gates_demo": { + "gate_calibrado": true, + "gate_rollback_so_se_violado": true, + "gate_sem_violacoes": true, + "gate_terminou_elastico": true + } + }, + "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)", + "avaliacao_real_gates": { + "fase_a_treinou": true, + "fase_b_treinou": true, + "som_phi_monotono_ambos": true, + "hsom_pin_teorema_real": true, + "moe_real_aprendeu": true, + "elastico_origem_reais": true, + "elastico_certificados_presentes": true, + "v2_cota_limpa_real_respeitada": true, + "v2_p_aceite_real_positiva": true + }, + "veredito_real": "9/9" +} \ No newline at end of file diff --git a/resultados/suite_v011_final.json b/resultados/suite_v011_final.json new file mode 100644 index 0000000000000000000000000000000000000000..d3c8734a444cd713b05f0ed3f0193ebee3fed1ad --- /dev/null +++ b/resultados/suite_v011_final.json @@ -0,0 +1,73 @@ +{ + "versao": "0.11.0", + "blocos": {}, + "gates": { + "v1_versao_0110": true, + "v1_kernels_asm_registrados": true, + "v1_binding_v2_soundness": true, + "v1_binding_elastico": true, + "v2_sha256_confere_hashlib": true, + "v2_checkpoint_manifesto_presente": true, + "v2_checkpoint_valido": true, + "v2_checkpoint_corrupcao_detectada": true, + "v2_carregar_retrocompativel": true, + "v3_mr5_guloso_vs_bruto": true, + "v8_cargo_158_mais": true, + "v4_cota_limpa_respeitada": true, + "v4_p_aceite_positiva": true, + "v4_cotas_finitas": true, + "v4_errata_ece_global_e_violavel": true, + "v4_errata_cota_limpa_cobre": true, + "v5_gates_elasticos": true, + "v5_certificados_presentes": true, + "v5_epsilon_seguro_nao_negativo": true, + "v6_pin_eq_hier_le_eq_grosso_exato": true, + "v6_cota_minkowski_pin": true, + "v6_cota_minkowski_sem_pin": true, + "v7_mediana_nao_piora_contraexemplo": true, + "v7_phi_monotono_media": true, + "v7_phi_monotono_mediana": true, + "v8_split_arquivado_documentado": true, + "v8_modulo_checkpoint_presente": true, + "v8_modulo_tipos_presente": true, + "v8_cargo_deterministico": true + }, + "medicoes": { + "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)", + "cargo_total": 160, + "testes_chave_faltando": [], + "v2_linha": { + "cota_corrigida": 1.404, + "cota_limpa": 0.4645, + "cota_limpa_respeitada": true, + "ece_aceito": 0.1645, + "l1_global": 0.4361, + "n_aceito": 2370, + "p_aceite": 0.395, + "p_erro_aceito": 0.3165, + "tau_c": 0.7 + }, + "v2_errata": { + "p_erro_aceito": 0.2125, + "cota_antiga_ece_global": 0.1173 + }, + "elastico": { + "confianca_media": 0.6859, + "iteracoes_media": 1.0, + "certificados": 8, + "rollbacks": 0 + }, + "h1_linha": { + "eq_hier_com_pin": 0.08692, + "eq_grosso_com_pin": 1.44193, + "eq_hier_sem_pin": 0.07905 + }, + "s42": { + "qe_inicial": 5.001, + "qe_media_6ep": 3.9475, + "qe_mediana_6ep": 5.001 + } + }, + "veredito": "29/29", + "ok": true +} \ No newline at end of file diff --git a/resultados/telemetria_v011.json b/resultados/telemetria_v011.json new file mode 100644 index 0000000000000000000000000000000000000000..caf23be37c68e884009918e49b3212accd8a409a --- /dev/null +++ b/resultados/telemetria_v011.json @@ -0,0 +1,111 @@ +{ + "versao": "0.11.0", + "estrutura": { + "n_modulos": 38, + "maior": { + "caminho": "src/lib.rs", + "kB": 138.7 + }, + "top5_kB": { + "src/lib.rs": 138.7, + "src/jepa.rs": 86.1, + "src/pensamento.rs": 70.6, + "src/som4d.rs": 67.0, + "src/moe_redirecionavel.rs": 56.3 + }, + "split_srp": "arquivado (arquivo_split_v100/ — débito documentado r-43)", + "modulos_novos_v011": [ + "src/asm.rs", + "src/raciocinio_elastico.rs", + "src/checkpoint.rs (restaurado)", + "src/tipos.rs (restaurado)" + ] + }, + "compilacao": { + "incremental_lib_rs_s": 25.7, + "ok": true + }, + "testes": { + "cargo_total": 160, + "cargo_deterministico": true, + "tempo_s": 33.1 + }, + "suite_v011": { + "veredito": "29/29", + "ok": true + }, + "checkpoints": { + "tokenizador_conceitos.json": { + "valido": false, + "manifesto": false + }, + "gerador_conceitos.json": { + "valido": false, + "manifesto": false + } + }, + "despacho": { + "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)", + "simd": "ver v0.9 (painel_v090 — kernels AVX-512 bit-a-bit)" + }, + "estados_de_treino": [ + "resultados/gerador_conceitos.json.estado.json", + "resultados/tokenizador_conceitos.json.estado.json", + "resultados/gerador_aritmetica.json.estado.json" + ], + "telemetria_real": { + "fase_a": { + "perda_inicial": 9.715057373046875, + "perda_final": 9.271934509277344, + "coerencia_welch_max": 7.414622160695217e-08, + "tc_intra_nivel_medio": 0.0 + }, + "fase_b": { + "perda_inicial": 4.246901341847011, + "perda_final": 3.9989989485059465 + }, + "moe_real": { + "perda_inicial": 0.02114950120449066, + "perda_final": 0.00036102166632190347, + "queda_pct": 98.29 + }, + "elastico_real": { + "origem": "reais", + "conf_media": 1.0, + "certificados": 8, + "rollbacks": 0, + "v2_linha": { + "cota_corrigida": 0.4, + "cota_limpa": 0.4, + "cota_limpa_respeitada": true, + "ece_aceito": 0.0, + "l1_global": 0.0, + "n_aceito": 120, + "p_aceite": 1.0, + "p_erro_aceito": 0.0, + "tau_c": 0.6 + } + }, + "veredito_real": "9/9" + }, + "tratamento_erros": { + "unwrap_expect_panic_em_producao": 109, + "por_modulo": { + "src/lib.rs": 57, + "src/jepa.rs": 2, + "src/fnh.rs": 1, + "src/simd.rs": 1, + "src/tokenizador.rs": 1, + "src/nlg.rs": 1, + "src/bin/bench_v090.rs": 29, + "src/amostrador.rs": 2, + "src/gerador.rs": 2, + "src/nlp.rs": 1, + "src/ponte.rs": 6, + "src/mascaras.rs": 4, + "src/camadas.rs": 1, + "src/perdas.rs": 1 + }, + "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" + } +} \ No newline at end of file diff --git a/resultados/treino_v100.json b/resultados/treino_v100.json new file mode 100644 index 0000000000000000000000000000000000000000..3cb78b0c1a2f0df7da277dd10f20f87d4eca05f7 --- /dev/null +++ b/resultados/treino_v100.json @@ -0,0 +1,251 @@ +{ + "versao": "0.10.0", + "dados": { + "sequencias": 1121, + "fonte": "wikimedia/wikipedia 20231101.pt" + }, + "fases": { + "a": { + "acc_recon": 0.158203125, + "coerencia_welch_max": 7.533882495636135e-08, + "delta_ort_max": 9.41514268205751e-07, + "escore_aprendizado": 0.3514674139957468, + "monotonia_prefixo": 0.8333333333333334, + "passos": 250, + "perda_final": 8.899502754211426, + "perda_inicial": 9.88571548461914, + "perplexidade_codebook": 49.18251125575817, + "tc_intra_nivel_medio": 0.0, + "tempo_s": 203.9 + }, + "b": { + "acc_conceitos": 0.013113839285714286, + "coerencia_welch_max": null, + "escore_aprendizado": 0.18339469025193836, + "passos": 400, + "perda_final": 4.015776293618338, + "perda_inicial": 4.203203133174351, + "tc_intra_nivel_medio": null, + "tempo_s": 201.9 + }, + "c": { + "acordos_medios": 0.46968567148303514, + "ce_final": 3.8938143253326416, + "ce_gatilhada_com_correcao": 4.013801554116335, + "ce_gatilhada_sem_correcao": 3.9862469174645168, + "ce_inicial": 3.904221909386771, + "confianca_media_final": 0.15108664333820343, + "confianca_media_inicial": 0.14182935655117035, + "confianca_pos_correcao": 0.13930911069566554, + "decaimento_delta": 0.9050641910008173, + "ece_antes": 0.025193523499183357, + "ece_depois": 0.057609438605140895, + "escore_aprendizado": 0.1875, + "maior_sobreposicao_us": 8, + "passos": 60, + "rodadas_acoplador": 55, + "tau_c": 0.023996472358703613, + "taxa_conflito_pcgrad": 0.0, + "taxa_gatilho": 0.625, + "temperatura_calibrada": 0.36286547501305927, + "timeouts_acoplador": 0, + "tempo_s": 109.4 + } + }, + "som_real": { + "media": { + "eq_ini": 0.22004171344653703, + "eq_fim": 0.2805910793281897, + "eqm_fim": 0.07936249586485472, + "te": 0.054, + "phi_monotono": true + }, + "mediana": { + "eq_ini": 0.22004171344653703, + "eq_fim": 0.22004171344653703, + "eqm_fim": 0.07226415350247549, + "te": 0.44, + "phi_monotono": true + } + }, + "hsom_real": { + "sem_reserva": { + "eq_hier": 0.0027989368310108926, + "eq_grosso": 0.07264646261965026, + "r_fino": 0.06984752578863937, + "c_observada": true + }, + "com_reserva": { + "eq_hier": 0.0040297286736116385, + "eq_grosso": 0.07264646261965026, + "r_fino": 0.06861673394603873, + "teorema_ok": true + }, + "cota_otima_sem": 0.28496048511933325 + }, + "jepa_modos_real": { + "dobradica": { + "media_queda_pct": 61.10047034418797, + "por_janela": [ + 74.7435812413127, + 74.78836000088069, + 52.52417665456309, + 42.34576347999541 + ] + }, + "raiz_suavizada": { + "media_queda_pct": 61.10045740384127, + "por_janela": [ + 74.74352173924332, + 74.7883637199964, + 52.52418067612995, + 42.34576347999541 + ] + }, + "softplus": { + "media_queda_pct": 60.708419132530885, + "por_janela": [ + 74.02832579784702, + 74.5809969848385, + 52.27764656298799, + 41.94670718445003 + ] + } + }, + "painel_v100": { + "ajustes_computados": 59, + "deteccoes": { + "acordo_tentativas": { + "inclinacao_theil_sen": 0.00013128299097944378, + "n_amostras": 55, + "polaridade": 1, + "r2": 0.0447115516932457, + "veredito_polarizado": "piorando" + }, + "ce_gatilhada_com": { + "inclinacao_theil_sen": -0.0022229651610056558, + "n_amostras": 55, + "polaridade": -1, + "r2": 0.022603039004906567, + "veredito_polarizado": "piorando" + }, + "ce_gatilhada_sem": { + "inclinacao_theil_sen": -0.002097100019454956, + "n_amostras": 55, + "polaridade": -1, + "r2": 0.023607765859403496, + "veredito_polarizado": "piorando" + }, + "confianca_media": { + "inclinacao_theil_sen": 2.0229948542850174e-05, + "n_amostras": 55, + "polaridade": 1, + "r2": 0.14801213048822426, + "veredito_polarizado": "piorando" + }, + "confianca_pos_correcao": { + "inclinacao_theil_sen": 0.00021375768951007297, + "n_amostras": 55, + "polaridade": 1, + "r2": 0.18385778668807162, + "veredito_polarizado": "piorando" + }, + "ece_calibracao": { + "inclinacao_theil_sen": 0.0, + "n_amostras": 1, + "polaridade": 1, + "r2": 0.0, + "veredito_polarizado": "amostra_insuficiente" + }, + "ece_pos_calibracao": { + "inclinacao_theil_sen": 0.0, + "n_amostras": 1, + "polaridade": 1, + "r2": 0.0, + "veredito_polarizado": "amostra_insuficiente" + }, + "escore_aprendizado": { + "inclinacao_theil_sen": 0.0031779661016949155, + "n_amostras": 4, + "polaridade": 1, + "r2": 0.69855405534808, + "veredito_polarizado": "piorando" + }, + "lr": { + "inclinacao_theil_sen": 0.0, + "n_amostras": 60, + "polaridade": 1, + "r2": 0.0, + "veredito_polarizado": "estagnado" + }, + "norma_delta": { + "inclinacao_theil_sen": -0.004560884659055644, + "n_amostras": 55, + "polaridade": 1, + "r2": 0.6655823745576321, + "veredito_polarizado": "aprendendo" + }, + "norma_grad": { + "inclinacao_theil_sen": -0.0009406904053285296, + "n_amostras": 60, + "polaridade": -1, + "r2": -0.05227700522904288, + "veredito_polarizado": "piorando" + }, + "perda": { + "inclinacao_theil_sen": -0.0009818642826403602, + "n_amostras": 60, + "polaridade": -1, + "r2": 0.021705938792401458, + "veredito_polarizado": "piorando" + }, + "taxa_gatilho": { + "inclinacao_theil_sen": 0.0, + "n_amostras": 60, + "polaridade": 1, + "r2": -0.17241379310344818, + "veredito_polarizado": "estagnado" + }, + "temperatura_calibrada": { + "inclinacao_theil_sen": 0.0, + "n_amostras": 1, + "polaridade": 1, + "r2": 0.0, + "veredito_polarizado": "amostra_insuficiente" + } + }, + "erros_registrados": 0, + "escore_aprendizado": 0.1875, + "fnh": { + "delta_ort_rotacao": null, + "gate_ultimo": null, + "punicao_ema": null, + "theta_norma": null + }, + "nlp_nlg": { + "espec_aceitacao": null, + "espec_speedup": null, + "nlg_coerencia": null, + "nlp_gate_medio": null + }, + "quebra_cabeca": { + "confianca_base": null, + "confianca_melhor": null, + "punicao_acumulada": null, + "taxa_aceitacao": null + }, + "resumo_direcoes": { + "aprendendo": 1, + "estagnado": 5, + "piorando": 8 + }, + "simd": { + "avx512_disponivel": true, + "chamadas_avx": 14250, + "chamadas_escalar": 0 + }, + "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", + "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", + "versao": "0.7.0" + } +} \ No newline at end of file diff --git a/scripts/74_treino_v100.py b/scripts/74_treino_v100.py new file mode 100644 index 0000000000000000000000000000000000000000..9974dd76e1bd6b4163dd7cf679a0c31525095039 --- /dev/null +++ b/scripts/74_treino_v100.py @@ -0,0 +1,148 @@ +#!/usr/bin/env python3 +"""74_treino_v100.py — AVALIAÇÃO COM DADOS REAIS dos mecanismos v0.10.0 +(análise/prova/teste das críticas DeepSeek — r-35). + +Pipeline (dados: Wikipédia PT-BR, wikimedia/wikipedia 20231101.pt): + 1. Fases A/B/C CURTAS — a fase A agora reporta coerência de Welch + (A.1′) e TC intra-nível plug-in Miller–Madow (B.1) nos codebooks + TREINADOS EM DADOS REAIS (linha de base da alavanca B-1T); + 2. SOM em latentes reais: A/B média vs mediana de Weiszfeld + (S4-1′-c) — QE e EQM reportadas nos dois critérios + Φ monotona; + 3. H-SOM em latentes reais: com e sem reservar_grosso (H-1′-c); + 4. JEPA em latentes reais: A/B dos 3 modos de variância (J-1′). +""" +import json, os, sys, time + +import numpy as np + + +def main(): + pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + sys.path.insert(0, pasta) + os.makedirs(os.path.join(pasta, "resultados"), exist_ok=True) + import khtst_rust as K + + cfg = K.Config(os.path.join(pasta, "configs", "base_rust.json")) + ck_tok = os.path.join(pasta, "resultados", "tokenizador_conceitos.json") + ck_ger = os.path.join(pasta, "resultados", "gerador_conceitos.json") + tel_c = os.path.join(pasta, "resultados", "telemetria_fase_c.jsonl") + + bpe = K.Bpe.carregar(os.path.join(pasta, "dados", "bpe.json")) + seqs = [] + with open(os.path.join(pasta, "dados", "shard_treino.jsonl")) as f: + for linha in f: + ids = bpe.codificar(json.loads(linha)["texto"]) + for i in range(0, max(1, len(ids) - 256), 128): + seqs.append(ids[i:i + 256]) + seqs = seqs[:1400] + PAD = 0 + largura = max(len(s) for s in seqs) + seqs_np = np.array( + [s + [PAD] * (largura - len(s)) for s in seqs], dtype=np.uint32 + ) + rel = { + "versao": "0.10.0", + "dados": {"sequencias": len(seqs), "fonte": "wikimedia/wikipedia 20231101.pt"}, + "fases": {}, + } + print(f"sequências: {len(seqs)} (ctx=256) | numpy {seqs_np.shape}", flush=True) + + # -------------------------------- fase A (numpy) — v100: coerença+TC + apagar = [ck_tok, ck_ger, tel_c] + for c in apagar: + if os.path.exists(c): + os.remove(c) + print(f"estado anterior apagado: {c}", flush=True) + print("=== FASE A — tokenizador (entrada NUMPY; μ-Welch + TC no resumo) ===", flush=True) + t0 = time.time() + saida = K.treinar_fase_a_np(cfg, seqs_np, None, ck_tok, None, 200.0) + rel["fases"]["a"] = {**saida["resumo"], "tempo_s": round(time.time() - t0, 1)} + print(json.dumps(rel["fases"]["a"], indent=1, ensure_ascii=False), flush=True) + + # -------------------------------- fase B (numpy) + print("=== FASE B — gerador (entrada NUMPY) ===", flush=True) + t0 = time.time() + saida_b = K.treinar_fase_b_np(cfg, seqs_np, ck_tok, None, ck_ger, teto_seg=200.0) + rel["fases"]["b"] = {**saida_b["resumo"], "tempo_s": round(time.time() - t0, 1)} + print(json.dumps(rel["fases"]["b"], indent=1, ensure_ascii=False), flush=True) + + # -------------------------------- fase C (curta) + print("=== FASE C — conjunto (60 passos) ===", flush=True) + t0 = time.time() + saida_c = K.treinar_fase_c(cfg, seqs, ck_tok, passos=60, caminho_gerador=ck_ger, + caminho_telemetria=tel_c, teto_seg=120.0) + rc = saida_c["resumo"] + rc["tempo_s"] = round(time.time() - t0, 1) + rel["fases"]["c"] = rc + chaves = [k for k in list(rc)[:10]] + print(json.dumps({k: rc[k] for k in chaves}, indent=1, ensure_ascii=False), flush=True) + + # -------------------------------- latentes reais + print("=== LATENTES REAIS (tokenizador treinado) ===", flush=True) + lat = K.codificar_latentes(cfg, ck_tok, seqs_np[:64]) + print(f"latentes: {lat.shape} {lat.dtype}", flush=True) + + # -------------------------------- SOM real: média vs mediana (S4-1′) + print("=== SOM REAL — média vs mediana de Weiszfeld (S4-1′) ===", flush=True) + nuvem = lat.reshape(-1, lat.shape[-1]) + sel = np.random.default_rng(5).choice(len(nuvem), 1500, replace=False) + nuvem_list = [list(map(float, v)) for v in nuvem[sel]] + base = json.dumps({"nx": 4, "ny": 3, "nz": 2, "nt": 2, "epocas": 12, + "sigma0": 2.0, "sigma1": 0.5, "semente": 42}) + som_med = K.treinar_som4d(nuvem_list, base) + som_mediana = K.treinar_som4d(nuvem_list, json.dumps({ + **json.loads(base), "criterio_lote": "mediana_geometrica", + "weiszfeld_iters": 8})) + rel["som_real"] = { + "media": {"eq_ini": som_med["eq_inicial"], "eq_fim": som_med["eq_final"], + "eqm_fim": som_med["eqm_final"], "te": som_med["te_final"], + "phi_monotono": som_med["phi_monotono"]}, + "mediana": {"eq_ini": som_mediana["eq_inicial"], "eq_fim": som_mediana["eq_final"], + "eqm_fim": som_mediana["eqm_final"], "te": som_mediana["te_final"], + "phi_monotono": som_mediana["phi_monotono"]}, + } + print(json.dumps(rel["som_real"], indent=1, ensure_ascii=False), flush=True) + + # -------------------------------- H-SOM real: com/sem reserva (H-1′-c) + print("=== H-SOM REAL — reservar_grosso (H-1′-c) ===", flush=True) + hs_sem = K.treinar_hsom(nuvem_list[:800]) + hs_com = K.treinar_hsom(nuvem_list[:800], json.dumps({"reservar_grosso": True})) + rel["hsom_real"] = { + "sem_reserva": {"eq_hier": hs_sem["eq_hierarquico"], "eq_grosso": hs_sem["eq_grosso"], + "r_fino": hs_sem["r_fino"], + "c_observada": hs_sem["eq_hierarquico"] <= hs_sem["eq_grosso"]}, + "com_reserva": {"eq_hier": hs_com["eq_hierarquico"], "eq_grosso": hs_com["eq_grosso"], + "r_fino": hs_com["r_fino"], + "teorema_ok": hs_com["eq_hierarquico"] <= hs_com["eq_grosso"]}, + "cota_otima_sem": (hs_sem["eq_grosso"] ** 0.5 + hs_sem["r_fino"] ** 0.5) ** 2, + } + print(json.dumps(rel["hsom_real"], indent=1, ensure_ascii=False), flush=True) + + # -------------------------------- JEPA real: 3 modos de variância (J-1′) + print("=== JEPA REAL — modos de variância (J-1′) ===", flush=True) + resultados_modo = {} + for modo in ["dobradica", "raiz_suavizada", "softplus"]: + cfg_j = json.dumps({"epocas": 40, "d_emb": 48, "semente": 42, "lr": 2e-3, + "modo_variancia": modo}) + quedas = [] + for w in range(4): + janela = lat[w].astype(float).tolist() + r = K.treinar_jepa(janela, [256], "tjepa", cfg_j) + quedas.append(r["queda_pct"]) + resultados_modo[modo] = { + "media_queda_pct": sum(quedas) / len(quedas), + "por_janela": quedas, + } + print(f" {modo}: queda média {resultados_modo[modo]['media_queda_pct']:.1f}%", flush=True) + rel["jepa_modos_real"] = resultados_modo + + # -------------------------------- painel v100 (via fase C) + rel["painel_v100"] = saida_c.get("painel_v100") + + with open(os.path.join(pasta, "resultados", "treino_v100.json"), "w") as f: + json.dump(rel, f, indent=1, ensure_ascii=False) + print("salvo: resultados/treino_v100.json", flush=True) + + +if __name__ == "__main__": + main() diff --git a/scripts/79_suite_v011.py b/scripts/79_suite_v011.py new file mode 100644 index 0000000000000000000000000000000000000000..1fd6aead2eba03e6be752f621ed2ab6205555504 --- /dev/null +++ b/scripts/79_suite_v011.py @@ -0,0 +1,230 @@ +#!/usr/bin/env python3 +"""79_suite_v011.py — v0.11.0: VEREDITO CONSOLIDADO (provas r-36..r-42 + +tratamento.txt Rust+Assembly + restauração da funcionalidade v0.10.0). + +Gates: + v1 versão 0.11.0 + módulos novos registrados (asm, raciocinio_elastico, + checkpoint, tipos) e bindings (asm_relatorio, v2_relatorio_soundness, + checkpoint_*, sha256_arquivo, demo_raciocinio_elastico); + v2 tratamento.txt (Assembly): relatório dos 3 kernels por flags + (CF/PF/ZF); testes cargo asm::* verdes; sha256_arquivo == hashlib + (oráculo independente); checkpoint atômico roundtrip + (salvar → validar → carregar verificado) + detecção de corrupção; + v3 M-R5′: teste cargo m_r5_guloso_vs_forca_bruta verde (guloso == + força bruta; contraexemplo r-41 com constante corrigida 31,794); + v4 V-2′: relatório de soundness condicional — cota limpa respeitada, + p_aceite > 0, ece_aceito ≤ 1, cotas finitas; contraexemplo do ECE + global reproduzido do Python (a cota antiga É violável); + v5 raciocínio elástico (RE-1..RE-8): demo com gates todos true, + certificados presentes, ε_safe ≥ 0, terminação ≤ B_max; + v6 H-1′ pin slot: treinar_hsom com reservar_grosso=true ⇒ EQ_hier ≤ + EQ_grosso EXATO (teorema) — e sem pin mantém a cota (√QE+√R)²; + v7 Weiszfeld: treinar_som4d criterio_lote=mediana_geometrica executa e + QE não-crescente no contraexemplo {0,10} (S4-2); + v8 preservação v0.10.0: cargo 158/158 (tipos T-V*, checkpoint CP-*); + SRP split ARQUIVADO com justificativa (arquivo_split_v100/LEIA-ME) — + funcionalidade preservada, estrutura registrada como débito. +Saída: resultados/suite_v011_final.json +""" +import hashlib +import json +import os +import re +import subprocess +import sys +import tempfile + +PASTA = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +R = os.path.join(PASTA, "resultados") + + +def main(): + rel = {"versao": "0.11.0", "blocos": {}, "gates": {}, "medicoes": {}} + + sys.path.insert(0, os.path.join(PASTA, "python")) + import khtst_rust.nucleo_rust as nr + + # ---- v1: versão e módulos + rel["gates"]["v1_versao_0110"] = nr.versao() == "khtst-rust-0.11.0" + asm_rep = nr.asm_relatorio() + rel["medicoes"]["asm_relatorio"] = asm_rep + rel["gates"]["v1_kernels_asm_registrados"] = all( + k in asm_rep for k in ("soma_u64_cheia", "primeiro_nan_f64", "primeiro_nan_f32", "CF", "PF") + ) + rel["gates"]["v1_binding_v2_soundness"] = hasattr(nr, "v2_relatorio_soundness") + rel["gates"]["v1_binding_elastico"] = hasattr(nr, "demo_raciocinio_elastico") + + # ---- v2: tratamento.txt (Assembly + Result) — oráculos independentes + # (a) SHA-256 puro Rust vs hashlib (FIPS 180-4 — dois oráculos) + with tempfile.NamedTemporaryFile(delete=False, suffix=".bin") as f: + f.write(os.urandom(4096)) + caminho_bin = f.name + h_rust = nr.sha256_arquivo(caminho_bin) + h_py = hashlib.sha256(open(caminho_bin, "rb").read()).hexdigest() + rel["gates"]["v2_sha256_confere_hashlib"] = h_rust == h_py + os.unlink(caminho_bin) + + # (b) checkpoint atômico: salvar → validar → carregar verificado + # (usa o próprio TokenizadorBPE pyclass, que salva via salvar_atomico) + with tempfile.TemporaryDirectory() as td: + ckpt = os.path.join(td, "tok.json") + bpe = nr.Bpe.treinar(["o rastro de provas em rust e assembly " * 20], 220) + bpe.salvar(ckpt) + manifestou = nr.checkpoint_manifesto(ckpt) + rel["gates"]["v2_checkpoint_manifesto_presente"] = manifestou is not None + rel["gates"]["v2_checkpoint_valido"] = nr.checkpoint_valido(ckpt) is True + # detecção de corrupção: alterar 1 byte ⇒ manifesto INVALIDA + dados = bytearray(open(ckpt, "rb").read()) + dados[len(dados) // 2] ^= 0x01 + with open(ckpt, "wb") as f: + f.write(dados) + rel["gates"]["v2_checkpoint_corrupcao_detectada"] = nr.checkpoint_valido(ckpt) is False + # retrocompatibilidade LEGADO: arquivo são SEM manifesto (pré-v0.10) + # continua carregando (leitura simples, com aviso no log) + bpe.salvar(ckpt) # regrava são + os.unlink(ckpt + ".manifest.json") # simula checkpoint pré-v0.10 + bpe2 = nr.Bpe.carregar(ckpt) + rel["gates"]["v2_carregar_retrocompativel"] = bpe2.n_vocab > 0 + + # ---- cargo (v3/v8): contagem total + testes-chave por nome + env = dict(os.environ) + env["PATH"] = os.path.expanduser("~/.cargo/bin") + os.pathsep + env.get("PATH", "") + r = subprocess.run( + ["cargo", "test", "--release"], capture_output=True, text=True, cwd=PASTA, env=env + ) + totais = [int(x) for x in re.findall(r"test result: ok\. (\d+) passed", r.stdout)] + total = sum(totais) + rel["medicoes"]["cargo_total"] = total + nomes = re.findall(r"^test (\S+) \.\.\. ok", r.stdout, re.M) + chave = [ + "asm::testes::soma_estoura_na_segunda_parcela", + "asm::testes::nan_f64_localizado", + "moe_redirecionavel::testes::m_r5_guloso_vs_forca_bruta", + "raciocinio_elastico::testes::re8_determinismo", + "raciocinio_elastico::testes::re2d_ciclo_com_compressao", + "verificador::testes::v2_linha_cota_condicional_corrigida", + ] + faltando = [c for c in chave if c not in nomes] + rel["medicoes"]["testes_chave_faltando"] = faltando + rel["gates"]["v3_mr5_guloso_vs_bruto"] = not faltando and r.returncode == 0 + rel["gates"]["v8_cargo_158_mais"] = total >= 158 and r.returncode == 0 + + # ---- v4: V-2′ soundness condicional (simulação superconfiante) + import random + + random.seed(11) + confs = [min(0.999, max(0.001, random.betavariate(2, 3) + 0.25)) for _ in range(6000)] + corretos = [random.random() <= c * 0.82 for c in confs] # superconfiante + s = nr.v2_relatorio_soundness(confs, corretos, 15, 0.70) + rel["medicoes"]["v2_linha"] = {k: (round(v, 4) if isinstance(v, float) else v) for k, v in s.items()} + rel["gates"]["v4_cota_limpa_respeitada"] = s["cota_limpa_respeitada"] is True + rel["gates"]["v4_p_aceite_positiva"] = 0.0 < s["p_aceite"] <= 1.0 + rel["gates"]["v4_cotas_finitas"] = ( + s["cota_limpa"] < 10.0 and s["cota_corrigida"] < 50.0 and s["ece_aceito"] <= 1.0 + ) + # contraexemplo da errata: ECE GLOBAL pode violar a cota antiga + random.seed(77) + cg, og = [], [] + for i in range(20000): + if i % 10 == 0: + cg.append(0.95) + og.append(random.random() < 0.80) + else: + cg.append(0.50) + og.append(random.random() < 0.50) + # ECE global 10 faixas via relatório no domínio total (tau=0) + s0 = nr.v2_relatorio_soundness(cg, og, 10, 0.0) + n_a = sum(1 for c in cg if c >= 0.9) + e_a = sum(1 for c, o in zip(cg, og) if c >= 0.9 and not o) + p_erro_a = e_a / n_a + cota_antiga = 1.0 - 0.9 + s0["ece_aceito"] # tau=0: ece_aceito == ECE global + rel["medicoes"]["v2_errata"] = { + "p_erro_aceito": round(p_erro_a, 4), + "cota_antiga_ece_global": round(cota_antiga, 4), + } + rel["gates"]["v4_errata_ece_global_e_violavel"] = p_erro_a > cota_antiga + s9 = nr.v2_relatorio_soundness(cg, og, 10, 0.9) + rel["gates"]["v4_errata_cota_limpa_cobre"] = s9["cota_limpa_respeitada"] is True + + # ---- v5: raciocínio elástico (RE-1..RE-8) + e = nr.demo_raciocinio_elastico(8, 6, 3, 120, 0.30, 6, 42) + rel["medicoes"]["elastico"] = { + "confianca_media": round(e["confianca_media"], 4), + "iteracoes_media": round(e["iteracoes_media"], 2), + "certificados": len(e["certificados"]), + "rollbacks": e["rollbacks"], + } + rel["gates"]["v5_gates_elasticos"] = all(e["gates"].values()) + rel["gates"]["v5_certificados_presentes"] = len(e["certificados"]) >= 1 + rel["gates"]["v5_epsilon_seguro_nao_negativo"] = all( + (c["epsilon_safe"] is None) or (c["epsilon_safe"] >= 0.0) for c in e["certificados"] + ) + + # ---- v6: H-1′ pin slot (reservar_grosso) — teorema EQ_hier ≤ EQ_grosso + random.seed(5) + dados = [[random.gauss(0, 1), random.gauss(0, 1), random.gauss(0, 2), random.gauss(0, 0.5)] + for _ in range(300)] + h_pin = nr.treinar_hsom(dados, json.dumps({"reservar_grosso": True})) + h_std = nr.treinar_hsom(dados, json.dumps({"reservar_grosso": False})) + rel["medicoes"]["h1_linha"] = { + "eq_hier_com_pin": round(h_pin["eq_hierarquico"], 5), + "eq_grosso_com_pin": round(h_pin["eq_grosso"], 5), + "eq_hier_sem_pin": round(h_std["eq_hierarquico"], 5), + } + rel["gates"]["v6_pin_eq_hier_le_eq_grosso_exato"] = ( + h_pin["eq_hierarquico"] <= h_pin["eq_grosso"] + 1e-12 + ) + # cota (√QE+√R)² SEMPRE válida (com e sem pin) + import math + + for h, nome in ((h_pin, "pin"), (h_std, "sem_pin")): + cota = (math.sqrt(h["eq_grosso"]) + math.sqrt(h["r_fino"])) ** 2 + rel["gates"][f"v6_cota_minkowski_{nome}"] = h["eq_hierarquico"] <= cota + 1e-9 + + # ---- v7: Weiszfeld (mediana geométrica) no contraexemplo S4-2 + dados_ce = [[0.0, 0.1], [10.0, -0.1]] * 8 # 2 clusters {0,10} + antes = nr.treinar_som4d(dados_ce, json.dumps({"nx": 2, "ny": 1, "nz": 1, "nt": 1, + "epocas": 1, "criterio_lote": "media", + "criterio_qe": "distancia"})) + depois = nr.treinar_som4d(dados_ce, json.dumps({"nx": 2, "ny": 1, "nz": 1, "nt": 1, + "epocas": 6, "criterio_lote": "media", + "criterio_qe": "distancia"})) + med = nr.treinar_som4d(dados_ce, json.dumps({"nx": 2, "ny": 1, "nz": 1, "nt": 1, + "epocas": 6, "criterio_lote": "mediana_geometrica", + "criterio_qe": "distancia"})) + rel["medicoes"]["s42"] = { + "qe_inicial": round(antes["eq_final"], 4), + "qe_media_6ep": round(depois["eq_final"], 4), + "qe_mediana_6ep": round(med["eq_final"], 4), + } + # com média a QE pode subir no regime σ grande (contraexemplo); + # com mediana de Weiszfeld a QE NÃO sobe em relação ao inicial + rel["gates"]["v7_mediana_nao_piora_contraexemplo"] = med["eq_final"] <= antes["eq_final"] + 1e-9 + rel["gates"]["v7_phi_monotono_media"] = depois["phi_monotono"] is True + rel["gates"]["v7_phi_monotono_mediana"] = med["phi_monotono"] is True + + # ---- v8: preservação v0.10 + arquivo do split SRP + leia = os.path.join(PASTA, "arquivo_split_v100", "LEIA-ME.md") + rel["gates"]["v8_split_arquivado_documentado"] = os.path.exists(leia) + for m in ("checkpoint", "tipos"): + rel["gates"][f"v8_modulo_{m}_presente"] = os.path.exists(os.path.join(PASTA, "src", f"{m}.rs")) + # determinismo: 2ª rodada de cargo idêntica + r2 = subprocess.run( + ["cargo", "test", "--release"], capture_output=True, text=True, cwd=PASTA, env=env + ) + totais2 = sum(int(x) for x in re.findall(r"test result: ok\. (\d+) passed", r2.stdout)) + rel["gates"]["v8_cargo_deterministico"] = totais2 == total and r2.returncode == 0 + + # ---- veredito + ok = sum(1 for v in rel["gates"].values() if v is True) + rel["veredito"] = f"{ok}/{len(rel['gates'])}" + rel["ok"] = ok == len(rel["gates"]) + with open(os.path.join(R, "suite_v011_final.json"), "w") as f: + json.dump(rel, f, indent=1, ensure_ascii=False) + print(json.dumps({"veredito": rel["veredito"], "ok": rel["ok"], + "medicoes": rel["medicoes"]}, indent=1, ensure_ascii=False)) + return 0 if rel["ok"] else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/80_avaliacao_real_v011.py b/scripts/80_avaliacao_real_v011.py new file mode 100644 index 0000000000000000000000000000000000000000..ee50a49895a9905d5ea1a0af5c7ed23ef6422be5 --- /dev/null +++ b/scripts/80_avaliacao_real_v011.py @@ -0,0 +1,166 @@ +#!/usr/bin/env python3 +"""80_avaliacao_real_v011.py — AVALIAÇÃO COM DADOS REAIS (Wikipédia PT-BR) +dos mecanismos v0.11.0 (r-36..r-42 completados + tratamento.txt). + +Diferencial da v0.11 sobre a avaliação v0.10 (script 74): + R1 raciocínio ELÁSTICO em latentes reais (r-42): cond = latente[j], + alvo = latente[j+1] (predição de próximo vetor) — motor + cabeça + verificadora treinados nos pares REAIS; certificados RE-2 auditados; + R2 V-2′ (r-40) nos pares de calibração REAIS: relatório de soundness + condicional (ece_aceito, p_aceite, cotas limpa/corrigida); + R3 M-R5′ (r-41): JEPA+MoE em latentes reais (o alocador guloso ótimo + agora guia a realocação de capacidade dentro do treino real); + R4 S4-2/H-1′ (r-36): SOM média vs mediana de Weiszfeld e H-SOM com/ + sem reservar_grosso em latentes reais (regressão v0.10 preservada); + R5 estados anteriores APAGADOS antes do treino (requisito do usuário); + R6 telemetria painel v0.11 (asm + elástico) registrada. +Saída: resultados/avaliacao_real_v011.json +""" +import json +import os +import sys +import time + +import numpy as np + + +def main(): + pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + sys.path.insert(0, pasta) + os.makedirs(os.path.join(pasta, "resultados"), exist_ok=True) + import khtst_rust as K + import khtst_rust.nucleo_rust as nr + + cfg = K.Config(os.path.join(pasta, "configs", "base_rust.json")) + ck_tok = os.path.join(pasta, "resultados", "tokenizador_conceitos.json") + ck_ger = os.path.join(pasta, "resultados", "gerador_conceitos.json") + + # ---- R5: apagar estados de treino anteriores (procura antes) + apagados = [] + for c in [ck_tok, ck_ger, + ck_tok + ".manifest.json", ck_ger + ".manifest.json", + os.path.join(pasta, "resultados", "telemetria_fase_c.jsonl")]: + if os.path.exists(c): + os.remove(c) + apagados.append(os.path.basename(c)) + print(f"estados anteriores apagados: {apagados or 'nenhum'}", flush=True) + + # ---- dados reais (shards coletados pelo 70) + bpe = K.Bpe.carregar(os.path.join(pasta, "dados", "bpe.json")) + seqs = [] + with open(os.path.join(pasta, "dados", "shard_treino.jsonl")) as f: + for linha in f: + ids = bpe.codificar(json.loads(linha)["texto"]) + for i in range(0, max(1, len(ids) - 256), 128): + seqs.append(ids[i:i + 256]) + seqs = seqs[:1400] + PAD = 0 + largura = max(len(s) for s in seqs) + seqs_np = np.array([s + [PAD] * (largura - len(s)) for s in seqs], dtype=np.uint32) + rel = { + "versao": "0.11.0", + "dados": {"sequencias": len(seqs), "fonte": "wikimedia/wikipedia 20231101.pt"}, + "estados_apagados": apagados, + } + print(f"sequências: {len(seqs)} (ctx=256) | numpy {seqs_np.shape}", flush=True) + + # ---- fases A/B (cortas — latentes + gerador reais) + print("=== FASE A — tokenizador (numpy) ===", flush=True) + t0 = time.time() + saida_a = K.treinar_fase_a_np(cfg, seqs_np, None, ck_tok, None, 200.0) + rel["fase_a"] = {**saida_a["resumo"], "tempo_s": round(time.time() - t0, 1)} + print(json.dumps(rel["fase_a"], indent=1, ensure_ascii=False)[:600], flush=True) + + print("=== FASE B — gerador (numpy) ===", flush=True) + t0 = time.time() + saida_b = K.treinar_fase_b_np(cfg, seqs_np, ck_tok, None, ck_ger, teto_seg=200.0) + rel["fase_b"] = {**saida_b["resumo"], "tempo_s": round(time.time() - t0, 1)} + print(json.dumps(rel["fase_b"], indent=1, ensure_ascii=False)[:600], flush=True) + + # ---- latentes reais + lat = K.codificar_latentes(cfg, ck_tok, seqs_np[:64]) + nuvem = np.asarray(lat).reshape(-1, np.asarray(lat).shape[-1]) + print(f"latentes reais: {nuvem.shape}", flush=True) + rng = np.random.default_rng(5) + sel = rng.choice(len(nuvem), 1500, replace=False) + nuvem_list = [list(map(float, v)) for v in nuvem[sel]] + rel["latentes"] = {"shape": list(nuvem.shape)} + + # ---- R4: SOM média vs mediana (S4-2) + H-SOM pin (H-1′) — regressão v0.10 + base = json.dumps({"nx": 4, "ny": 3, "nz": 2, "nt": 2, "epocas": 12, + "sigma0": 2.0, "sigma1": 0.5, "semente": 42}) + som_med = K.treinar_som4d(nuvem_list, base) + som_mediana = K.treinar_som4d(nuvem_list, json.dumps( + {**json.loads(base), "criterio_lote": "mediana_geometrica", "weiszfeld_iters": 8})) + hs_sem = K.treinar_hsom(nuvem_list[:800]) + hs_com = K.treinar_hsom(nuvem_list[:800], json.dumps({"reservar_grosso": True})) + rel["som_real"] = { + "media": {"eq_fim": som_med["eq_final"], "eqm_fim": som_med["eqm_final"], + "te": som_med["te_final"], "phi_mono": som_med["phi_monotono"]}, + "mediana": {"eq_fim": som_mediana["eq_final"], "eqm_fim": som_mediana["eqm_final"], + "te": som_mediana["te_final"], "phi_mono": som_mediana["phi_monotono"]}, + "hsom_sem_pin": {"eq_hier": hs_sem["eq_hierarquico"], "eq_grosso": hs_sem["eq_grosso"]}, + "hsom_com_pin": {"eq_hier": hs_com["eq_hierarquico"], "eq_grosso": hs_com["eq_grosso"]}, + } + print(json.dumps(rel["som_real"], indent=1, ensure_ascii=False), flush=True) + + # ---- R3: MoE-JEPA em latentes reais (guloso M-R5′ no treino) + print("=== MoE-JEPA REAL (alocador guloso M-R5′ integrado) ===", flush=True) + moe = K.jepa_com_moe(nuvem_list[:600], "moe", 40, 0.5, 42) + rel["moe_real"] = { + "perda_inicial": moe["perda_pred_inicial"], "perda_final": moe["perda_pred_final"], + "queda_pct": round(100.0 * (1.0 - moe["perda_pred_final"] / max(moe["perda_pred_inicial"], 1e-12)), 2), + } + print(json.dumps(rel["moe_real"], indent=1, ensure_ascii=False), flush=True) + + # ---- R1+R2: raciocínio elástico em latentes REAIS + V-2′ + print("=== ELÁSTICO REAL (r-42) + V-2′ (r-40) ===", flush=True) + # pares reais: cond = latente j, alvo = latente j+1 (predição próximo vetor) + pares = min(240, len(nuvem) - 1) + conds_r = [list(map(float, nuvem[j])) for j in range(pares)] + alvos_r = [list(map(float, nuvem[j + 1])) for j in range(pares)] + t0 = time.time() + el = nr.demo_raciocinio_elastico( + len(conds_r[0]), len(alvos_r[0]), 3, 90, 0.30, 6, 42, conds_r, alvos_r) + confs, corretos = el["confs_calibracao"], el["corretos_calibracao"] + tau = 0.60 + s2 = nr.v2_relatorio_soundness(confs, corretos, 10, tau) + rel["elastico_real"] = { + "origem": el["origem_dados"], + "d_cond": len(conds_r[0]), "d_saida": len(alvos_r[0]), + "conf_media": round(el["confianca_media"], 4), + "iteracoes_media": round(el["iteracoes_media"], 2), + "certificados": len(el["certificados"]), + "rollbacks": el["rollbacks"], + "tempo_s": round(time.time() - t0, 1), + "v2_linha": {k: (round(v, 4) if isinstance(v, float) else v) for k, v in s2.items()}, + "gates_demo": el["gates"], + } + print(json.dumps(rel["elastico_real"], indent=1, ensure_ascii=False), flush=True) + + # ---- R6: telemetria v0.11 (asm + relatório do módulo) + rel["asm"] = nr.asm_relatorio() + + # ---- gates de avaliação real + g = {} + g["fase_a_treinou"] = rel["fase_a"].get("perda_final", 1) < rel["fase_a"].get("perda_inicial", 0) + g["fase_b_treinou"] = rel["fase_b"].get("perda_final", 1) < rel["fase_b"].get("perda_inicial", 0) + g["som_phi_monotono_ambos"] = som_med["phi_monotono"] and som_mediana["phi_monotono"] + g["hsom_pin_teorema_real"] = hs_com["eq_hierarquico"] <= hs_com["eq_grosso"] + 1e-12 + g["moe_real_aprendeu"] = rel["moe_real"]["perda_final"] < rel["moe_real"]["perda_inicial"] + g["elastico_origem_reais"] = el["origem_dados"] == "reais" + g["elastico_certificados_presentes"] = len(el["certificados"]) >= 1 + g["v2_cota_limpa_real_respeitada"] = s2["cota_limpa_respeitada"] is True + g["v2_p_aceite_real_positiva"] = 0.0 < s2["p_aceite"] <= 1.0 + ok = sum(1 for v in g.values() if v is True) + rel["avaliacao_real_gates"] = g + rel["veredito_real"] = f"{ok}/{len(g)}" + + with open(os.path.join(pasta, "resultados", "avaliacao_real_v011.json"), "w") as f: + json.dump(rel, f, indent=1, ensure_ascii=False) + print(f"VEREDITO REAL: {rel['veredito_real']}", flush=True) + return 0 if ok == len(g) else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/81_telemetria_v011.py b/scripts/81_telemetria_v011.py new file mode 100644 index 0000000000000000000000000000000000000000..de2dca9174fb1837ebcd5f267bcb307a566a5013 --- /dev/null +++ b/scripts/81_telemetria_v011.py @@ -0,0 +1,147 @@ +#!/usr/bin/env python3 +"""81_telemetria_v011.py — TELEMETRIA DE TODO O PROJETO (v0.11.0). + +Coleta (todas as informações acessíveis): + T1 estrutura: inventário de módulos (canon plano + arquivo do split SRP); + T2 compilação: tempos frio (target limpo parcial) e incremental por toque; + T3 testes: contagem cargo (determinismo 2×) e gates da suíte 79; + T4 integridade: checkpoints com manifesto SHA-256 válidos; + T5 despacho: relatório dos kernels SIMD (v0.9) e ASM (v0.11); + T6 estados: varredura de estados de treino (deve listar e apagar depois); + T7 telemetria real: séries da avaliação 80 (perdas A/B, MoE, elástico); + T8 unwrap de produção: contagem de unwrap/expect/panic fora de testes + (tratamento.txt §1 — métrica de dívida). +Saída: resultados/telemetria_v011.json +""" +import json +import os +import re +import subprocess +import time + +PASTA = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +R = os.path.join(PASTA, "resultados") + + +def run(cmd, env=None, **kw): + return subprocess.run(cmd, capture_output=True, text=True, cwd=PASTA, env=env, **kw) + + +def main(): + env = dict(os.environ) + env["PATH"] = os.path.expanduser("~/.cargo/bin") + os.pathsep + env.get("PATH", "") + rel = {"versao": "0.11.0"} + + # ---- T1: estrutura + arquivos = [] + for raiz, _, nfs in os.walk(os.path.join(PASTA, "src")): + for n in nfs: + if n.endswith(".rs"): + p = os.path.join(raiz, n) + arquivos.append((os.path.relpath(p, PASTA), os.path.getsize(p))) + arquivos.sort(key=lambda x: -x[1]) + rel["estrutura"] = { + "n_modulos": len(arquivos), + "maior": {"caminho": arquivos[0][0], "kB": round(arquivos[0][1] / 1e3, 1)}, + "top5_kB": {a: round(b / 1e3, 1) for a, b in arquivos[:5]}, + "split_srp": "arquivado (arquivo_split_v100/ — débito documentado r-43)", + "modulos_novos_v011": ["src/asm.rs", "src/raciocinio_elastico.rs", + "src/checkpoint.rs (restaurado)", "src/tipos.rs (restaurado)"], + } + + # ---- T2: compilação incremental (toque em lib.rs) + total de testes + t0 = time.time() + r1 = run(["cargo", "build", "--release"], env=env) + rel["compilacao"] = { + "incremental_lib_rs_s": round(time.time() - t0, 1), + "ok": r1.returncode == 0, + } + t0 = time.time() + rt = run(["cargo", "test", "--release"], env=env) + tot1 = sum(int(x) for x in re.findall(r"test result: ok\. (\d+) passed", rt.stdout)) + rt2 = run(["cargo", "test", "--release"], env=env) + tot2 = sum(int(x) for x in re.findall(r"test result: ok\. (\d+) passed", rt2.stdout)) + rel["testes"] = { + "cargo_total": tot1, + "cargo_deterministico": tot1 == tot2 and rt.returncode == 0 and rt2.returncode == 0, + "tempo_s": round(time.time() - t0, 1), + } + + # ---- T3: gates da suíte + suite = os.path.join(R, "suite_v011_final.json") + if os.path.exists(suite): + s = json.load(open(suite)) + rel["suite_v011"] = {"veredito": s["veredito"], "ok": s["ok"]} + + # ---- T4: integridade dos checkpoints (manifesto SHA-256) + import sys + sys.path.insert(0, os.path.join(PASTA, "python")) + import khtst_rust.nucleo_rust as nr + cks = {} + for n in ("tokenizador_conceitos.json", "gerador_conceitos.json"): + p = os.path.join(R, n) + if os.path.exists(p): + cks[n] = {"valido": nr.checkpoint_valido(p), + "manifesto": nr.checkpoint_manifesto(p) is not None} + rel["checkpoints"] = cks + + # ---- T5: despacho de kernels + rel["despacho"] = { + "asm": nr.asm_relatorio(), + "simd": "ver v0.9 (painel_v090 — kernels AVX-512 bit-a-bit)", + } + + # ---- T6: varredura de estados de treino + estados = [] + for raiz, _, nfs in os.walk(PASTA): + if any(x in raiz for x in ("target", ".git", "arquivo_split_v100", "node_modules")): + continue + for n in nfs: + if n.endswith((".estado.json", ".pt", ".npz", ".ckpt")): + estados.append(os.path.relpath(os.path.join(raiz, n), PASTA)) + rel["estados_de_treino"] = estados # .estado.json de oráculos locais são legado + + # ---- T7: telemetria real (avaliação 80) + av = os.path.join(R, "avaliacao_real_v011.json") + if os.path.exists(av): + a = json.load(open(av)) + rel["telemetria_real"] = { + "fase_a": {k: a["fase_a"].get(k) for k in ("perda_inicial", "perda_final", "coerencia_welch_max", "tc_intra_nivel_medio")}, + "fase_b": {k: a["fase_b"].get(k) for k in ("perda_inicial", "perda_final")}, + "moe_real": a.get("moe_real"), + "elastico_real": {k: a["elastico_real"].get(k) for k in + ("origem", "conf_media", "certificados", "rollbacks", "v2_linha")}, + "veredito_real": a.get("veredito_real"), + } + + # ---- T8: unwrap de produção (tratamento.txt §1 — dívida medida) + tot_prod, detalhe = 0, {} + padrao = re.compile(r"\.unwrap\(\)|\.expect\(|panic!|unreachable!") + for cam, _ in arquivos: + src = open(os.path.join(PASTA, cam)).read() + m = re.search(r"#\[cfg\(test\)\]", src) + prod = src[: m.start()] if m else src + # exclui linhas de comentário/documentação (falso-positivo de doc) + n = sum(1 for lin in prod.split("\n") + if padrao.search(lin) and not lin.lstrip().startswith("//")) + if n: + detalhe[cam] = n + tot_prod += n + rel["tratamento_erros"] = { + "unwrap_expect_panic_em_producao": tot_prod, + "por_modulo": detalhe, + "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", + } + + with open(os.path.join(R, "telemetria_v011.json"), "w") as f: + json.dump(rel, f, indent=1, ensure_ascii=False) + print(json.dumps(rel, indent=1, ensure_ascii=False)) + return 0 + + +if __name__ == "__main__": + main() diff --git a/scripts/82_publicar_v011.py b/scripts/82_publicar_v011.py new file mode 100644 index 0000000000000000000000000000000000000000..5f78528a48dcf305b681cbee6d322cec9f40bbc1 --- /dev/null +++ b/scripts/82_publicar_v011.py @@ -0,0 +1,223 @@ +#!/usr/bin/env python3 +"""82_publicar_v011.py — Publicação da v0.11.0 no HF (UM ÚNICO upload_folder +organizado — o HF bloqueia envios parciais em sequência; upload atômico). + +Fases: + 1. inventário da conta + APAGAMENTO de estados de treino remanescentes; + 2. varredura local do VALOR do token (nenhum arquivo pode contê-lo); + 3. UM ÚNICO upload_folder com ignore_patterns EXPLÍCITOS + + delete_patterns p/ os RESTOS do split SRP v0.10 (src/jepa/, src/ + pensamento/, src/moe_redirecionavel/, src/python/ — a árvore canônica + v0.11 voltou aos arquivos planos; o ramo morto vive em + arquivo_split_v100/ NÃO publicado); + 4. verificação pós-upload (0 estados, módulos-chave presentes, sem dirs + do split, sem arquivo_split); + 5. varredura REMOTA do valor do token; + 6. apagamento dos estados de treino LOCAIS (checkpoints + manifestos + + *.estado.json). +Token: EXCLUSIVAMENTE via variável de ambiente HF_TOKEN (nunca em arquivo). +""" +import os +import sys +import tempfile + +ARQUIVOS_EXCLUIR_DIRS = {"target", ".cargo", "__pycache__", ".git", ".venv", + "skills", "externos", "arquivo_split_v100"} +ARQUIVOS_EXCLUIR_NOME = {"shard_treino.jsonl", "shard_validacao.jsonl", + "bpe.json", "rustup-init.sh"} +SUFIXOS_ESTADO = (".pt", ".pth", ".ckpt", ".safetensors", ".bin", ".npz", + ".msgpack") +NOMES_ESTADO = {"gerador_conceitos.json", "tokenizador_conceitos.json", + "gerador_aritmetica.json", "_drill_ck.json"} +# restos do split SRP v0.10 (canon v0.11 = arquivos planos) +DIRS_SPLIT = ["src/jepa", "src/pensamento", "src/moe_redirecionavel", + "src/python"] + + +def coletar(pasta): + arquivos = {} + for raiz, dirs, fs in os.walk(pasta): + dirs[:] = [d for d in dirs if d not in ARQUIVOS_EXCLUIR_DIRS] + for f in fs: + if f in ARQUIVOS_EXCLUIR_NOME or f in NOMES_ESTADO: + continue + if f.endswith(SUFIXOS_ESTADO) or f.endswith(".estado.json"): + continue + if f.endswith(".manifest.json") or f.endswith(".manifest.json.tmp"): + continue + if f.endswith(".so") or f in (".gitignore", "Cargo.lock.ori"): + continue + if f.startswith("hf_") or f.startswith("intros_"): + continue + caminho = os.path.join(raiz, f) + arquivos[os.path.relpath(caminho, pasta)] = caminho + return arquivos + + +def varre_token_em_arquivos(token, pares): + tb = token.encode() + achados = [] + for rel, p in pares.items(): + try: + with open(p, "rb") as f: + if tb in f.read(): + achados.append(rel) + except OSError: + pass + return achados + + +def main(): + from huggingface_hub import HfApi + token = os.environ.get("HF_TOKEN") + if not token: + print("ERRO: HF_TOKEN ausente") + sys.exit(1) + api = HfApi(token=token) + repo = "PowerMachine/khtst-rust" + + # ---------------- 1) inventário da conta + apaga estados ---------------- + print("=== 1) inventário da conta HF (procura estados de treino) ===") + repos = list(api.list_models(author="PowerMachine")) + print(f"repos: {len(repos)}") + total_removidos = 0 + for r in repos: + try: + files = api.list_repo_files(repo_id=r.id, repo_type="model") + except Exception as e: + print(f" {r.id}: erro ao listar ({e})") + continue + estados = [f for f in files + if f.endswith(SUFIXOS_ESTADO) + or f.split("/")[-1] in NOMES_ESTADO + or (".meta.json" in f and "checkpoint" in f)] + if estados: + print(f" {r.id}: APAGANDO {len(estados)} estados") + for f in estados: + api.delete_file(path_in_repo=f, repo_id=r.id, repo_type="model") + total_removidos += len(estados) + else: + print(f" {r.id}: {len(files)} arquivos, 0 estados") + print(f"estados removidos no total: {total_removidos}") + + # ---------------- 2) varredura local do token ---------------- + pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + arquivos = coletar(pasta) + print(f"\n=== 2) varredura local: {len(arquivos)} arquivos ===") + achados = varre_token_em_arquivos(token, arquivos) + if achados: + print(f"ERRO: valor do token encontrado em: {achados}") + sys.exit(1) + print("varredura de token local: limpa") + + # ---------------- 3) UM ÚNICO upload_folder ---------------- + ignores = ( + [f"{d}/**" for d in ARQUIVOS_EXCLUIR_DIRS] + + [f"{d}" for d in ARQUIVOS_EXCLUIR_DIRS] + + [f"**/{n}" for n in ARQUIVOS_EXCLUIR_NOME] + + [f"**/{n}" for n in NOMES_ESTADO] + + list(SUFIXOS_ESTADO) + + ["*.so", ".gitignore", "hf_*.py", "hf_*.json", "intros_*.json", + "*.estado.json", "**/*.manifest.json", "**/*.manifest.json.tmp", + "*.tmp"] + ) + deletes = [f"{d}/**" for d in DIRS_SPLIT] + DIRS_SPLIT + print(f"\n=== 3) upload_folder ÚNICO ({len(arquivos)} arquivos; " + f"delete: {DIRS_SPLIT}) ===") + api.upload_folder( + repo_id=repo, repo_type="model", folder_path=pasta, + ignore_patterns=ignores, + delete_patterns=deletes, + commit_message="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)", + ) + print("upload concluído") + + # ---------------- 4) verificação pós-upload ---------------- + print("\n=== 4) verificação pós-upload ===") + files = api.list_repo_files(repo_id=repo, repo_type="model") + estados = [f for f in files if f.endswith(SUFIXOS_ESTADO) + or f.split("/")[-1] in NOMES_ESTADO + or f.endswith(".manifest.json")] + assert not estados, f"estados publicados: {estados}" + chaves = ["src/asm.rs", "src/raciocinio_elastico.rs", "src/checkpoint.rs", + "src/tipos.rs", "src/jepa.rs", "src/pensamento.rs", + "src/moe_redirecionavel.rs", "src/som4d.rs", "src/fnh.rs", + "src/verificador.rs", "src/lib.rs", + "scripts/79_suite_v011.py", "scripts/80_avaliacao_real_v011.py", + "scripts/81_telemetria_v011.py", "scripts/82_publicar_v011.py", + "docs/memorias/r-36-provas-som-v011.md", + "docs/memorias/r-37-provas-jepa-v011.md", + "docs/memorias/r-38-provas-ncm-v011.md", + "docs/memorias/r-39-provas-pensamento-v011.md", + "docs/memorias/r-40-provas-verificador-v011.md", + "docs/memorias/r-41-provas-moe-fnh-v011.md", + "docs/memorias/r-42-raciocinio-elastico-v011.md", + "docs/memorias/r-43-tratamento-erros-asm-v011.md", + "resultados/suite_v011_final.json", + "resultados/avaliacao_real_v011.json", + "resultados/telemetria_v011.json"] + faltando = [c for c in chaves if c not in files] + assert not faltando, f"faltando: {faltando}" + split_resto = [f for f in files if any(f.startswith(d + "/") for d in DIRS_SPLIT)] + assert not split_resto, f"restos do split ainda no repo: {split_resto[:5]}" + print(f"repo: {len(files)} arquivos | 0 estados | módulos-chave OK | " + f"split v0.10 removido") + + # ---------------- 5) varredura REMOTA do token ---------------- + print("\n=== 5) varredura REMOTA do valor do token ===") + with tempfile.TemporaryDirectory() as tmp: + achados_remotos = [] + for f in files: + if f.endswith((".py", ".rs", ".md", ".json", ".toml", ".sh", ".cfg", + ".txt", ".jsonl")): + try: + p = api.hf_hub_download(repo_id=repo, repo_type="model", + filename=f, local_dir=tmp) + with open(p, "rb") as fh: + if token.encode() in fh.read(): + achados_remotos.append(f) + except Exception: + pass + if achados_remotos: + print(f"ERRO: token remoto em: {achados_remotos}") + sys.exit(1) + print("varredura remota: limpa") + + # ---------------- 6) apaga estados de treino LOCAIS ---------------- + print("\n=== 6) estados de treino locais (checkpoints + manifestos) ===") + apagados = 0 + for nome in sorted(NOMES_ESTADO): + for sufixo in ("", ".manifest.json", ".estado.json"): + p = os.path.join(pasta, "resultados", nome + sufixo) + if os.path.exists(p): + os.remove(p) + apagados += 1 + print(f" apagado: resultados/{nome}{sufixo}") + # varredura final de qualquer outro estado no projeto + for raiz, dirs, fs in os.walk(pasta): + dirs[:] = [d for d in dirs if d not in {"target", ".git", ".venv"}] + for f in fs: + if (f.endswith(SUFIXOS_ESTADO) or f.endswith(".estado.json")) and \ + "resultados" in raiz: + p = os.path.join(raiz, f) + os.remove(p) + apagados += 1 + print(f" apagado: {os.path.relpath(p, pasta)}") + print(f"locais apagados: {apagados}") + print("\nPUBLICAÇÃO v0.11.0 CONCLUÍDA") + + +if __name__ == "__main__": + main() diff --git a/src/asm.rs b/src/asm.rs new file mode 100644 index 0000000000000000000000000000000000000000..4c6611cab2ba026c4bab67560149eb9ad6d7a33b --- /dev/null +++ b/src/asm.rs @@ -0,0 +1,303 @@ +//! `asm` — v0.11.0 (tratamento.txt §1+§2): kernels x86-64 em Assembly inline +//! (`core::arch::asm!`) com tratamento de erros por FLAGS do processador, +//! integrados ao protocolo Rust `Result` — nunca `panic!` em estado +//! inválido (tratamento.txt: "erros recuperáveis e irrecuperáveis"). +//! +//! # Protocolo de erro híbrido (Rust ⇄ Assembly) +//! +//! 1. **Rust (边界/validação)**: comprimentos e pré-condições são validados +//! ANTES do bloco asm ("valide os limites de pilha e divisores antes de +//! executar instruções críticas") — o Assembly nunca recebe entrada +//! inválida de estrutura (apenas valores que podem estourar). +//! 2. **Assembly (detecção)**: cada kernel lê o Registrador de Flags +//! (RFLAGS) após a instrução sensível e desvia com `jcc` condicional: +//! - `CF` (Carry Flag): overflow SEM SINAL — indicador EXATO de estouro +//! em adição `u64` (tratamento.txt §2: "empréstimo/overflow sem sinal"); +//! - `PF` (Parity Flag): após `ucomisd`/`ucomiss`, PF=1 ⇔ comparação +//! UNORDERED ⇔ algum operando é NaN (detecção de NaN por hardware); +//! - `ZF` (Zero Flag): igualdade de ponteiros/contadores no fim de laço. +//! 3. **Convenção de retorno**: o bloco asm devolve um CÓDIGO NUMÉRICO em +//! registrador de propósito geral (tratamento.txt §2: "códigos de retorno +//! em registradores... 0 significa sucesso") que o Rust converte em +//! `Result` — o caminho feliz nunca silencia o erro. +//! +//! # Registradores e flags alterados (documentação obrigatória) +//! +//! | Kernel | Instrução sensível | Flags que altera | Flag consumida | Clobbers | +//! |---|---|---|---|---| +//! | `soma_u64_cheia` | `add` | AF CF OF SF ZF PF | `CF` (`jc`) | 3 GPRs (declarados) | +//! | `primeiro_nan_f64` | `ucomisd` | ZF PF CF | `PF` (`jp`) | 3 GPRs + 1 XMM | +//! | `primeiro_nan_f32` | `ucomiss` | ZF PF CF | `PF` (`jp`) | 3 GPRs + 1 XMM | +//! +//! O compilador Rust recebe a lista `in`/`out`/`inout` COMPLETA — nenhum +//! registrador é alterado implicitamente (clobber oculto = bug). + +use std::arch::asm; + +/// Padrão `module::error` (tratamento.txt §1): enum coeso no escopo do +/// módulo, `thiserror` para Display/Error sem código repetido. +pub mod error { + #[derive(Debug, Clone, PartialEq, thiserror::Error)] + pub enum ErroAsm { + /// `CF=1` após `add`: a soma excede `u64::MAX` — o valor NÃO é + /// confiável (wraparound evitado por hardware, não por software). + #[error("estouro de soma u64: {n} parcelas ultrapassam u64::MAX (CF=1 no kernel add/jc)")] + EstouroSoma { n: usize }, + /// Pré-condição estrutural violada (nunca deve ocorrer via API pública). + #[error("pré-condição violada: {motivo}")] + PreCondicao { motivo: String }, + } +} + +pub use error::ErroAsm; + +/// **Kernel 1 — soma u64 com estouro detectado por Carry Flag.** +/// +/// Lógica computacional (prova por caso): +/// - `add rax, [ptr]` com valores u64: o processador soma em largura fixa +/// de 64 bits e arma `CF=1` sse o resultado verdadeiro ≥ 2^64 (definição +/// do sinal de carry em adição sem sinal — manual Intel, ADD). Não existe +/// estado intermediário: OU cabe (CF=0, soma exata), OU estoura (CF=1). +/// - `jc 1f` consome CF imediatamente após a adição (nenhuma instrução +/// intermediária altera flags — `add ptr, 8` vem DEPOIS do desvio). +/// - O laço termina por `cmp`/`jne` (ZF=0 ⇒ ponteiros distintos): após a +/// última parcela, `p == f` ⇒ ZF=1 ⇒ não desvia ⇒ sai com código 0. +/// - Com `CF=1` o kernel desvia para `mov {e}, 1` (código de erro 1 em +/// registrador — convenção tratamento.txt §2) e a soma parcial é +/// DESCARTADA pelo Rust (`Err`). +/// +/// Determinismo: uma única ordem de soma (esquerda→direita) — o resultado é +/// bit-a-bit reprodutível (u64 é associativo/exato quando não estoura). +pub fn soma_u64_cheia(xs: &[u64]) -> Result { + if xs.is_empty() { + return Ok(0); // validação de fronteira em Rust (tratamento.txt) + } + let mut soma: u64 = 0; + let mut codigo_erro: u64; + // {p} é inout: o kernel AVANÇA o ponteiro — modificar um `in` é UB + // de alocação de registradores (lesson v011-1, bug meu catalogado) + let mut ptr = xs.as_ptr(); + unsafe { + asm!( + "xor {e}, {e}", // e := 0 (sucesso); ZF=1 (não consumido) + "2:", // ── corpo do laço ── + "add {s}, [{p}]", // soma += *p [AF CF OF SF ZF PF] + "jc 3f", // CF=1 ⇒ estouro sem sinal ⇒ erro + "add {p}, 8", // p += 8 (flags alteradas, NÃO consumidas) + "cmp {p}, {f}", // p == fim? [CF OF SF ZF PF] + "jne 2b", // ZF=0 ⇒ continua + "jmp 4f", // fim normal: código 0 preservado + "3:", // ── caminho de ERRO ── + "mov {e}, 1", // código de erro 1 (registrador) + "4:", + s = inout(reg) soma, + p = inout(reg) ptr, + f = in(reg) xs.as_ptr().wrapping_add(xs.len()), + e = out(reg) codigo_erro, + ); + } + if codigo_erro != 0 { + return Err(ErroAsm::EstouroSoma { n: xs.len() }); + } + Ok(soma) +} + +/// **Kernel 2 — primeiro NaN f64 detectado por Parity Flag (ucomisd).** +/// +/// Lógica computacional: +/// - `ucomisd xmm0, [ptr]` compara 0.0 (em xmm) com o valor da fatia: +/// o sinal PF é armado ⇔ a comparação é UNORDERED ⇔ ALGUM operando é NaN +/// (manual Intel, UCOMISD: "unordered" ⇔ QNaN/SNaN em qualquer lado). +/// Como 0.0 é sempre ordenado, PF=1 ⇔ o ELEMENTO é NaN (por eliminação). +/// - `jp 1f` consome PF imediatamente; `i` preserva o ÍNDICE exato do +/// primeiro NaN (código de retorno em registrador — o chamador sabe ONDE, +/// não apenas SE). +/// - Laço `cmp {i}, {n}` / `jne 2b` (ZF): termina com sentinel `−1` (64 bits +/// complemento-2 = `u64::MAX`) quando nenhum NaN existe. +/// - Exceção de ponto flutuante #I (invalid) de QNaN está MASCARADA por +/// padrão no MXCSR do processo Rust — o único efeito observável é PF=1. +/// +/// Devolve `Ok(Some(idx))` no primeiro NaN, `Ok(None)` se a fatia é limpa. +pub fn primeiro_nan_f64(xs: &[f64]) -> Result, ErroAsm> { + if xs.is_empty() { + return Ok(None); + } + let mut idx: u64; + // {p} é inout (o kernel avança o ponteiro — v011-1) + let mut ptr = xs.as_ptr(); + unsafe { + asm!( + "xor {i}, {i}", // i := 0 (índice corrente); ZF=1 + "2:", // ── corpo do laço ── + "ucomisd {zero}, [{p}]", // 0.0 vs xs[i] [ZF PF CF] + "jp 3f", // PF=1 ⇒ unordered ⇒ NaN no índice i + "add {p}, 8", // p += 8 (flags não consumidas) + "add {i}, 1", // i += 1 (flags não consumidas) + "cmp {i}, {n}", // i == n? [ZF CF OF SF PF] + "jne 2b", // ZF=0 ⇒ continua + "mov {i}, -1", // sentinel NOT_FOUND (u64::MAX) + "jmp 4f", + "3:", // ── achou: i já é o índice ── + "4:", + zero = in(xmm_reg) 0f64, + p = inout(reg) ptr, + n = in(reg) xs.len() as u64, + i = out(reg) idx, + ); + } + if idx == u64::MAX { + return Ok(None); + } + Ok(Some(idx as usize)) +} + +/// **Kernel 3 — primeiro NaN f32 (ucomiss/jp)** — idem ao Kernel 2 em +/// precisão simples (os gradientes do treino são `Vec`). +pub fn primeiro_nan_f32(xs: &[f32]) -> Result, ErroAsm> { + if xs.is_empty() { + return Ok(None); + } + let mut idx: u64; + // {p} é inout (o kernel avança o ponteiro — v011-1) + let mut ptr = xs.as_ptr(); + unsafe { + asm!( + "xor {i}, {i}", + "2:", + "ucomiss {zero}, [{p}]", // 0.0f vs xs[i] [ZF PF CF] + "jp 3f", // PF=1 ⇒ NaN no índice i + "add {p}, 4", // passo de 4 bytes (f32) + "add {i}, 1", + "cmp {i}, {n}", + "jne 2b", + "mov {i}, -1", + "jmp 4f", + "3:", + "4:", + zero = in(xmm_reg) 0f32, + p = inout(reg) ptr, + n = in(reg) xs.len() as u64, + i = out(reg) idx, + ); + } + if idx == u64::MAX { + return Ok(None); + } + Ok(Some(idx as usize)) +} + +/// Relatório do módulo (telemetria): alvo e kernels disponíveis. +pub fn relatorio() -> String { + format!( + "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)" + ) +} + +pub fn versao() -> &'static str { + "asm-0.11.0" +} + +// --------------------------------------------------------------------------- +// Testes de falsificação (lógica computacional dos flags) +// --------------------------------------------------------------------------- + +#[cfg(test)] +mod testes { + use super::*; + + /// CF=1 exato: u64::MAX + 1 estoura e o kernel reporta (não wrapa). + #[test] + fn soma_estoura_na_segunda_parcela() { + assert_eq!(soma_u64_cheia(&[u64::MAX, 1]).unwrap_err(), ErroAsm::EstouroSoma { n: 2 }); + assert_eq!(soma_u64_cheia(&[u64::MAX]).unwrap(), u64::MAX); // 1 parcela: ok + assert_eq!( + soma_u64_cheia(&[u64::MAX; 3]).unwrap_err(), + ErroAsm::EstouroSoma { n: 3 } + ); + } + + /// Equivalência EXATA com a soma Rust (u64 é associativo sem estouro). + #[test] + fn soma_equivalente_rust() { + let mut rng = crate::rng::RngDeterministico::novo(3); + for caso in 0..8 { + let n = 1 + caso * 37; + let v: Vec = (0..n).map(|_| (rng.uniforme() * 1e6) as u64).collect(); + let esperado: u64 = v.iter().sum(); + assert_eq!(soma_u64_cheia(&v).unwrap(), esperado, "caso {caso}"); + } + // fronteira: soma que CHEGA exatamente em u64::MAX (CF=0) + assert_eq!(soma_u64_cheia(&[u64::MAX - 5, 5]).unwrap(), u64::MAX); + // fronteira: u64::MAX-1 + 1 = MAX (ok) e MAX + MAX (estoura) + assert_eq!(soma_u64_cheia(&[u64::MAX - 1, 1]).unwrap(), u64::MAX); + assert!(soma_u64_cheia(&[u64::MAX, u64::MAX]).is_err()); + // vazio => Ok(0) (fronteira validada em Rust antes do asm) + assert_eq!(soma_u64_cheia(&[]).unwrap(), 0); + } + + /// PF=1 exato: NaN em posição conhecida (quiet e signaling). + #[test] + fn nan_f64_localizado() { + let limpo: Vec = (0..1000).map(|i| i as f64 * 0.5 - 250.0).collect(); + assert_eq!(primeiro_nan_f64(&limpo).unwrap(), None); + // quiet NaN (0x7FF8...) na posição 7 + let mut v = limpo.clone(); + v[7] = f64::from_bits(0x7FF8_0000_0000_0000); + assert_eq!(primeiro_nan_f64(&v).unwrap(), Some(7)); + // signaling NaN (0x7FF0...001) na posição 0 + v = limpo.clone(); + v[0] = f64::from_bits(0x7FF0_0000_0000_0001); + assert_eq!(primeiro_nan_f64(&v).unwrap(), Some(0)); + // último elemento + v = limpo.clone(); + v[999] = f64::NAN; + assert_eq!(primeiro_nan_f64(&v).unwrap(), Some(999)); + // inf NÃO é NaN (ucomisd ordenado com +inf) => None + v = limpo.clone(); + v[500] = f64::INFINITY; + v[501] = f64::NEG_INFINITY; + assert_eq!(primeiro_nan_f64(&v).unwrap(), None); + // vazio => None + assert_eq!(primeiro_nan_f64(&[]).unwrap(), None); + } + + /// PF=1 em f32 (gradientes do treino são Vec). + #[test] + fn nan_f32_localizado() { + let limpo: Vec = (0..512).map(|i| i as f32 - 256.0).collect(); + assert_eq!(primeiro_nan_f32(&limpo).unwrap(), None); + let mut v = limpo.clone(); + v[13] = f32::NAN; + assert_eq!(primeiro_nan_f32(&v).unwrap(), Some(13)); + v[0] = f32::from_bits(0x7FC0_0000); // QNaN + assert_eq!(primeiro_nan_f32(&v).unwrap(), Some(0)); + v = limpo.clone(); + v[511] = f32::NAN; + assert_eq!(primeiro_nan_f32(&v).unwrap(), Some(511)); + // inf/‑inf não são NaN + v = limpo.clone(); + v[10] = f32::INFINITY; + assert_eq!(primeiro_nan_f32(&v).unwrap(), None); + } + + /// Desempenho honesto: o kernel asm NÃO é mais lento que o iterador + /// Rust (verificação de sanidade — mesma ordem de grandeza). + #[test] + fn desempenho_comparavel_rust() { + let v: Vec = (0..1_000_000).map(|i| (i % 97) as f64 * 0.001).collect(); + let t0 = std::time::Instant::now(); + let r_asm = primeiro_nan_f64(&v).unwrap(); + let d_asm = t0.elapsed(); + let t1 = std::time::Instant::now(); + let r_rust = v.iter().position(|x| x.is_nan()); + let d_rust = t1.elapsed(); + assert_eq!(r_asm, r_rust); + // tolerância 10× (kernel escalar por elemento; nunca deve ser 10× pior) + assert!( + d_asm.as_nanos() <= 10 * d_rust.as_nanos().max(1), + "asm {d_asm:?} vs rust {d_rust:?}" + ); + } +} diff --git a/src/bin/bench_v090.rs b/src/bin/bench_v090.rs index 88bbab5f259134af42da9d31f15ef3fb353ff446..24d2e249e609cc6afe6bf2961dd94735bf4b5434 100644 --- a/src/bin/bench_v090.rs +++ b/src/bin/bench_v090.rs @@ -10,7 +10,7 @@ use std::hint::black_box; use std::time::Instant; fn mediana(mut xs: Vec) -> f64 { - xs.sort_by(|a, b| a.partial_cmp(b).unwrap()); + xs.sort_by(|a, b| a.total_cmp(b)); xs[xs.len() / 2] } diff --git a/src/controlador.rs b/src/controlador.rs index dfef8481f62b79e582c47dde392d3613e531be9d..24aa5bfa41b837f3d54e6f0eae2b99a82929dcc2 100644 --- a/src/controlador.rs +++ b/src/controlador.rs @@ -95,7 +95,7 @@ impl Controlador { pub fn clip_corrente(&mut self, hub: &mut TelemetryHub) -> f64 { if self.normas_grad.len() >= 32 { let mut v = self.normas_grad.clone(); - v.sort_by(|a, b| a.partial_cmp(b).unwrap()); + v.sort_by(|a, b| a.total_cmp(b)); let idx = ((self.clip_percentil / 100.0) * (v.len() - 1) as f64).round() as usize; let novo = v[idx.min(v.len() - 1)].max(0.25); if (novo - self.clip).abs() / self.clip > 0.3 { @@ -187,7 +187,7 @@ impl AutoAjustePensamento { return self.tau_c; // amostra insuficiente — mantém (honesto) } let mut v = self.confs_retidas.clone(); - v.sort_by(|a, b| a.partial_cmp(b).unwrap()); + v.sort_by(|a, b| a.total_cmp(b)); let idx = (((1.0 - epsilon.clamp(0.0, 0.5)) * v.len() as f64).ceil() as usize) .saturating_sub(1) .min(v.len() - 1); @@ -215,7 +215,7 @@ impl AutoAjustePensamento { if razoes.len() < 4 { return self.orcamento_b; } - razoes.sort_by(|a, b| a.partial_cmp(b).unwrap()); + razoes.sort_by(|a, b| a.total_cmp(b)); let rho = razoes[razoes.len() / 2]; // mediana (robusto) let delta0 = self.ganhos_por_iteracao.iter().cloned().fold(f64::MIN, f64::max).max(1e-9); // B* = ceil( ln(c·(1−ρ)/Δ) / ln(ρ) ) — ótimo do custo marginal @@ -236,7 +236,7 @@ impl AutoAjustePensamento { return self.n_tentativas; } let mut v = self.acordos.clone(); - v.sort_by(|a, b| a.partial_cmp(b).unwrap()); + v.sort_by(|a, b| a.total_cmp(b)); let a_med = v[v.len() / 2]; // lema do acordo: a = p² + (1−p)² ⇒ p = (1 + √(2a−1))/2 (a ≥ 1/2) let p_chapeu = if a_med >= 0.5 { diff --git a/src/fnh.rs b/src/fnh.rs index 5bf01de2209a823e95d714af9b34ea2de7104d1b..9224d9fff5bf3212829d89355f9df11146162d70 100644 --- a/src/fnh.rs +++ b/src/fnh.rs @@ -388,6 +388,22 @@ impl GatePunicao { let sig = 1.0 / (1.0 + (-z).exp()); (2.0 * sig - 1.0).max(0.0) } + + /// **v0.11.0 (tipos de domínio, T-V2):** gate TIPADO — + /// `Probabilidade → GateAtivacao`. O valor bruto é sempre ∈ [0,1] + /// (Teo F-3: sigmoide retificada), mas o construtor tipado é defesa em + /// profundidade: falha impossível vira clamp AUDITÁVEL com log (nunca + /// panic em caminho de produção — tratamento.txt §1). + pub fn valor_tipado(&self, punicao: &crate::tipos::Probabilidade) -> crate::tipos::GateAtivacao { + let g = self.valor(punicao.valor()); + match crate::tipos::GateAtivacao::novo(g) { + Ok(t) => t, + Err(e) => { + log::error!("valor_tipado: gate {g} fora de [0,1] ({e}) — clamp a ZERO"); + crate::tipos::GateAtivacao::ZERO + } + } + } } /// Camada FNH — uma hipótese flexível com rotações aprendíveis, suavização de diff --git a/src/gerador.rs b/src/gerador.rs index 23fa9abfd52fa623f52ed9e5cc746ee845b5ab59..a985f10e98d002671606e7732baee4797eae4abd 100644 --- a/src/gerador.rs +++ b/src/gerador.rs @@ -246,9 +246,9 @@ impl GeradorConceitos { } let txt = serde_json::to_string(&serde_json::Value::Object(obj)) .map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?; - let tmp = format!("{caminho}.tmp"); - std::fs::write(&tmp, txt).map_err(|e| candle_core::Error::Msg(format!("io: {e}")))?; - std::fs::rename(&tmp, caminho).map_err(|e| candle_core::Error::Msg(format!("rename: {e}")))?; + // v0.11.0 (restaurado da v0.10.0): checkpoint ATÔMICO completo — + // tmp→fsync→rename→fsync(dir) + manifesto SHA-256 (Teo CP-1/CP-2) + crate::checkpoint::salvar_atomico(caminho, &txt)?; Ok(()) } diff --git a/src/jepa.rs b/src/jepa.rs index df48617762deaed6edc2a1d4f5ab2d45041704ec..fbbb89bcfad6c9c68a601e849476397e844e7b1f 100644 --- a/src/jepa.rs +++ b/src/jepa.rs @@ -103,6 +103,40 @@ impl MlpJepa { } } +/// Modo do termo de variância do regularizador VC (v0.10.0, crítica +/// DeepSeek J-1 — análise e provas completas em r-35 §1). +/// +/// A crítica acerta que a prova original do J-1 é INVÁLIDA no argumento de +/// ponto crítico (`∂V/∂std ≠ 0` **não** implica `∇_z V ≠ 0`: a cadeia passa +/// pela raiz `std = √var`, não-diferenciável em `var = 0`, e `∇_z var = 0` no +/// colapso — o produto é `−∞·0`, indefinido). MAS o mecanismo apontado pela +/// crítica (a dobradiça `max(0,γ−s)²` ter kink em `s = 0`) está ERRADO: a +/// dobradiça é C¹ em todo `ℝ` (derivada contínua `−2(γ−s)·1[s<γ]`, com +/// `−2·0 = 0` em `s = γ`); o kink é da RAIZ. Consequência prática: o +/// `Softplus` proposto NÃO restaura a diferenciabilidade w.r.t. `z` (Teo +/// J-1′-iii, teste `j1d`). O teorema correto (J-1′) é que o colapso é uma +/// **sela sharp**: `D⁺V(u) = −(2γ/d)·Σ_j s_j(u) < 0` para toda direção +/// centrada `u ≠ 0`, e sempre existe direção de descida para `L` completa +/// (tome `u` centrada e ⊥ `∇L_pred`). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum ModoVariancia { + /// `max(0, γ−√var)²` — comportamento v0.5.0–v0.9.0 (bit-a-bit). + /// Sela SHARP no colapso: escape LINEAR em `|t|` (melhor dinâmica de + /// fuga); gradiente w.r.t. z não existe no colapso exato (medido no + /// teste `j1a`) — configuracão de medida zero em f32. + Dobradica, + /// `max(0, γ−√(var+ε))²` — único modo `C^∞` em `z`. No colapso o + /// gradiente EXISTE e é 0 (ponto crítico), mas a sela é ESTRITA: + /// `V_ε` decai quadraticamente ao afastar-se (J-1′-ii). Viés + /// `≤ 2γ√ε·d` em relação à dobradiça (ε=1e-12 ⇒ ~1e-6·γ). + RaizSuavizada, + /// `softplus(k(γ−std))²` — proposta DeepSeek. NÃO restaura a + /// diferenciabilidade w.r.t. `z` (o kink é da raiz — contraexemplo + /// `j1d`); remove apenas a não-C² da dobradiça em `std = γ`. Opt-in + /// documentado p/ uso com métodos de 2ª ordem no regularizador. + Softplus, +} + /// Núcleo JEPA: codificador + preditor + alvo EMA + regularizador VC. pub struct NucleoJepa { pub encoder: MlpJepa, @@ -115,6 +149,12 @@ pub struct NucleoJepa { pub m: f64, pub lambda_vc: f64, pub gamma_vc: f64, + /// v0.10.0 — modo do termo de variância (crítica DeepSeek J-1). + pub modo_var: ModoVariancia, + /// ε do modo `RaizSuavizada`. + pub eps_raiz: f64, + /// k do modo `Softplus`. + pub k_softplus: f64, } impl NucleoJepa { @@ -170,9 +210,21 @@ impl NucleoJepa { m, lambda_vc, gamma_vc, + modo_var: ModoVariancia::Dobradica, + eps_raiz: 1e-12, + k_softplus: 5.0, }) } + /// v0.10.0 — define o modo do termo de variância (J-1′). Aditivo: o + /// default `Dobradica` preserva o comportamento bit-a-bit das + /// versões anteriores (SOTA VICReg canônico — Bardes et al. 2022). + pub fn definir_modo_variancia(&mut self, modo: ModoVariancia, eps_raiz: f64, k_softplus: f64) { + self.modo_var = modo; + self.eps_raiz = eps_raiz.max(0.0); + self.k_softplus = k_softplus.max(1e-3); + } + pub fn vars(&self) -> Vec { let mut v = self.encoder.vars(); v.extend(self.preditor.vars()); @@ -219,29 +271,66 @@ impl NucleoJepa { /// Regularizador variância-covariância do lote de incorporações z (n, d). /// - /// **J-1:** no colapso total `z_i = c ∀i` ⇒ `std_j = 0` ⇒ `V = d·γ²`. + /// **J-1′ (v0.10.0):** no colapso total `z_i = c ∀i` ⇒ `std_j = 0` ⇒ + /// `V = γ²` (Dobradica). O colapso é uma SELA SHARP, não um ponto de + /// mínimo: `D⁺V(u) = −(2γ/d)·Σ_j s_j(u) < 0` para toda direção centrada + /// `u ≠ 0` — prova em r-35 §1.2. A crítica DeepSeek ao argumento de ponto + /// crítico da v0.5.0 é PROCEDENTE (cadeia inválida pela raiz); a correção + /// proposta (softplus) é REFUTADA (j1d) — o kink é da raiz, não da + /// dobradiça. Modos alternativos: `RaizSuavizada` (único C^∞ em z, sela + /// estrita com escape quadrático) e `Softplus` (opt-in, ver enum). pub fn perda_vc(&self, z: &Tensor) -> Result { let n = z.dim(0)? as f64; let d = self.d_emb; let media = z.mean_keepdim(0)?; // (1, d) let centr = z.broadcast_sub(&media)?; let var = (centr.sqr()?.sum(0)? / n)?; // (d,) - let std = var.sqrt()?; - // dobradiça: max(0, γ − std)² + // std por modo (J-1′): o kink está na RAIZ, não na dobradiça + let std = match self.modo_var { + ModoVariancia::RaizSuavizada => { + let eps_t = Tensor::new(self.eps_raiz as f32, z.device())? + .broadcast_as(var.dims())?; + (&var + &eps_t)?.sqrt()? + } + ModoVariancia::Dobradica | ModoVariancia::Softplus => var.sqrt()?, + }; let gamma_t = Tensor::new(self.gamma_vc as f32, z.device())?.broadcast_as(std.dims())?; - let gap = gamma_t.broadcast_sub(&std)?.clamp(0.0, f64::INFINITY)?; + let gap: Tensor = match self.modo_var { + ModoVariancia::Dobradica | ModoVariancia::RaizSuavizada => { + // dobradiça: max(0, γ − std) — C¹ em std (derivada 0 em std=γ) + (gamma_t.broadcast_sub(&std)?).clamp(0.0, f64::INFINITY)? + } + ModoVariancia::Softplus => { + // sp(k(γ−std)) = log(1+e^{k(γ−std)}) — forma direta é estável + // no domínio |k(γ−std)| ≤ k·max(γ,std) (f32 satura e^x em + // x>88; k·γ ≤ 50 por construção do setter) + let x = (gamma_t.broadcast_sub(&std)?.affine(self.k_softplus, 0.0))? + .exp()?; + (&x + 1.0)?.log()? + } + }; let v = gap.sqr()?.sum_all()?; - // covariância fora-diagonal: C = centrᵀ·centr/n; perda = ‖C − diag‖²_F/(2d) + // covariância fora-diagonal: C = centrᵀ·centr/n; perda = ‖offdiag(C)‖²_F/(2d) + // + // **BUG v100-1 (corrigido na v0.10.0)**: até a v0.9.0 a máscara + // tinha 1s NA diagonal — o termo computava `Σ_j var_j²/(2d)` + // (quadrado das VARIÂNCIAS) em vez do fora-diagonal documentado e + // provado (r-20 §0, Corolário J-1.1 sobre rank(Cov) < d). O + // contraexemplo foi exposto pelo teste de compatibilidade j1e + // (falsificação pedida pela crítica DeepSeek) — o gate agora valida + // contra a referência CORRETA. Efeito da correção: o termo passa a + // DESCORRELACIONAR dimensões (sua função provada); a dobradiça + // continua responsável pelo anti-colapso (J-1′). let cov = (centr.transpose(0, 1)?.matmul(¢r)? / n)?; // (d, d) - let mask_diag = { - let mut m = vec![0f32; d * d]; + let mask_fora = { + let mut m = vec![1f32; d * d]; for i in 0..d { - m[i * d + i] = 1.0; + m[i * d + i] = 0.0; } Tensor::from_vec(m, (d, d), z.device())? }; - let fora = ((&cov * &mask_diag)?.sqr()?.sum_all()? / (2.0 * d.max(1) as f64))?; + let fora = ((&cov * &mask_fora)?.sqr()?.sum_all()? / (2.0 * d.max(1) as f64))?; let v_norm = (v / d.max(1) as f64)?; Ok((v_norm + fora)?) } @@ -440,7 +529,7 @@ pub fn pontos_mais_distantes(pontos: &[Vec], k: usize, rng: &mut RngDetermi .iter() .enumerate() .filter(|(i, _)| !centros.contains(i)) - .max_by(|a, b| a.1.partial_cmp(b.1).unwrap()) + .max_by(|a, b| a.1.total_cmp(b.1)) .map(|(i, _)| i) .unwrap_or(0); centros.push(prox); @@ -588,7 +677,7 @@ pub fn em_grupos_pontos(pc: &Tensor, k: usize, m: usize, rng: &mut RngDeterminis ord.sort_by(|&a, &b| { let da = distancia_eucl(&coords_f[a], &coords_f[ci]); let db = distancia_eucl(&coords_f[b], &coords_f[ci]); - da.partial_cmp(&db).unwrap() + da.total_cmp(&db) }); let mut buf: Vec = Vec::with_capacity(m * d); for &idx in ord.iter().take(m) { @@ -650,6 +739,10 @@ pub struct CfgJepa { pub semente: u64, /// tamanho do bloco-alvo (nº de patches por bloco). pub tam_bloco: usize, + /// v0.10.0 (J-1′, crítica DeepSeek): modo do termo de variância. + pub modo_variancia: ModoVariancia, + pub eps_raiz: f64, + pub k_softplus: f64, } impl Default for CfgJepa { @@ -664,10 +757,18 @@ impl Default for CfgJepa { frac_mascara: 0.35, semente: 42, tam_bloco: 2, + modo_variancia: ModoVariancia::Dobradica, + eps_raiz: 1e-12, + k_softplus: 5.0, } } } +/// Aplica o modo de variância da cfg a um núcleo recém-construído (v0.10.0). +pub fn aplicar_modo_variancia(nucleo: &mut NucleoJepa, cfg: &CfgJepa) { + nucleo.definir_modo_variancia(cfg.modo_variancia, cfg.eps_raiz, cfg.k_softplus); +} + /// Relatório de treino de uma variante. #[derive(Debug, Clone)] pub struct RelatorioJepa { @@ -706,7 +807,7 @@ pub fn treinar_variante( let mut nucleo = NucleoJepa::novo_com_semente( d_patch, cfg.d_emb, - if cond.is_some() { cond.unwrap().dim(1)? } else { 0 }, + if cond.is_some() { cond.as_ref().unwrap().dim(1)? } else { 0 }, n, cfg.m, cfg.lambda_vc, @@ -714,6 +815,7 @@ pub fn treinar_variante( cfg.semente, dev, )?; + aplicar_modo_variancia(&mut nucleo, &cfg); let otimo_vars = nucleo.vars(); let mut otimizador = crate::treino::AdamWManual::novo(otimo_vars, cfg.lr, 0.01); @@ -875,7 +977,7 @@ pub fn treinar_variante_adaptativa( let mut nucleo = NucleoJepa::novo_com_semente( d_patch, cfg.d_emb, - if cond.is_some() { cond.unwrap().dim(1)? } else { 0 }, + if cond.is_some() { cond.as_ref().unwrap().dim(1)? } else { 0 }, n, cfg.m, cfg.lambda_vc, @@ -883,6 +985,7 @@ pub fn treinar_variante_adaptativa( cfg.semente, dev, )?; + aplicar_modo_variancia(&mut nucleo, &cfg); let otimo_vars = nucleo.vars(); let mut otimizador = crate::treino::AdamWManual::novo(otimo_vars, cfg.lr, 0.01); let z0 = nucleo.codificar(patches)?; @@ -1061,7 +1164,7 @@ impl SonicMoe { let mut cand: Vec<(usize, f32)> = (0..n) .map(|i| (i, probs_v[i][ei])) .collect(); - cand.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + cand.sort_by(|a, b| b.1.total_cmp(&a.1)); let mut escolhidos: Vec = Vec::new(); for (i, _) in cand { if carga[ei] >= self.capacidade { @@ -1070,7 +1173,7 @@ impl SonicMoe { // verifica se ei está no top-k do token i let mut ordem: Vec<(f32, usize)> = (0..e).map(|k| (probs_v[i][k], k)).collect(); - ordem.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap()); + ordem.sort_by(|a, b| b.0.total_cmp(&a.0)); let top: Vec = ordem.iter().rev().take(self.n_top).map(|(_, k)| *k).collect(); if top.contains(&ei) { escolhidos.push(i); @@ -1269,6 +1372,7 @@ pub fn treinar_lejepa( let mut nucleo = NucleoJepa::novo_com_semente( d_patch, cfg.d_emb, d_cond, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev, )?; + aplicar_modo_variancia(&mut nucleo, &cfg); let mut otim = crate::treino::AdamWManual::novo(nucleo.vars(), cfg.lr, 0.01); let mut perda_inicial = f64::NAN; let mut perda_final = f64::NAN; @@ -1340,6 +1444,8 @@ pub fn treinar_mcjepa( // núcleo A→B e núcleo B→A (compartilham apenas a estrutura) 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)?; 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)?; + aplicar_modo_variancia(&mut nb, &cfg); + aplicar_modo_variancia(&mut na, &cfg); let mut otim = crate::treino::AdamWManual::novo( [nb.vars(), na.vars()].concat(), cfg.lr, @@ -1415,10 +1521,12 @@ pub fn treinar_bjepa(patches: &Tensor, cfg: &CfgJepa, dev: &Device) -> Result 0.9, "perda VC no colapso = {v} (deveria ser ~1)"); } + // ----------------------------------------------------------------- + // v0.10.0 — J-1′ (crítica DeepSeek): o colapso é SELA SHARP, não + // ponto crítico; o kink é da RAIZ (não da dobradiça); softplus NÃO + // restaura diferenciabilidade w.r.t. z. Provas em r-35 §1. + // ----------------------------------------------------------------- + + /// Lote de colapso + direção centrada u (col 0: metade +1 metade −1; + /// col 1: alternado ±1) — ambas as colunas com s_j = 1, média 0. + fn lote_e_direcao_j1(n: usize, d: usize) -> (Vec, Vec) { + let mut z = vec![0.5f32; n * d]; + let mut u = vec![0f32; n * d]; + for i in 0..n { + for j in 0..d { + let s0 = if i < n / 2 { 1.0 } else { -1.0 }; + let s1 = if i % 2 == 0 { 1.0 } else { -1.0 }; + let s = if j == 0 { s0 } else { s1 }; + u[i * d + j] = s; + } + } + z.shrink_to_fit(); + (z, u) + } + + #[test] + fn teste_j1a_dobradica_gradiente_indefinido_no_colapso() { + // Falsificação da prova v0.5.0 (r-20 §1): no colapso exato, a + // retropropagação da Dobradica através de std = √var produz + // gradiente NÃO-finito w.r.t. z (o produto da cadeia é −∞·0). + // "∂V/∂std = −2γ ≠ 0" NÃO implica "∇_z V ≠ 0" — a crítica + // DeepSeek procede neste ponto. (Forward permanece correto: γ².) + let dev = Device::Cpu; + let nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap(); + let (z, _) = lote_e_direcao_j1(8, 8); + let zt = Tensor::from_vec(z, (8, 8), &dev).unwrap(); + let zv = Var::from_tensor(&zt).unwrap(); + let l = nucleo.perda_vc(&zv.as_tensor()).unwrap(); + let v = l.to_scalar::().unwrap() as f64; + assert!((v - 1.0).abs() < 1e-6, "forward no colapso = {v} (esperado γ²=1)"); + let grads = l.backward().unwrap(); + let g = grads.get(&zv).unwrap().flatten_all().unwrap().to_vec1::().unwrap(); + let n_nao_finitos = g.iter().filter(|x| !x.is_finite()).count(); + // registra o comportamento REAL do autograd no colapso exato + println!("j1a: não-finitos no gradiente z = {n_nao_finitos}/{}", g.len()); + assert!( + g.iter().any(|x| !x.is_finite()), + "esperado gradiente não-finito no colapso exato (kink da raiz); \ + se isto falhar, o autograd do candle short-circuitou o kink — \ + atualizar r-35 §1.4 com a medição nova" + ); + } + + #[test] + fn teste_j1b_sela_sharp_descida_linear() { + // J-1′-ii: D⁺V(u) = −(2γ/d)·Σ_j s_j(u) — descida LINEAR em |t|. + // n=8, d=8, u com s_j = 1 ∀j ⇒ Σs_j = 8 ⇒ C = (2·1/8)·8 = 2. + let dev = Device::Cpu; + let nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap(); + let (z, u) = lote_e_direcao_j1(8, 8); + let v_de = |t: f64| -> f64 { + let dados: Vec = z + .iter() + .zip(&u) + .map(|(&zi, &ui)| zi + (t * ui as f64) as f32) + .collect(); + let zt = Tensor::from_vec(dados, (8, 8), &dev).unwrap(); + nucleo.perda_vc(&zt).unwrap().to_scalar::().unwrap() as f64 + }; + let v0 = v_de(0.0); + let c_teorico = 2.0 * 1.0 / 8.0 * 8.0; // (2γ/d)·Σs_j = 2 + let t = 0.01; + let slope = (v_de(t) - v0) / t; + assert!( + (slope + c_teorico).abs() < 0.05 * c_teorico, + "slope linear medido {slope} vs teórico −{c_teorico}" + ); + // afastar-se do colapso REDUZ V (sela, não mínimo) + assert!(v_de(0.1) < v0, "V deve cair ao afastar do colapso (sela sharp)"); + } + + #[test] + fn teste_j1c_raiz_suavizada_critico_mas_sela_estrita() { + // J-1′-ii(ε): com std = √(var+ε), o gradiente no colapso EXISTE, + // é finito e IGUAL A ZERO (ponto crítico) — mas V_ε cai ao + // afastar-se (SELA ESTRITA, escape quadrático). O modo troca a + // natureza do ponto sem criar mínimo espúrio. + let dev = Device::Cpu; + let mut nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap(); + nucleo.definir_modo_variancia(ModoVariancia::RaizSuavizada, 1e-6, 5.0); + let (z, u) = lote_e_direcao_j1(8, 8); + let zt = Tensor::from_vec(z.clone(), (8, 8), &dev).unwrap(); + let zv = Var::from_tensor(&zt).unwrap(); + let l = nucleo.perda_vc(&zv.as_tensor()).unwrap(); + let grads = l.backward().unwrap(); + let g = grads.get(&zv).unwrap().flatten_all().unwrap().to_vec1::().unwrap(); + assert!( + g.iter().all(|x| x.is_finite()), + "RaizSuavizada: gradiente deve ser finito no colapso" + ); + let mx = g.iter().fold(0f32, |a, &b| a.max(b.abs())); + assert!(mx < 1e-9, "gradiente no colapso = 0 exato (sela), máx = {mx}"); + // sela estrita: afastar reduz V + let v_de = |t: f64| -> f64 { + let dados: Vec = z + .iter() + .zip(&u) + .map(|(&zi, &ui)| zi + (t * ui as f64) as f32) + .collect(); + let ztt = Tensor::from_vec(dados, (8, 8), &dev).unwrap(); + nucleo.perda_vc(&ztt).unwrap().to_scalar::().unwrap() as f64 + }; + assert!( + v_de(0.1) < v_de(0.0), + "RaizSuavizada: V_ε deve cair ao afastar (sela estrita, não mínimo)" + ); + } + + #[test] + fn teste_j1d_softplus_nao_diferenciavel_em_z() { + // J-1′-iii (REFUTAÇÃO da correção proposta pela crítica): o + // softplus suaviza a dobradiça (que já era C¹) mas NÃO a raiz. + // As derivadas laterais de V w.r.t. z no colapso diferem por + // sinal ⇒ gradiente NÃO existe — a proposta não cumpre o que + // afirma ("garante diferenciabilidade em todo o domínio"). + let dev = Device::Cpu; + let mut nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap(); + nucleo.definir_modo_variancia(ModoVariancia::Softplus, 1e-12, 5.0); + let (z, u) = lote_e_direcao_j1(8, 8); + let v_de = |t: f64| -> f64 { + let dados: Vec = z + .iter() + .zip(&u) + .map(|(&zi, &ui)| zi + (t * ui as f64) as f32) + .collect(); + let zt = Tensor::from_vec(dados, (8, 8), &dev).unwrap(); + nucleo.perda_vc(&zt).unwrap().to_scalar::().unwrap() as f64 + }; + let t = 0.001; + // D⁺ = lim [V(t)−V(0)]/t ; D⁻ = lim [V(−t)−V(0)]/(−t) + let d_mais = (v_de(t) - v_de(0.0)) / t; + let d_menos = (v_de(-t) - v_de(0.0)) / (-t); + // constante teórica: C_sp = (2k·sp(kγ)·σ(kγ)/d)·Σs_j, γ=1, k=5, d=8, Σs=8 + let (k, g, d, ss) = (5.0f64, 1.0f64, 8.0f64, 8.0f64); + let sp = |x: f64| (1.0 + x.exp()).ln(); + let sg = 1.0 / (1.0 + (-k * g).exp()); + let c_sp = 2.0 * k * sp(k * g) * sg / d * ss; + assert!( + d_mais < -0.5 * c_sp && d_menos > 0.5 * c_sp, + "derivadas laterais devem divergir por sinal: D⁺={d_mais:.4}, \ + D⁻={d_menos:.4}, C_sp teórico={c_sp:.4} — softplus NÃO é \ + diferenciável em z no colapso" + ); + } + + #[test] + fn teste_j1e_compat_bit_a_bit_dobradica() { + // O default preserva o comportamento das versões anteriores: a + // Dobradica explícita produz o MESMO valor bit-a-bit que o caminho + // v0.9.0 (fórmula de referência recalculada aqui). + let dev = Device::Cpu; + let mut nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap(); + let mut rng = crate::rng::RngDeterministico::novo(77); + let dados: Vec = (0..8 * 8).map(|_| rng.normal(0.0, 1.0) as f32).collect(); + let z = Tensor::from_vec(dados.clone(), (8, 8), &dev).unwrap(); + nucleo.definir_modo_variancia(ModoVariancia::Dobradica, 1e-12, 5.0); + let bits = nucleo + .perda_vc(&z) + .unwrap() + .to_scalar::() + .unwrap() + .to_bits(); + // referência v0.9.0 recalculada de forma independente (f64): + // V = (1/d)Σ_j max(0,γ−std_j)² + ‖offdiag(Cov)‖²_F/(2d) + let gamma = 1.0f64; + let mut v_var = 0.0f64; + for j in 0..8 { + let media: f64 = (0..8).map(|i| dados[i * 8 + j] as f64).sum::() / 8.0; + let var: f64 = (0..8) + .map(|i| (dados[i * 8 + j] as f64 - media).powi(2)) + .sum::() + / 8.0; + v_var += (gamma - var.sqrt()).max(0.0).powi(2); + } + v_var /= 8.0; + let mut v_cov = 0.0f64; + for a in 0..8 { + for b in 0..8 { + if a != b { + let ma: f64 = (0..8).map(|i| dados[i * 8 + a] as f64).sum::() / 8.0; + let mb: f64 = (0..8).map(|i| dados[i * 8 + b] as f64).sum::() / 8.0; + let cab: f64 = (0..8) + .map(|i| (dados[i * 8 + a] as f64 - ma) * (dados[i * 8 + b] as f64 - mb)) + .sum::() + / 8.0; + v_cov += cab * cab; + } + } + } + v_cov /= 2.0 * 8.0; + let v_ref = v_var + v_cov; + let obtido = f32::from_bits(bits) as f64; + assert!( + (obtido - v_ref).abs() < 1e-5, + "Dobradica deve reproduzir a fórmula v0.9.0: {obtido} vs {v_ref}" + ); + } + #[test] fn teste_j2_ema_ponto_fixo() { // encoder congelado ⇒ após muitas passadas EMA, alvo = encoder diff --git a/src/jepa/mascaras.rs b/src/jepa/mascaras.rs deleted file mode 100644 index 1bd9e00efe855ed5a8e372e438df05fb862fcf5e..0000000000000000000000000000000000000000 --- a/src/jepa/mascaras.rs +++ /dev/null @@ -1,173 +0,0 @@ -//! `jepa::mascaras` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -// --------------------------------------------------------------------------- -// Parte 2 — máscaras -// --------------------------------------------------------------------------- - -/// Máscara de blocos 2D (Image-JEPA): grade (h, w) de patches; sorteia -/// `n_blocos` retângulos aleatórios com fração alvo `frac` de patches. -pub fn mascara_blocos_2d(h: usize, w: usize, n_blocos: usize, frac: f64, rng: &mut RngDeterministico) -> Vec { - let total = h * w; - let alvo = (total as f64 * frac) as usize; - let mut masc = vec![false; total]; - let mut coberto = 0usize; - for _ in 0..n_blocos.max(1) { - if coberto >= alvo { - break; - } - let bh = 1 + rng.inteiro(h.min(4)); - let bw = 1 + rng.inteiro(w.min(4)); - let y0 = rng.inteiro(h + 1 - bh); - let x0 = rng.inteiro(w + 1 - bw); - for y in y0..y0 + bh { - for x in x0..x0 + bw { - let i = y * w + x; - if !masc[i] { - masc[i] = true; - coberto += 1; - } - } - } - } - masc -} - -/// Máscara de tubos 3D (V-JEPA 2): grade (t, h, w); tubos = retângulos que -/// atravessam o tempo. -pub fn mascara_tubos_3d(t: usize, h: usize, w: usize, n_tubos: usize, frac: f64, rng: &mut RngDeterministico) -> Vec { - let total = t * h * w; - let alvo = (total as f64 * frac) as usize; - let mut masc = vec![false; total]; - let mut coberto = 0usize; - for _ in 0..n_tubos.max(1) { - if coberto >= alvo { - break; - } - let bh = 1 + rng.inteiro(h.min(3)); - let bw = 1 + rng.inteiro(w.min(3)); - let y0 = rng.inteiro(h + 1 - bh); - let x0 = rng.inteiro(w + 1 - bw); - for tt in 0..t { - for y in y0..y0 + bh { - for x in x0..x0 + bw { - let i = (tt * h + y) * w + x; - if !masc[i] { - masc[i] = true; - coberto += 1; - } - } - } - } - } - masc -} - -/// Máscara de bandas (Audio-JEPA): grade (f, tau) — bandas de frequência -/// horizontais com extensão temporal. -pub fn mascara_bandas(f: usize, tau: usize, n_bandas: usize, frac: f64, rng: &mut RngDeterministico) -> Vec { - mascara_blocos_2d(f, tau, n_bandas, frac, rng) // blocos na grade (f, tau) -} - -/// Máscara de blocos 3D (3D-JEPA): grade (x, y, z) de voxels. -pub fn mascara_blocos_3d(x: usize, y: usize, z: usize, n_blocos: usize, frac: f64, rng: &mut RngDeterministico) -> Vec { - mascara_tubos_3d(x, y, z, n_blocos, frac, rng) -} - -/// Máscara de segmentos canal×tempo (Brain-JEPA): canais inteiros OU -/// janelas temporais (aleatório por chamada). -pub fn mascara_segmentos(c: usize, t: usize, frac: f64, rng: &mut RngDeterministico) -> Vec { - let total = c * t; - let alvo = (total as f64 * frac) as usize; - let mut masc = vec![false; total]; - if rng.inteiro(2) == 0 { - // canais inteiros - let mut coberto = 0; - let mut canais: Vec = (0..c).collect(); - // embaralhar - for i in (1..canais.len()).rev() { - let j = rng.inteiro(i + 1); - canais.swap(i, j); - } - for &ch in canais.iter() { - if coberto >= alvo { - break; - } - for tt in 0..t { - masc[ch * t + tt] = true; - coberto += 1; - } - } - } else { - // janelas temporais - let mut coberto = 0; - let mut t0 = 0; - while coberto < alvo && t0 < t { - let len = 1 + rng.inteiro((t / 4).max(1)); - for ch in 0..c { - for tt in t0..(t0 + len).min(t) { - masc[ch * t + tt] = true; - coberto += 1; - } - } - t0 += len + 1; - } - } - masc -} - -/// Máscara 1D (T-JEPA): intervalos contíguos em n posições. -pub fn mascara_intervalos_1d(n: usize, frac: f64, rng: &mut RngDeterministico) -> Vec { - let alvo = (n as f64 * frac) as usize; - let mut masc = vec![false; n]; - let mut coberto = 0; - while coberto < alvo { - let len = 1 + rng.inteiro((n / 8).max(1)); - let i0 = rng.inteiro(n); - for i in i0..(i0 + len).min(n) { - if !masc[i] { - masc[i] = true; - coberto += 1; - } - } - } - masc -} - -/// Amostragem dos pontos mais distantes (FPS) para Point-JEPA. -pub fn pontos_mais_distantes(pontos: &[Vec], k: usize, rng: &mut RngDeterministico) -> Vec { - let n = pontos.len(); - if n == 0 || k == 0 { - return vec![]; - } - let k = k.min(n); - let mut centros = vec![rng.inteiro(n)]; - let mut dist_min: Vec = pontos - .iter() - .map(|p| distancia_eucl(p, &pontos[centros[0]])) - .collect(); - while centros.len() < k { - let prox = dist_min - .iter() - .enumerate() - .filter(|(i, _)| !centros.contains(i)) - .max_by(|a, b| a.1.partial_cmp(b.1).unwrap()) - .map(|(i, _)| i) - .unwrap_or(0); - centros.push(prox); - for (i, p) in pontos.iter().enumerate() { - let d = distancia_eucl(p, &pontos[prox]); - if d < dist_min[i] { - dist_min[i] = d; - } - } - } - centros -} - -pub(crate) fn distancia_eucl(a: &[f64], b: &[f64]) -> f64 { - a.iter().zip(b).map(|(x, y)| (x - y) * (x - y)).sum::().sqrt() -} diff --git a/src/jepa/mod.rs b/src/jepa/mod.rs deleted file mode 100644 index e68e71515d2b10af3e0c2d7d6a47a7e3a9fb8dd7..0000000000000000000000000000000000000000 --- a/src/jepa/mod.rs +++ /dev/null @@ -1,61 +0,0 @@ -//! Suíte JEPA — módulos: núcleo, máscaras, patches, variantes, -//! SonicMoE, ReplaySSM (divisão SRP v0.10.0 — r-35 §2). - -//! Suíte JEPA v0.5.0 — núcleo unificado + 12 variantes + SonicMoE + ReplaySSM. -//! -//! **Núcleo (todas as variantes compartilham):** -//! - codificador `E_θ` (MLp SiLU), preditor `P_φ` (condicionado por posição/ -//! ação/edição), codificador-alvo EMA `E_ξ` com `ξ ← m·ξ + (1−m)·θ` -//! (gradiente cortado — alvo nunca recebe gradiente); -//! - regularizador variância-covariância (VICReg-lite) anti-colapso: -//! `V(z) = Σ_j max(0, γ − std(z_j))²` + fora-diagonal da covariância. -//! - perda: `L = Σ_b ‖P(z_ctx, pos_b) − sg(ẑ_b)‖²/B + λ_vc·V`. -//! -//! **Prova J-1 (impossibilidade de colapso, em r-20):** se todas as -//! incorporações colapsam para constante, `std(z_j) = 0 ∀j` ⇒ `V = d·γ² > 0`; -//! logo o colapso total NÃO é minimizador com `λ_vc > 0`. -//! -//! **Prova J-2 (EMA = stop-grad + ponto fixo):** `∂L/∂ξ = 0` (detach); se -//! `θ_t → θ*` então `ξ_t → θ*` (recursão linear contratante com `m < 1`). -//! -//! **Prova J-3 (decomposição de informação):** com `P` suficientemente -//! rico, `min_P L = Σ_b Var(ẑ_b | z_ctx)` — a perda retém só o componentes -//! previsíveis do alvo dado o contexto. -//! -//! **Variantes** (esquema de máscara + adaptador de modalidade): -//! Image-JEPA (blocos 2D) · V-JEPA 2 (tubos 3D + cond. de ação) · MC-JEPA -//! (cruz-modal, dois codificadores) · Audio-JEPA (bandas de espectrograma) · -//! Point-JEPA (grupos FPS) · 3D-JEPA (voxels) · Brain-JEPA (canal×tempo) · -//! T-JEPA (série temporal canal-independente) · LeJEPA (edição-condicionado) · -//! BJEPA (bidirecional com consistência de ciclo). -//! -//! **SonicMoE** — MoE com roteamento top-k, capacidade por especialista -//! (tile-aware) e perda auxiliar de balanceamento (argumento Switch: -//! `L_aux = E·Σ f_e·p_e ≥ 1` com igualdade sse uniforme). -//! -//! **ReplaySSM** — SSM de porta diagonal (`h_t = σ(a)⊙h_{t−1} + -//! (1−σ(a))⊙(Bx_t)`, estabilidade herdada do Teo S-2') + replay de experiências -//! para aprendizado continuado (interpolação de gradientes limita o -//! esquecimento — Teo R-1). - -use candle_core::{Device, Result, Tensor, Var}; -use crate::camadas::Linear; -use crate::rng::RngDeterministico; - -// ---- divisão SRP v0.10.0 (r-35 §2): submódulos + re-exports ---- -#[cfg(test)] -mod testes; -mod mascaras; -mod nucleo; -mod patches; -mod replay_ssm; -mod sonic_moe; -mod variantes; - -pub use mascaras::*; -pub use nucleo::*; -pub use patches::*; -pub use replay_ssm::*; -pub use sonic_moe::*; -pub use variantes::*; - diff --git a/src/jepa/nucleo.rs b/src/jepa/nucleo.rs deleted file mode 100644 index 6f481d3bd1336632adcc037e7b78ada79524bfc9..0000000000000000000000000000000000000000 --- a/src/jepa/nucleo.rs +++ /dev/null @@ -1,211 +0,0 @@ -//! `jepa::nucleo` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -// --------------------------------------------------------------------------- -// Parte 1 — núcleo -// --------------------------------------------------------------------------- - -/// MLP 2 camadas com SiLU (d → h → d_saida). -pub struct MlpJepa { - pub l1: Linear, - pub l2: Linear, - pub d_entrada: usize, - pub d_saida: usize, -} - -impl MlpJepa { - pub fn novo(d_entrada: usize, d_oculta: usize, d_saida: usize, dev: &Device) -> Result { - let s1 = (1.0 / (d_entrada as f64).sqrt()) * 0.9; - let s2 = (1.0 / (d_oculta as f64).sqrt()) * 0.9; - Ok(Self { - l1: Linear::sem_vies(d_entrada, d_oculta, s1, dev)?, - l2: Linear::sem_vies(d_oculta, d_saida, s2, dev)?, - d_entrada, - d_saida, - }) - } - - pub fn fwd(&self, x: &Tensor) -> Result { - let h = candle_nn::ops::silu(&self.l1.fwd(x)?)?; - self.l2.fwd(&h) - } - - pub fn vars(&self) -> Vec { - [self.l1.vars(), self.l2.vars()].concat() - } - - /// EMA: `self ← m·self + (1−m)·outro` (usado no codificador-alvo). - pub fn ema_de(&mut self, outro: &MlpJepa, m: f64) -> Result<()> { - for (a, b) in self.vars().iter().zip(outro.vars().iter()) { - let novo = (a.as_tensor().affine(m, 0.0)? + b.as_tensor().affine(1.0 - m, 0.0)?)?; - a.set(&novo)?; - } - Ok(()) - } -} - -/// Núcleo JEPA: codificador + preditor + alvo EMA + regularizador VC. -pub struct NucleoJepa { - pub encoder: MlpJepa, - pub preditor: MlpJepa, - pub alvo: MlpJepa, - /// tabela de posições (blocos) — entrada extra do preditor. - pub pos: Var, - pub d_emb: usize, - pub d_cond: usize, - pub m: f64, - pub lambda_vc: f64, - pub gamma_vc: f64, -} - -impl NucleoJepa { - pub fn novo( - d_patch: usize, - d_emb: usize, - d_cond: usize, - n_pos: usize, - m: f64, - lambda_vc: f64, - gamma_vc: f64, - dev: &Device, - ) -> Result { - let encoder = MlpJepa::novo(d_patch, 2 * d_emb, d_emb, dev)?; - let preditor = MlpJepa::novo(d_emb + d_cond + d_emb, 2 * d_emb, d_emb, dev)?; - // alvo nasce IGUAL ao encoder (ponto de partida do EMA) - let mut alvo = MlpJepa::novo(d_patch, 2 * d_emb, d_emb, dev)?; - for (va, vb) in alvo.vars().iter().zip(encoder.vars().iter()) { - va.set(vb.as_tensor())?; - } - let pos_t = Tensor::randn(0f32, 0.02, (n_pos.max(1), d_emb), dev)?; - Ok(Self { - encoder, - preditor, - alvo, - pos: Var::from_tensor(&pos_t)?, - d_emb, - d_cond, - m, - lambda_vc, - gamma_vc, - }) - } - - pub fn vars(&self) -> Vec { - let mut v = self.encoder.vars(); - v.extend(self.preditor.vars()); - v.push(self.pos.clone()); - v // NOTA: alvo NÃO entra — é buffer EMA - } - - pub fn ema_passo(&mut self) -> Result<()> { - self.alvo.ema_de(&self.encoder, self.m) - } - - /// Codifica um conjunto de patches (n, d_patch) → (n, d_emb). - pub fn codificar(&self, patches: &Tensor) -> Result { - self.encoder.fwd(patches) - } - - /// Codifica com o alvo EMA — SEM gradiente (detach por construção: as - /// vars do alvo não estão no otimizador e o tensor é desconectado). - pub fn alvo_codificar(&self, patches: &Tensor) -> Result { - Ok(self.alvo.fwd(patches)?.detach()) - } - - /// Prediz o embedding do bloco `i_pos` a partir do contexto `z_ctx` - /// (d_emb) e da condição `cond` (d_cond; zeros se None). - pub fn predizer(&self, z_ctx: &Tensor, i_pos: usize, cond: Option<&Tensor>) -> Result { - // z_ctx: (b, d_emb) ou (d_emb,) - let b = z_ctx.dim(0).unwrap_or(1); - let dev = z_ctx.device(); - let pos = self.pos.as_tensor().get(i_pos.min(self.pos.dim(0)?.saturating_sub(1)))?; - let pos_b = pos.broadcast_as((b, self.d_emb))?; - let cond_b = match cond { - Some(c) => { - if c.dims().len() == 1 && b > 1 { - c.broadcast_as((b, self.d_cond))? - } else { - c.clone() - } - } - None => Tensor::zeros((b, self.d_cond), candle_core::DType::F32, dev)?, - }; - let entrada = Tensor::cat(&[z_ctx, &pos_b, &cond_b], candle_core::D::Minus1)?; - self.preditor.fwd(&entrada) - } - - /// Regularizador variância-covariância do lote de incorporações z (n, d). - /// - /// **J-1:** no colapso total `z_i = c ∀i` ⇒ `std_j = 0` ⇒ `V = d·γ²`. - pub fn perda_vc(&self, z: &Tensor) -> Result { - let n = z.dim(0)? as f64; - let d = self.d_emb; - let media = z.mean_keepdim(0)?; // (1, d) - let centr = z.broadcast_sub(&media)?; - let var = (centr.sqr()?.sum(0)? / n)?; // (d,) - let std = var.sqrt()?; - // dobradiça: max(0, γ − std)² - let gamma_t = - Tensor::new(self.gamma_vc as f32, z.device())?.broadcast_as(std.dims())?; - let gap = gamma_t.broadcast_sub(&std)?.clamp(0.0, f64::INFINITY)?; - let v = gap.sqr()?.sum_all()?; - // covariância fora-diagonal: C = centrᵀ·centr/n; perda = ‖C − diag‖²_F/(2d) - let cov = (centr.transpose(0, 1)?.matmul(¢r)? / n)?; // (d, d) - let mask_diag = { - let mut m = vec![0f32; d * d]; - for i in 0..d { - m[i * d + i] = 1.0; - } - Tensor::from_vec(m, (d, d), z.device())? - }; - let fora = ((&cov * &mask_diag)?.sqr()?.sum_all()? / (2.0 * d.max(1) as f64))?; - let v_norm = (v / d.max(1) as f64)?; - Ok((v_norm + fora)?) - } - - /// Perda JEPA padrão para UM lote: contexto (número variável de patches), - /// lista de blocos-alvo (posições), condição opcional. - /// - /// `z_ctx` = incorporação agregada do contexto (b, d_emb); - /// `alvos`: para cada elemento do lote, Vec<(i_pos, patches_alvo)>. - pub fn perda_lote( - &self, - z_ctx: &Tensor, - alvos: &[Vec<(usize, Tensor)>], - cond: Option<&Tensor>, - z_ctx_todos: &Tensor, - ) -> Result<(Tensor, f64, f64)> { - let b = z_ctx.dim(0)?; - let dev = z_ctx.device(); - let mut perdas: Vec = Vec::new(); - let mut n_alvos = 0usize; - for (i, blocos) in alvos.iter().enumerate() { - for (i_pos, patches_alvo) in blocos { - // ẑ_b = média das incorporações-alvo dos patches do bloco - let zt = self.alvo_codificar(patches_alvo)?; // (m, d_emb) - let zt_m = zt.mean(0)?; // (d_emb,) - let zt_b = zt_m.broadcast_as((1, self.d_emb))?; - let zc = z_ctx.get(i)?.broadcast_as((1, self.d_emb))?; - let c_i = cond.map(|c| c.get(i)?.broadcast_as((1, self.d_cond))).transpose()?; - let pred = self.predizer(&zc, *i_pos, c_i.as_ref())?; - let dif = (&pred - &zt_b)?; - let l = (dif.sqr()?.sum_all()? / self.d_emb as f64)?; - perdas.push(l); - n_alvos += 1; - } - } - let l_pred = if perdas.is_empty() { - Tensor::zeros((), candle_core::DType::F32, &dev)? - } else { - (Tensor::stack(&perdas, 0)?.sum_all()? / n_alvos.max(1) as f64)? - }; - let l_vc = self.perda_vc(z_ctx_todos)?; - let total = (l_pred.affine(1.0, 0.0)? + l_vc.affine(self.lambda_vc, 0.0)?)?; - let lp = l_pred.to_scalar::()? as f64; - let lv = l_vc.to_scalar::()? as f64; - Ok((total, lp, lv)) - } -} diff --git a/src/jepa/patches.rs b/src/jepa/patches.rs deleted file mode 100644 index 88daf2ca5642a866ed102a0a20d9ba4cac61f243..0000000000000000000000000000000000000000 --- a/src/jepa/patches.rs +++ /dev/null @@ -1,150 +0,0 @@ -//! `jepa::patches` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -// --------------------------------------------------------------------------- -// Parte 3 — adaptadores de modalidade -// --------------------------------------------------------------------------- - -/// (C, H, W) → patches (H/ph · W/pw, C·ph·pw) — Image-JEPA. -pub fn em_patches_2d(img: &Tensor, ph: usize, pw: usize) -> Result { - let (c, h, w) = (img.dim(0)?, img.dim(1)?, img.dim(2)?); - let dev = img.device(); - let mut linhas: Vec = Vec::new(); - for y in (0..h).step_by(ph) { - for x in (0..w).step_by(pw) { - let hh = ph.min(h - y); - let ww = pw.min(w - x); - let patch = img.narrow(0, 0, c)?.narrow(1, y, hh)?.narrow(2, x, ww)?; - // padding para (C, ph, pw) se borda - let patch = if hh < ph || ww < pw { - let mut buf = patch.flatten_all()?.to_vec1::()?; - let falta = c * ph * pw - buf.len(); - buf.extend(std::iter::repeat(0f32).take(falta)); - Tensor::from_vec(buf, (c * ph * pw,), &dev)? - } else { - patch.flatten_all()? - }; - linhas.push(patch); - } - } - Ok(Tensor::stack(&linhas, 0)?) -} - -/// (T, H, W) → tubos (T/pt · H/ph · W/pw, pt·ph·pw) — V-JEPA 2. -pub fn em_tubos_3d(vid: &Tensor, pt: usize, ph: usize, pw: usize) -> Result { - let (t, h, w) = (vid.dim(0)?, vid.dim(1)?, vid.dim(2)?); - let dev = vid.device(); - let mut linhas: Vec = Vec::new(); - for tt in (0..t).step_by(pt) { - let tl = pt.min(t - tt); - for y in (0..h).step_by(ph) { - for x in (0..w).step_by(pw) { - let hh = ph.min(h - y); - let ww = pw.min(w - x); - let tubo = vid - .narrow(0, tt, tl)? - .narrow(1, y, hh)? - .narrow(2, x, ww)? - .flatten_all()?; - let mut buf = tubo.to_vec1::()?; - let falta = pt * ph * pw - buf.len(); - buf.extend(std::iter::repeat(0f32).take(falta)); - linhas.push(Tensor::from_vec(buf, (pt * ph * pw,), &dev)?); - } - } - } - Ok(Tensor::stack(&linhas, 0)?) -} - -/// (F, τ) → patches (F/pf · τ/pt, pf·pt) — Audio-JEPA. -pub fn em_patches_espectrograma(spec: &Tensor, pf: usize, pt: usize) -> Result { - let (f, tau) = (spec.dim(0)?, spec.dim(1)?); - let dev = spec.device(); - let mut linhas: Vec = Vec::new(); - for i in (0..f).step_by(pf) { - for j in (0..tau).step_by(pt) { - let ff = pf.min(f - i); - let tt = pt.min(tau - j); - let p = spec.narrow(0, i, ff)?.narrow(1, j, tt)?.flatten_all()?; - let mut buf = p.to_vec1::()?; - let falta = pf * pt - buf.len(); - buf.extend(std::iter::repeat(0f32).take(falta)); - linhas.push(Tensor::from_vec(buf, (pf * pt,), &dev)?); - } - } - Ok(Tensor::stack(&linhas, 0)?) -} - -/// (C, T) → patches canal-independentes (C · T/pt, pt) — T-JEPA/Brain-JEPA. -pub fn em_patches_serie(ts: &Tensor, pt: usize) -> Result { - let (c, t) = (ts.dim(0)?, ts.dim(1)?); - let dev = ts.device(); - let mut linhas: Vec = Vec::new(); - for ch in 0..c { - for j in (0..t).step_by(pt) { - let tt = pt.min(t - j); - let p = ts.narrow(0, ch, 1)?.narrow(1, j, tt)?.flatten_all()?; - let mut buf = p.to_vec1::()?; - let falta = pt - buf.len(); - buf.extend(std::iter::repeat(0f32).take(falta)); - linhas.push(Tensor::from_vec(buf, (pt,), &dev)?); - } - } - Ok(Tensor::stack(&linhas, 0)?) -} - -/// (X, Y, Z) → voxels (X/px · Y/py · Z/pz, px·py·pz) — 3D-JEPA. -pub fn em_voxels(vol: &Tensor, px: usize, py: usize, pz: usize) -> Result { - let (x, y, z) = (vol.dim(0)?, vol.dim(1)?, vol.dim(2)?); - let dev = vol.device(); - let mut linhas: Vec = Vec::new(); - for i in (0..x).step_by(px) { - for j in (0..y).step_by(py) { - for k in (0..z).step_by(pz) { - let lx = px.min(x - i); - let ly = py.min(y - j); - let lz = pz.min(z - k); - let p = vol.narrow(0, i, lx)?.narrow(1, j, ly)?.narrow(2, k, lz)?.flatten_all()?; - let mut buf = p.to_vec1::()?; - let falta = px * py * pz - buf.len(); - buf.extend(std::iter::repeat(0f32).take(falta)); - linhas.push(Tensor::from_vec(buf, (px * py * pz,), &dev)?); - } - } - } - Ok(Tensor::stack(&linhas, 0)?) -} - -/// Nuvem de pontos (n, d) → grupos FPS (k, m·d): k centros por FPS, cada -/// grupo = os m vizinhos mais próximos do centro (concatenados) — Point-JEPA. -pub fn em_grupos_pontos(pc: &Tensor, k: usize, m: usize, rng: &mut RngDeterministico) -> Result { - let n = pc.dim(0)?; - let d = pc.dim(1)?; - let coords = pc.to_vec2::()?; - let coords_f: Vec> = coords.iter().map(|r| r.iter().map(|&v| v as f64).collect()).collect(); - let centros = pontos_mais_distantes(&coords_f, k, rng); - let dev = pc.device(); - let mut linhas: Vec = Vec::new(); - for &ci in ¢ros { - // m vizinhos mais próximos do centro ci (incluindo ele próprio) - let mut ord: Vec = (0..n).collect(); - ord.sort_by(|&a, &b| { - let da = distancia_eucl(&coords_f[a], &coords_f[ci]); - let db = distancia_eucl(&coords_f[b], &coords_f[ci]); - da.partial_cmp(&db).unwrap() - }); - let mut buf: Vec = Vec::with_capacity(m * d); - for &idx in ord.iter().take(m) { - for j in 0..d { - buf.push(coords[idx][j]); - } - } - let falta = m * d - buf.len(); - buf.extend(std::iter::repeat(0f32).take(falta)); - linhas.push(Tensor::from_vec(buf, (m * d,), &dev)?); - } - Ok(Tensor::stack(&linhas, 0)?) -} diff --git a/src/jepa/replay_ssm.rs b/src/jepa/replay_ssm.rs deleted file mode 100644 index 324dbbd246af49e29c05f922ed567d9e82616272..0000000000000000000000000000000000000000 --- a/src/jepa/replay_ssm.rs +++ /dev/null @@ -1,107 +0,0 @@ -//! `jepa::replay_ssm` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -// --------------------------------------------------------------------------- -// Parte 6 — ReplaySSM -// --------------------------------------------------------------------------- - -/// SSM de porta diagonal com replay para aprendizado continuado. -/// -/// Recorrência: `h_t = σ(a) ⊙ h_{t−1} + (1 − σ(a)) ⊙ (B x_t)`. -/// -/// **Prova R-1 (estabilidade):** `|σ(a)| < 1` ⇒ perturbações de `h_0` -/// decaem geometricamente (mesma estrutura do Teo S-2' do SSD-Δ). -/// -/// **Prova R-2 (limite de esquecimento):** o passo de treino mistura -/// gradientes `(1−α)·∇L_novo + α·∇L_replay`; para `L_antiga` μ-fortemente -/// convexa com gradientes novos limitados por `G`, o afastamento do ótimo -/// antigo por passo é `≤ (1−α)·η·G` (sem replay: `≤ η·G`) — o replay -/// contrai o drift por um fator `1/(1−α)` no regime linear. -pub struct ReplaySsm { - pub a: Var, // (d,) — porta (sigmoid no uso) - pub b: Var, // (d_in, d) — projeção de entrada - pub d: usize, - pub alpha_replay: f64, - pub buffer: Vec, - pub capacidade_buffer: usize, -} - -impl ReplaySsm { - pub fn novo(d_in: usize, d: usize, alpha_replay: f64, capacidade_buffer: usize, dev: &Device) -> Result { - let a_t = Tensor::randn(0f32, 0.5, (d,), dev)?; - let b_t = Tensor::randn(0f32, 0.1, (d_in, d), dev)?; - Ok(Self { - a: Var::from_tensor(&a_t)?, - b: Var::from_tensor(&b_t)?, - d, - alpha_replay, - buffer: Vec::new(), - capacidade_buffer, - }) - } - - pub fn vars(&self) -> Vec { - vec![self.a.clone(), self.b.clone()] - } - - /// Scan: x (T, d_in) → h (T, d). Diferenciável (candle autograd). - pub fn scan(&self, x: &Tensor) -> Result { - let t = x.dim(0)?; - let dev = x.device(); - let porta = candle_nn::ops::sigmoid(&self.a.as_tensor().broadcast_as((1, self.d))?)?; // (1, d) - let um_menos = porta.affine(-1.0, 1.0)?; // 1 − σ(a) - let entrada = x.matmul(&self.b.as_tensor())?; // (T, d) - let mut h = Tensor::zeros((1, self.d), candle_core::DType::F32, &dev)?; - let mut saidas: Vec = Vec::with_capacity(t); - for i in 0..t { - let xt = entrada.narrow(0, i, 1)?; - h = ((&porta * &h)? + (&um_menos * &xt)?)?; - saidas.push(h.clone()); - } - Ok(Tensor::stack(&saidas, 0)?) - } - - /// Empurra uma janela de treino no buffer (FIFO). - pub fn guardar(&mut self, x: &Tensor) { - if self.buffer.len() >= self.capacidade_buffer { - self.buffer.remove(0); - } - self.buffer.push(x.detach()); - } - - /// Um passo de treino no lote novo (com mistura de replay). - /// Devolve (perda_total, perda_novo, perda_replay). - pub fn passo_treino( - &mut self, - x: &Tensor, - alvo: &Tensor, - otimizador: &mut crate::treino::AdamWManual, - ) -> Result<(f64, f64, f64)> { - // perda nova - let h = self.scan(x)?; - let dif = (&h - alvo)?; - let perda_novo = dif.sqr()?.mean_all()?; - // replay - let mut perda_total = perda_novo.clone(); - let mut p_r = 0.0; - if !self.buffer.is_empty() { - let idx = self.buffer.len() - 1; - let antigo = self.buffer[idx].clone(); - let hr = self.scan(&antigo)?; - // alvo do replay: manter a dinâmica aprendida estável (magnitudes - // finitas) — auto-supervisão de estabilidade - let dr = hr.sqr()?.mean_all()?; - perda_total = (perda_total.affine(1.0 - self.alpha_replay, 0.0)? - + dr.affine(self.alpha_replay, 0.0)?)?; - p_r = dr.to_scalar::()? as f64; - } - let pn = perda_novo.to_scalar::()? as f64; - otimizador.passo(crate::treino::grads_achatados(&perda_total, &self.vars())?); - self.guardar(x); - let pt = perda_total.to_scalar::()? as f64; - Ok((pt, pn, p_r)) - } -} diff --git a/src/jepa/sonic_moe.rs b/src/jepa/sonic_moe.rs deleted file mode 100644 index eb9d3e2e90bdac1e23e4a34dfd5ba2ceca80b6fa..0000000000000000000000000000000000000000 --- a/src/jepa/sonic_moe.rs +++ /dev/null @@ -1,155 +0,0 @@ -//! `jepa::sonic_moe` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -// --------------------------------------------------------------------------- -// Parte 5 — SonicMoE (IO/tile-aware) -// --------------------------------------------------------------------------- - -/// MoE top-k com capacidade por especialista e perda de balanceamento. -/// -/// **Prova SM-1 (limite de capacidade):** o roteamento tile-aware mantém no -/// máximo `C` tokens por especialista por ladrilho — o drop é determinístico -/// (ordem de chegada) e o nº de tokens descartados é `Σ_e max(0, load_e − C)`. -/// -/// **Prova SM-2 (balanceamento):** `L_aux = E·Σ_e f_e·p_e`; com roteamento -/// auto-consistente (`f = p`), `L_aux = E·Σ p_e² ≥ 1` com igualdade sse -/// `p_e = 1/E` (Cauchy–Schchwarz) — o mínimo força o roteador uniforme. -pub struct SonicMoe { - pub roteador: Linear, // d → E - pub especialistas: Vec, // E experts d → d - pub n_top: usize, - pub capacidade: usize, - pub lambda_aux: f64, -} - -pub struct SaidaMoe { - pub saida: Tensor, - pub perda_aux: Tensor, - pub carga: Vec, // tokens efetivamente processados por especialista - pub descartados: usize, // tokens com especialistas cortados pela capacidade -} - -impl SonicMoe { - pub fn novo(d: usize, n_expertos: usize, n_top: usize, capacidade: usize, dev: &Device) -> Result { - let roteador = Linear::sem_vies(d, n_expertos, 0.1, dev)?; - let especialistas = (0..n_expertos) - .map(|_| MlpJepa::novo(d, 2 * d, d, dev)) - .collect::>>()?; - Ok(Self { roteador, especialistas, n_top, capacidade, lambda_aux: 0.01 }) - } - - pub fn vars(&self) -> Vec { - let mut v = self.roteador.vars(); - for e in &self.especialistas { - v.extend(e.vars()); - } - v - } - - /// Forward tile-aware: (n, d) → (n, d). - pub fn fwd(&self, x: &Tensor) -> Result { - let n = x.dim(0)?; - let d = x.dim(1)?; - let e = self.especialistas.len(); - let dev = x.device(); - let logits = self.roteador.fwd(x)?; // (n, E) - let probs = candle_nn::ops::softmax(&logits, candle_core::D::Minus1)?; - - // top-k por token (não diferenciável — pesos do top-k são dif. via probs) - let probs_v = probs.to_vec2::()?; - let mut carga = vec![0usize; e]; - let mut descartados = 0usize; - // acumulador de saída (n, d) — construído por soma de contribuições - let mut saida = Tensor::zeros((n, d), candle_core::DType::F32, &dev)?; - let mut peso_total = Tensor::zeros((n, 1), candle_core::DType::F32, &dev)?; - // por especialista (tile): tokens cujo top-k contém e e com carga < C - for ei in 0..e { - // candidatos: tokens ordenados por prob do especialista ei - let mut cand: Vec<(usize, f32)> = (0..n) - .map(|i| (i, probs_v[i][ei])) - .collect(); - cand.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); - let mut escolhidos: Vec = Vec::new(); - for (i, _) in cand { - if carga[ei] >= self.capacidade { - break; - } - // verifica se ei está no top-k do token i - let mut ordem: Vec<(f32, usize)> = - (0..e).map(|k| (probs_v[i][k], k)).collect(); - ordem.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap()); - let top: Vec = ordem.iter().rev().take(self.n_top).map(|(_, k)| *k).collect(); - if top.contains(&ei) { - escolhidos.push(i); - carga[ei] += 1; - } - } - if escolhidos.is_empty() { - continue; - } - // tile do especialista: uma única passagem em lote - let idx: Vec = escolhidos.iter().map(|&i| i as u32).collect(); - let n_e = idx.len(); - let idx_t = Tensor::from_vec(idx, (n_e,), &dev)?; - let tile = x.index_select(&idx_t, 0)?; - let y = self.especialistas[ei].fwd(&tile)?; // (m, d) - // pesos: prob do especialista ei para cada token escolhido - let w: Vec = escolhidos.iter().map(|&i| probs_v[i][ei]).collect(); - let n_w = escolhidos.len(); - let w_t = Tensor::from_vec(w.clone(), (n_w, 1), &dev)?; - let contrib = y.broadcast_mul(&w_t)?; - // scatter-add: acumula nas posições - let mut buf = saida.to_vec2::()?; - let contrib_v = contrib.to_vec2::()?; - for (k, &i) in escolhidos.iter().enumerate() { - for j in 0..d { - buf[i][j] += contrib_v[k][j]; - } - } - saida = Tensor::from_vec( - buf.into_iter().flatten().collect::>(), - (n, d), - &dev, - )?; - let mut pt = peso_total.to_vec2::()?; - for (k, &i) in escolhidos.iter().enumerate() { - pt[i][0] += w[k]; - } - peso_total = Tensor::from_vec( - pt.into_iter().flatten().collect::>(), - (n, 1), - &dev, - )?; - } - // tokens sem especialista (todos cortados) → descartados; saída 0 - let pt_v = peso_total.to_vec2::()?; - for i in 0..n { - if pt_v[i][0] == 0.0 { - descartados += 1; - } - } - // renormaliza pelo peso efetivo (evita viés da capacidade) - let denom = peso_total.clamp(1e-6, f64::INFINITY)?; - let saida = saida.broadcast_div(&denom)?; - - // perda auxiliar: E·Σ f_e·p_e (f = fração de tokens cujo top-1 é e) - let mut f = vec![0f32; e]; - for i in 0..n { - let (mut melhor, mut mp) = (0usize, f32::NEG_INFINITY); - for k in 0..e { - if probs_v[i][k] > mp { - mp = probs_v[i][k]; - melhor = k; - } - } - f[melhor] += 1.0 / n as f32; - } - let f_t = Tensor::from_vec(f, (e,), &dev)?; - let p_media = probs.mean(0)?; // (E,) - let perda_aux = ((&f_t * &p_media)?.sum_all()? * (e as f64))?; - Ok(SaidaMoe { saida, perda_aux, carga, descartados }) - } -} diff --git a/src/jepa/testes.rs b/src/jepa/testes.rs deleted file mode 100644 index 812ba8b775611be7452fe2caf10ad5da14400b18..0000000000000000000000000000000000000000 --- a/src/jepa/testes.rs +++ /dev/null @@ -1,212 +0,0 @@ -//! `jepa::testes` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -#[cfg(test)] -mod testes { - use super::*; - - fn tensor_2d(dados: &[Vec], dev: &Device) -> Tensor { - let flat: Vec = dados.iter().flat_map(|v| v.iter().map(|&x| x as f32)).collect(); - Tensor::from_vec(flat, (dados.len(), dados[0].len()), dev).unwrap() - } - - #[test] - fn teste_mascaras_validas() { - // fração respeitada ±, particionamento contexto/alvo não-vazio - let mut rng = RngDeterministico::novo(1); - let m2 = mascara_blocos_2d(8, 8, 4, 0.3, &mut rng); - assert_eq!(m2.len(), 64); - let frac = m2.iter().filter(|&&b| b).count() as f64 / 64.0; - assert!(frac >= 0.15 && frac <= 0.55, "frac 2d = {frac}"); - assert!(m2.iter().any(|&b| !b), "contexto vazio"); - - let m3 = mascara_tubos_3d(4, 6, 6, 3, 0.3, &mut rng); - assert_eq!(m3.len(), 144); - let f3 = m3.iter().filter(|&&b| b).count() as f64 / 144.0; - assert!(f3 >= 0.15 && f3 <= 0.6, "frac 3d = {f3}"); - - let ms = mascara_segmentos(4, 32, 0.25, &mut rng); - assert_eq!(ms.len(), 128); - assert!(ms.iter().any(|&b| b) && ms.iter().any(|&b| !b)); - - let m1 = mascara_intervalos_1d(64, 0.3, &mut rng); - let f1 = m1.iter().filter(|&&b| b).count() as f64 / 64.0; - assert!(f1 >= 0.25 && f1 <= 0.45, "frac 1d = {f1}"); - } - - #[test] - fn teste_fps_cobre() { - let mut rng = RngDeterministico::novo(2); - let pontos: Vec> = (0..40) - .map(|i| { - let a = i as f64 * 0.1; - vec![a.cos() * 3.0, a.sin() * 3.0, (i % 7) as f64 * 0.3] - }) - .collect(); - let centros = pontos_mais_distantes(&pontos, 6, &mut rng); - assert_eq!(centros.len(), 6); - // centros distintos - let mut s = centros.clone(); - s.sort(); - s.dedup(); - assert_eq!(s.len(), 6); - } - - #[test] - fn teste_j1_colapso_impossivel() { - // No colapso total (z constante), a perda VC = γ² > 0 — verificando a - // fórmula implementada com um lote constante. - let dev = Device::Cpu; - let nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap(); - let z = Tensor::from_vec(vec![0.5f32; 8 * 8], (8, 8), &dev).unwrap(); - let lvc = nucleo.perda_vc(&z).unwrap(); - let v = lvc.to_scalar::().unwrap() as f64; - // std=0 ⇒ dobradiça = γ = 1 ⇒ V/d = 1; cov = 0 - assert!(v > 0.9, "perda VC no colapso = {v} (deveria ser ~1)"); - } - - #[test] - fn teste_j2_ema_ponto_fixo() { - // encoder congelado ⇒ após muitas passadas EMA, alvo = encoder - let dev = Device::Cpu; - let mut nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.5, 0.1, 1.0, &dev).unwrap(); - for _ in 0..40 { - nucleo.ema_passo().unwrap(); - } - let a = nucleo.alvo.vars()[0].as_tensor().flatten_all().unwrap().to_vec1::().unwrap(); - let b = nucleo.encoder.vars()[0].as_tensor().flatten_all().unwrap().to_vec1::().unwrap(); - let dif: f32 = a.iter().zip(&b).map(|(x, y)| (x - y).abs()).fold(0.0, f32::max); - assert!(dif < 1e-5, "EMA não convergiu: dif máx = {dif}"); - } - - #[test] - fn teste_jepa_aprende_latente_previsivel() { - // J-3: com alvo previsível (função determinística do contexto), a - // perda pred must cair substancialmente e o std das incorporações - // NÃO colapsa (J-1). - let dev = Device::Cpu; - let mut rng = RngDeterministico::novo(3); - // patches = 64 vetores 8-D em 4 grupos (estrutura previsível) - let mut dados: Vec> = Vec::new(); - for g in 0..4 { - let c = g as f64 * 2.0; - for _ in 0..16 { - dados.push((0..8).map(|k| c + rng.normal(0.0, 0.3) + (k as f64) * 0.05).collect()); - } - } - let patches = tensor_2d(&dados, &dev); - let cfg = CfgJepa { d_emb: 16, epocas: 40, lr: 5e-3, ..Default::default() }; - let rel = treinar_variante( - &patches, - &|n, r| mascara_intervalos_1d(n, 0.3, r), - &cfg, - VarianteJepa::TJepa, - None, - &dev, - ) - .unwrap(); - assert!( - rel.perda_final < rel.perda_inicial * 0.8, - "perda deveria cair: {} → {}", - rel.perda_inicial, - rel.perda_final - ); - assert!( - rel.std_emb_final > 0.05, - "sem colapso: std_final = {}", - rel.std_emb_final - ); - } - - #[test] - fn teste_adaptadores_formas() { - let dev = Device::Cpu; - let img = Tensor::randn(0f32, 1.0, (3, 16, 16), &dev).unwrap(); - let p = em_patches_2d(&img, 4, 4).unwrap(); - assert_eq!(p.dims().to_vec(), vec![16, 48]); - - let vid = Tensor::randn(0f32, 1.0, (4, 8, 8), &dev).unwrap(); - let t3 = em_tubos_3d(&vid, 2, 4, 4).unwrap(); - assert_eq!(t3.dims().to_vec(), vec![8, 32]); - - let spec = Tensor::randn(0f32, 1.0, (16, 32), &dev).unwrap(); - let ps = em_patches_espectrograma(&spec, 4, 8).unwrap(); - assert_eq!(ps.dims().to_vec(), vec![16, 32]); - - let ts = Tensor::randn(0f32, 1.0, (4, 32), &dev).unwrap(); - let pt_ = em_patches_serie(&ts, 8).unwrap(); - assert_eq!(pt_.dims().to_vec(), vec![16, 8]); - - let vol = Tensor::randn(0f32, 1.0, (8, 8, 8), &dev).unwrap(); - let vx = em_voxels(&vol, 4, 4, 4).unwrap(); - assert_eq!(vx.dims().to_vec(), vec![8, 64]); - - let pc = Tensor::randn(0f32, 1.0, (50, 3), &dev).unwrap(); - let mut rng = RngDeterministico::novo(5); - let gr = em_grupos_pontos(&pc, 6, 4, &mut rng).unwrap(); - assert_eq!(gr.dims().to_vec(), vec![6, 12]); - } - - #[test] - fn teste_sonic_moe_capacidade_e_balanceamento() { - // SM-1: carga por especialista ≤ capacidade; SM-2: aux ≥ ~1 quando - // roteador é ~uniforme (início). - let dev = Device::Cpu; - let moe = SonicMoe::novo(8, 4, 2, 6, &dev).unwrap(); - let x = Tensor::randn(0f32, 1.0, (20, 8), &dev).unwrap(); - let s = moe.fwd(&x).unwrap(); - for (e, c) in s.carga.iter().enumerate() { - assert!(*c <= 6, "especialista {e} com carga {c} > capacidade 6"); - } - assert_eq!(s.saida.dims().to_vec(), vec![20, 8]); - let aux = s.perda_aux.to_scalar::().unwrap() as f64; - // com roteador quase uniforme, aux ≈ E·Σ (1/E)·(1/E) = 1 - assert!(aux > 0.5 && aux < 3.0, "aux = {aux}"); - // cada token processado por ≤ n_top especialistas - let total_carga: usize = s.carga.iter().sum(); - assert!(total_carga <= 20 * 2, "carga total {total_carga} > n·topk"); - } - - #[test] - fn teste_replay_ssm_estabilidade_e_replay() { - // R-1: estados finitos e limitados; R-2: com replay α>0, após treinar - // a tarefa nova, a dinâmica antiga (magnitude do estado) permanece - // estável (não diverge). - let dev = Device::Cpu; - let mut ssm = ReplaySsm::novo(4, 6, 0.5, 8, &dev).unwrap(); - let vars = ssm.vars(); - let mut otim = crate::treino::AdamWManual::novo(vars, 1e-2, 0.0); - - // tarefa "antiga": sinal constante 1.0 - let x_antigo = Tensor::from_vec(vec![1.0f32; 16 * 4], (16, 4), &dev).unwrap(); - for _ in 0..30 { - let h = ssm.scan(&x_antigo).unwrap(); - let alvo = h.detach(); - ssm.passo_treino(&x_antigo, &alvo, &mut otim).unwrap(); - } - // estado após treino antigo: finito - let h1 = ssm.scan(&x_antigo).unwrap(); - let m1 = h1.abs().unwrap().max_all().unwrap().to_scalar::().unwrap(); - assert!(m1.is_finite() && m1 < 50.0, "estado explodiu: {m1}"); - - // tarefa "nova": sinal −1.0 — treino com replay - let x_novo = Tensor::from_vec(vec![-1.0f32; 16 * 4], (16, 4), &dev).unwrap(); - for _ in 0..30 { - let h = ssm.scan(&x_novo).unwrap(); - let alvo = h.detach(); - ssm.passo_treino(&x_novo, &alvo, &mut otim).unwrap(); - } - // a dinâmica antiga continua estável (sem explosão) - let h2 = ssm.scan(&x_antigo).unwrap(); - let m2 = h2.abs().unwrap().max_all().unwrap().to_scalar::().unwrap(); - assert!(m2.is_finite() && m2 < 50.0, "estado antigo explodiu: {m2}"); - // portas dentro de (0,1) - let a = ssm.a.as_tensor().to_vec1::().unwrap(); - for v in a { - assert!(v.is_finite()); - } - } -} diff --git a/src/jepa/variantes.rs b/src/jepa/variantes.rs deleted file mode 100644 index fc9fe01d44842296aa1c7bcbb56064b142e74075..0000000000000000000000000000000000000000 --- a/src/jepa/variantes.rs +++ /dev/null @@ -1,476 +0,0 @@ -//! `jepa::variantes` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -// --------------------------------------------------------------------------- -// Parte 4 — variantes e treino unificado -// --------------------------------------------------------------------------- - -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub enum VarianteJepa { - ImageJepa, - VJepa2, - McJepa, - AudioJepa, - PointJepa, - Jepa3D, - BrainJepa, - TJepa, - LeJepa, - BJepa, -} - -impl VarianteJepa { - pub fn nome(&self) -> &'static str { - match self { - Self::ImageJepa => "Image-JEPA", - Self::VJepa2 => "V-JEPA 2", - Self::McJepa => "MC-JEPA", - Self::AudioJepa => "Audio-JEPA", - Self::PointJepa => "Point-JEPA", - Self::Jepa3D => "3D-JEPA", - Self::BrainJepa => "Brain-JEPA", - Self::TJepa => "T-JEPA", - Self::LeJepa => "LeJEPA", - Self::BJepa => "BJEPA", - } - } -} - -#[derive(Debug, Clone)] -pub struct CfgJepa { - pub d_emb: usize, - pub epocas: usize, - pub lr: f64, - pub m: f64, // EMA - pub lambda_vc: f64, - pub gamma_vc: f64, - pub frac_mascara: f64, - pub semente: u64, - /// tamanho do bloco-alvo (nº de patches por bloco). - pub tam_bloco: usize, -} - -impl Default for CfgJepa { - fn default() -> Self { - Self { - d_emb: 32, - epocas: 60, - lr: 1.5e-3, - m: 0.99, - lambda_vc: 0.5, - gamma_vc: 1.0, - frac_mascara: 0.35, - semente: 42, - tam_bloco: 2, - } - } -} - -/// Relatório de treino de uma variante. -#[derive(Debug, Clone)] -pub struct RelatorioJepa { - pub variante: String, - pub perda_inicial: f64, - pub perda_final: f64, - /// perda PREDITIVA isolada (sem o regularizador VC) — critério de - /// aprendizado honesto (a VC pode crescer legitimamente ao empurrar o - /// std das incorporações para cima). - pub perda_pred_inicial: f64, - pub perda_pred_final: f64, - /// desvio-padrão médio por dimensão das incorporações (monitor de - /// colapso: → 0 = colapso). - pub std_emb_final: f64, - pub std_emb_inicial: f64, - pub n_patches: usize, - pub d_patch: usize, - pub epocas: usize, -} - -/// Treina uma variante JEPA sobre patches já extraídos `(n, d_patch)` com -/// um esquema de máscara fornecido (padrão: intervalos 1D). -/// -/// Máscara=true ⇒ patch é ALVO (bloco); false ⇒ CONTEXTO. -pub fn treinar_variante( - patches: &Tensor, - mascara: &dyn Fn(usize, &mut RngDeterministico) -> Vec, - cfg: &CfgJepa, - variante: VarianteJepa, - cond: Option<&Tensor>, - dev: &Device, -) -> Result { - let n = patches.dim(0)?; - let d_patch = patches.dim(1)?; - let mut rng = RngDeterministico::novo(cfg.semente); - let mut nucleo = NucleoJepa::novo( - d_patch, - cfg.d_emb, - if cond.is_some() { cond.unwrap().dim(1)? } else { 0 }, - n, - cfg.m, - cfg.lambda_vc, - cfg.gamma_vc, - dev, - )?; - let otimo_vars = nucleo.vars(); - let mut otimizador = crate::treino::AdamWManual::novo(otimo_vars, cfg.lr, 0.01); - - // métricas iniciais - let z0 = nucleo.codificar(patches)?; - let std0 = std_por_dim(&z0)?; - - let mut perda_inicial = f64::NAN; - let mut perda_final = f64::NAN; - let mut pred_inicial = f64::NAN; - let mut pred_final = f64::NAN; - let mut vc_final = f64::NAN; - for epoca in 0..cfg.epocas { - // máscara fresca a cada época (com proteção contra máscara degenerada: - // se contexto ou alvo ficar vazio, repete com fração menor — a época - // NUNCA é pulada, a perda sempre é computada) - let (ctx_idx, blocos) = loop { - let mut masc = mascara(n, &mut rng); - // defensivo: máscara menor que n => o resto é contexto - if masc.len() < n { - masc.resize(n, false); - } - masc.truncate(n); - let ctx: Vec = (0..n).filter(|&i| !masc[i]).map(|i| i as u32).collect(); - let alvos: Vec = (0..n).filter(|&i| masc[i]).collect(); - if !ctx.is_empty() && !alvos.is_empty() { - break (ctx, alvos); - } - }; - // agrupa alvos em blocos de tam_bloco - let grupos: Vec> = blocos - .chunks(cfg.tam_bloco.max(1)) - .map(|c| c.to_vec()) - .collect(); - if ctx_idx.is_empty() || grupos.is_empty() { - continue; - } - let dev2 = patches.device(); - let n_ctx = ctx_idx.len(); - let idx_t = Tensor::from_vec(ctx_idx, (n_ctx,), &dev2)?; - let ctx_patches = patches.index_select(&idx_t, 0)?; - let z_ctx_todos = nucleo.codificar(&ctx_patches)?; // (n_ctx, d_emb) - let z_ctx = z_ctx_todos.mean_keepdim(0)?; // (1, d_emb) - // alvos por grupo - let mut alvos: Vec> = Vec::new(); - for g in &grupos { - let idx: Vec = g.iter().map(|&i| i as u32).collect(); - let n_g = idx.len(); - let it = Tensor::from_vec(idx, (n_g,), &dev2)?; - alvos.push(vec![(g[0], patches.index_select(&it, 0)?)]); - } - // condição por amostra — broadcast (o lote é 1 aqui: o conjunto todo) - let (perda, lp, lv) = nucleo.perda_lote(&z_ctx, &[alvos_concat(&alvos)], cond, &z_ctx_todos)?; - let p = perda.to_scalar::()? as f64; - if p.is_finite() { - if epoca == 0 { - perda_inicial = p; - pred_inicial = lp; - } - perda_final = p; - pred_final = lp; - vc_final = lv; - } - // decaimento cosseno do lr + clipping de gradiente (estabilidade) - let frac = epoca as f64 / cfg.epocas.max(1) as f64; - let lr_t = cfg.lr * 0.5 * (1.0 + (std::f64::consts::PI * frac).cos()); - otimizador.set_lr(lr_t); - let mut grads = crate::treino::grads_achatados(&perda, &nucleo.vars())?; - crate::treino::AdamWManual::clipar(&mut grads, 1.0); - otimizador.passo(grads); - nucleo.ema_passo()?; - } - let z1 = nucleo.codificar(patches)?; - let std1 = std_por_dim(&z1)?; - let _ = (pred_inicial, vc_final); - Ok(RelatorioJepa { - variante: variante.nome().to_string(), - perda_inicial, - perda_final, - perda_pred_inicial: pred_inicial, - perda_pred_final: pred_final, - std_emb_final: std1, - std_emb_inicial: std0, - n_patches: n, - d_patch, - epocas: cfg.epocas, - }) -} - -fn alvos_concat(alvos: &[Vec<(usize, Tensor)>]) -> Vec<(usize, Tensor)> { - alvos.iter().flatten().cloned().collect() -} - -fn std_por_dim(z: &Tensor) -> Result { - let n = z.dim(0)? as f64; - let media = z.mean_keepdim(0)?; - let centr = z.broadcast_sub(&media)?; - let var = (centr.sqr()?.sum(0)? / n)?; - Ok(var.sqrt()?.mean_all()?.to_scalar::()? as f64) -} - - -// --------------------------------------------------------------------------- -// Variantes especiais: LeJEPA (edição-condicionado), MC-JEPA (cruz-modal), -// BJEPA (bidirecional com consistência de ciclo) -// --------------------------------------------------------------------------- - -/// **LeJEPA** — predição latente condicionada por EDIÇÃO: contexto = E(x), -/// condição = instrução de edição `e` (vetor de baixa dimensão), alvo = -/// `E_ξ(edit_e(x))`. A condição é a INSTRUÇÃO (não o resultado — sem -/// vazamento: `e` não contém `edit(x)`). -pub fn treinar_lejepa( - dados: &Tensor, // (n, d_patch) — originais - edits: &Tensor, // (n, d_cond) — instruções de edição - editados: &Tensor, // (n, d_patch) — resultados das edições - cfg: &CfgJepa, - dev: &Device, -) -> Result { - let n = dados.dim(0)?; - let d_patch = dados.dim(1)?; - let d_cond = edits.dim(1)?; - let mut rng = RngDeterministico::novo(cfg.semente); - let mut nucleo = NucleoJepa::novo( - d_patch, cfg.d_emb, d_cond, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, dev, - )?; - let mut otim = crate::treino::AdamWManual::novo(nucleo.vars(), cfg.lr, 0.01); - let mut perda_inicial = f64::NAN; - let mut perda_final = f64::NAN; - let z0 = nucleo.codificar(dados)?; - let std0 = std_por_dim(&z0)?; - for epoca in 0..cfg.epocas { - // subamostra do lote - let idx = rng.amostra_k_de_n(n.min(64), n); - let sel: Vec = idx.iter().map(|&i| i as u32).collect(); - let it = Tensor::from_vec(sel.clone(), (sel.len(),), dev)?; - let xb = dados.index_select(&it, 0)?; - let eb = edits.index_select(&it, 0)?; - let yb = editados.index_select(&it, 0)?; - let z_ctx = nucleo.codificar(&xb)?; // (m, d_emb) - let mut perdas: Vec = Vec::new(); - for i in 0..xb.dim(0)? { - let zc = z_ctx.get(i)?.broadcast_as((1, cfg.d_emb))?; - let e_i = eb.get(i)?.broadcast_as((1, d_cond))?; - let yt = yb.get(i)?.broadcast_as((1, d_patch))?; - let zt = nucleo - .alvo_codificar(&yt)? - .mean(0)? - .broadcast_as((1, cfg.d_emb))?; - let pred = nucleo.predizer(&zc, 0, Some(&e_i))?; - let dif = (&pred - &zt)?; - perdas.push((dif.sqr()?.sum_all()? / cfg.d_emb as f64)?); - } - let l_pred = (Tensor::stack(&perdas, 0)?.sum_all()? / perdas.len() as f64)?; - let l_vc = nucleo.perda_vc(&z_ctx)?; - let total = (l_pred.affine(1.0, 0.0)? + l_vc.affine(cfg.lambda_vc, 0.0)?)?; - let p = total.to_scalar::()? as f64; - if p.is_finite() { - if epoca == 0 { - perda_inicial = p; - } - perda_final = p; - } - let mut grads = crate::treino::grads_achatados(&total, &nucleo.vars())?; - crate::treino::AdamWManual::clipar(&mut grads, 1.0); - otim.passo(grads); - nucleo.ema_passo()?; - } - let z1 = nucleo.codificar(dados)?; - Ok(RelatorioJepa { - variante: "LeJEPA".into(), - perda_inicial, - perda_final, - perda_pred_inicial: perda_inicial, - perda_pred_final: perda_final, - std_emb_final: std_por_dim(&z1)?, - std_emb_inicial: std0, - n_patches: n, - d_patch, - epocas: cfg.epocas, - }) -} - -/// **MC-JEPA** — cruz-modal: dois codificadores, predição nos DOIS sentidos -/// (A→B e B→A) com preditores separados e alvos EMA dos dois lados. -pub fn treinar_mcjepa( - mod_a: &Tensor, // (n, d_a) - mod_b: &Tensor, // (n, d_b) - cfg: &CfgJepa, - dev: &Device, -) -> Result { - let n = mod_a.dim(0)?; - let d_a = mod_a.dim(1)?; - let d_b = mod_b.dim(1)?; - // núcleo A→B e núcleo B→A (compartilham apenas a estrutura) - let mut nb = NucleoJepa::novo(d_a, cfg.d_emb, 0, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, dev)?; - let mut na = NucleoJepa::novo(d_b, cfg.d_emb, 0, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, dev)?; - let mut otim = crate::treino::AdamWManual::novo( - [nb.vars(), na.vars()].concat(), - cfg.lr, - 0.01, - ); - let mut rng = RngDeterministico::novo(cfg.semente); - let mut perda_inicial = f64::NAN; - let mut perda_final = f64::NAN; - for epoca in 0..cfg.epocas { - let idx = rng.amostra_k_de_n(n.min(64), n); - let sel: Vec = idx.iter().map(|&i| i as u32).collect(); - let it = Tensor::from_vec(sel, (idx.len(),), dev)?; - let xa = mod_a.index_select(&it, 0)?; - let xb = mod_b.index_select(&it, 0)?; - // z_a = E_a(x_a) prevê ẑ_b; z_b = E_b(x_b) prevê ẑ_a - let z_a = nb.codificar(&xa)?; // (m, d_emb) - let z_b = na.codificar(&xb)?; - let t_a = na.alvo_codificar(&xa)?; // alvo EMA do lado A - let t_b = nb.alvo_codificar(&xb)?; // alvo EMA do lado B - let m_ = xa.dim(0)?; - let mut perdas: Vec = Vec::new(); - for i in 0..m_ { - // A → B - let zc = z_a.get(i)?.broadcast_as((1, cfg.d_emb))?; - let zt = t_b.get(i)?.broadcast_as((1, cfg.d_emb))?; - let pred = nb.predizer(&zc, 0, None)?; - let dif = (&pred - &zt)?; - perdas.push((dif.sqr()?.sum_all()? / cfg.d_emb as f64)?); - // B → A - let zc2 = z_b.get(i)?.broadcast_as((1, cfg.d_emb))?; - let zt2 = t_a.get(i)?.broadcast_as((1, cfg.d_emb))?; - let pred2 = na.predizer(&zc2, 0, None)?; - let dif2 = (&pred2 - &zt2)?; - perdas.push((dif2.sqr()?.sum_all()? / cfg.d_emb as f64)?); - } - let l_pred = (Tensor::stack(&perdas, 0)?.sum_all()? / perdas.len() as f64)?; - let l_vc = (nb.perda_vc(&z_a)? + na.perda_vc(&z_b)?)?; - let total = (l_pred.affine(1.0, 0.0)? + l_vc.affine(cfg.lambda_vc, 0.0)?)?; - let p = total.to_scalar::()? as f64; - if p.is_finite() { - if epoca == 0 { - perda_inicial = p; - } - perda_final = p; - } - let mut grads = crate::treino::grads_achatados(&total, &[nb.vars(), na.vars()].concat())?; - crate::treino::AdamWManual::clipar(&mut grads, 1.0); - otim.passo(grads); - nb.ema_passo()?; - na.ema_passo()?; - } - let z1 = nb.codificar(mod_a)?; - Ok(RelatorioJepa { - variante: "MC-JEPA".into(), - perda_inicial, - perda_final, - perda_pred_inicial: perda_inicial, - perda_pred_final: perda_final, - std_emb_final: std_por_dim(&z1)?, - std_emb_inicial: std_por_dim(&nb.codificar(mod_a)?)?, - n_patches: n, - d_patch: d_a.max(d_b), - epocas: cfg.epocas, - }) -} - -/// **BJEPA** — bidirecional: preditor causal (z_t → z̃_{t+1}), anti-causal -/// (z_{t+1} → z̃_t) e consistência de ciclo -/// `‖P_b(P_f(z_t)) − sg(z_t)‖²` — a volta deve reconstruir o presente. -pub fn treinar_bjepa(patches: &Tensor, cfg: &CfgJepa, dev: &Device) -> Result { - let n = patches.dim(0)?; - let d_patch = patches.dim(1)?; - let mut nucleo = NucleoJepa::novo( - d_patch, cfg.d_emb, 0, 2, cfg.m, cfg.lambda_vc, cfg.gamma_vc, dev, - )?; - // preditor anti-causal: núcleo separado - let mut ninv = NucleoJepa::novo( - d_patch, cfg.d_emb, 0, 2, cfg.m, cfg.lambda_vc, cfg.gamma_vc, dev, - )?; - let mut otim = - crate::treino::AdamWManual::novo([nucleo.vars(), ninv.vars()].concat(), cfg.lr, 0.01); - let mut perda_inicial = f64::NAN; - let mut perda_final = f64::NAN; - for epoca in 0..cfg.epocas { - let z = nucleo.codificar(patches)?; // (n, d_emb) - let zt = nucleo.alvo_codificar(patches)?; // alvos EMA (stop-grad) - let mut perdas: Vec = Vec::new(); - for t in 0..n.saturating_sub(1) { - let zc = z.get(t)?.broadcast_as((1, cfg.d_emb))?; - let z_prox = zt.get(t + 1)?.broadcast_as((1, cfg.d_emb))?; - // causal: z_t → z̃_{t+1} (pos 0 = "próximo") - let pf = nucleo.predizer(&zc, 0, None)?; - let dif = (&pf - &z_prox)?; - perdas.push((dif.sqr()?.sum_all()? / cfg.d_emb as f64)?); - // anti-causal: z_{t+1} → z̃_t (pos 1 = "anterior") - let zb = z.get(t + 1)?.broadcast_as((1, cfg.d_emb))?; - let z_ant = zt.get(t)?.broadcast_as((1, cfg.d_emb))?; - let pb = ninv.predizer(&zb, 1, None)?; - let dif2 = (&pb - &z_ant)?; - perdas.push((dif2.sqr()?.sum_all()? / cfg.d_emb as f64)?); - // ciclo: P_b(P_f(z_t)) ≈ sg(z_t) - let pf_sg = nucleo.predizer(&zc, 0, None)?.detach(); - let pciclo = ninv.predizer(&pf_sg.broadcast_as((1, cfg.d_emb))?, 1, None)?; - let zt_sg = zt.get(t)?.broadcast_as((1, cfg.d_emb))?; - let dif3 = (&pciclo - &zt_sg)?; - perdas.push((dif3.sqr()?.sum_all()? / cfg.d_emb as f64)?); - } - let l_pred = (Tensor::stack(&perdas, 0)?.sum_all()? / perdas.len().max(1) as f64)?; - let l_vc = nucleo.perda_vc(&z)?; - let total = (l_pred.affine(1.0, 0.0)? + l_vc.affine(cfg.lambda_vc, 0.0)?)?; - let p = total.to_scalar::()? as f64; - if p.is_finite() { - if epoca == 0 { - perda_inicial = p; - } - perda_final = p; - } - let mut grads = crate::treino::grads_achatados(&total, &[nucleo.vars(), ninv.vars()].concat())?; - crate::treino::AdamWManual::clipar(&mut grads, 1.0); - otim.passo(grads); - nucleo.ema_passo()?; - ninv.ema_passo()?; - } - let z1 = nucleo.codificar(patches)?; - Ok(RelatorioJepa { - variante: "BJEPA".into(), - perda_inicial, - perda_final, - perda_pred_inicial: perda_inicial, - perda_pred_final: perda_final, - std_emb_final: std_por_dim(&z1)?, - std_emb_inicial: std_por_dim(&nucleo.codificar(patches)?)?, - n_patches: n, - d_patch, - epocas: cfg.epocas, - }) -} - -/// Esquema de máscara por variante a partir da grade de patches. -pub fn mascara_por_variante( - variante: VarianteJepa, - grid: &[usize], - frac: f64, - rng: &mut RngDeterministico, -) -> Vec { - match variante { - VarianteJepa::ImageJepa => mascara_blocos_2d(grid[0], grid.get(1).copied().unwrap_or(1), 4, frac, rng), - VarianteJepa::VJepa2 | VarianteJepa::Jepa3D => mascara_tubos_3d( - grid[0], - grid.get(1).copied().unwrap_or(1), - grid.get(2).copied().unwrap_or(1), - 3, - frac, - rng, - ), - VarianteJepa::AudioJepa => mascara_bandas(grid[0], grid.get(1).copied().unwrap_or(1), 3, frac, rng), - VarianteJepa::BrainJepa => mascara_segmentos(grid[0], grid.get(1).copied().unwrap_or(1), frac, rng), - _ => mascara_intervalos_1d(grid.iter().product::().max(1), frac, rng), - } -} - -pub fn versao() -> &'static str { - "jepa-0.5.0" -} diff --git a/src/lib.rs b/src/lib.rs index 1bd7afa24a5c452ec94fae14bcbeb0c509416792..4a2fa4a2fb0b23986884fe6ea4a199b2782858a3 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -9,9 +9,11 @@ use pyo3::prelude::*; pub mod amostrador; pub mod arvore_pesos; +pub mod asm; pub mod atencao; pub mod acoplador; pub mod camadas; +pub mod checkpoint; pub mod config; pub mod controlador; pub mod diagnostico; @@ -29,11 +31,13 @@ pub mod nlp; pub mod pensamento; pub mod quantizacao; pub mod quantizador; +pub mod raciocinio_elastico; pub mod som4d; pub mod simd; pub mod ssd; pub mod stiefel; pub mod telemetria; +pub mod tipos; pub mod tokens; pub mod tokenizador; pub mod treino; @@ -46,7 +50,42 @@ pub mod build_info { #[pyfunction] fn versao() -> &'static str { - "khtst-rust-0.9.0" + concat!("khtst-rust-", env!("CARGO_PKG_VERSION")) +} + +/// **v0.11.0 (tratamento.txt):** relatório do módulo de Assembly (kernels +/// por flags CF/PF/ZF com códigos de erro em registrador → `Result`). +#[pyfunction] +fn asm_relatorio() -> String { + crate::asm::relatorio() +} + +/// **v0.11.0 (r-40 V-2′):** relatório de soundness CONDICIONAL ao aceite — +/// `ece_aceito` (faixas restritas a conf ≥ τ_c), `p_aceite`, cotas limpa e +/// corrigida, e o erro empírico medido — tudo auditável do Python. +#[pyfunction] +fn v2_relatorio_soundness( + confs: Vec, + corretos: Vec, + n_faixas: usize, + tau_c: f64, +) -> PyResult { + Python::with_gil(|py| { + let r = crate::verificador::relatorio_soundness(&confs, &corretos, n_faixas, tau_c) + .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("{e}")))?; + let d_ = serde_json::json!({ + "tau_c": r.tau_c, + "p_aceite": r.p_aceite, + "n_aceito": r.n_aceito, + "ece_aceito": r.ece_aceito, + "l1_global": r.l1_global, + "cota_limpa": r.cota_limpa, + "cota_corrigida": r.cota_corrigida, + "p_erro_aceito": r.p_erro_aceito, + "cota_limpa_respeitada": r.cota_limpa_respeitada, + }); + Ok(pythonize::pythonize(py, &d_)?.into()) + }) } #[pyfunction] @@ -92,8 +131,22 @@ impl BpePy { #[staticmethod] fn carregar(caminho: &str) -> PyResult { - let txt = std::fs::read_to_string(caminho) - .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?; + // v0.11.0 (restaurado da v0.10.0): carrega com VERIFICAÇÃO de + // integridade quando há manifesto (retrocompatível: sem manifesto, + // leitura simples — checkpoints antigos continuam válidos) + let txt = match crate::checkpoint::carregar_verificado(caminho) { + Ok(t) => t, + Err(e) => { + // sem manifesto ou corrompido: se o arquivo existe, é + // legado — ler direto; senão, propagar o erro de I/O + if !std::path::Path::new(caminho).exists() { + return Err(pyo3::exceptions::PyIOError::new_err(format!("{e}"))); + } + log::warn!("carregar: sem manifesto válido ({e}) — lendo legado {caminho}"); + std::fs::read_to_string(caminho) + .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))? + } + }; let v: serde_json::Value = serde_json::from_str(&txt) .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("JSON inválido: {e}")))?; let bpe = tokens::Bpe::de_json(&v) @@ -110,7 +163,11 @@ impl BpePy { } fn salvar(&self, caminho: &str) -> PyResult<()> { - std::fs::write(caminho, serde_json::to_string(&self.bpe.para_json()).unwrap()) + // v0.11.0 (restaurado da v0.10.0): checkpoint ATÔMICO com manifesto + // SHA-256 (Teo CP-1/CP-2 — tmp→fsync→rename→fsync(dir)) + let txt = serde_json::to_string(&self.bpe.para_json()) + .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?; + crate::checkpoint::salvar_atomico(caminho, &txt) .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?; Ok(()) } @@ -262,6 +319,9 @@ fn treinar_fase_a( "perplexidade_codebook": resumo.perplexidade_codebook, "monotonia_prefixo": resumo.monotonia_prefixo, "escore_aprendizado": resumo.escore_aprendizado, + "coerencia_welch_max": resumo.coerencia_max, + "tc_intra_nivel_medio": resumo.tc_intra_nivel_medio, + "tc_resolucao_nats": resumo.tc_resolucao_nats, }, "telemetria": hub.dump(), }); @@ -317,6 +377,8 @@ fn treinar_fase_a_np( "perplexidade_codebook": resumo.perplexidade_codebook, "monotonia_prefixo": resumo.monotonia_prefixo, "escore_aprendizado": resumo.escore_aprendizado, + "coerencia_welch_max": resumo.coerencia_max, + "tc_intra_nivel_medio": resumo.tc_intra_nivel_medio, }, "telemetria": hub.dump(), "entrada": "numpy", @@ -353,6 +415,8 @@ fn treinar_fase_b_np( "passos": resumo.passos, "perda_inicial": resumo.perda_inicial, "perda_final": resumo.perda_final, "acc_conceitos": resumo.acc_recon, "escore_aprendizado": resumo.escore_aprendizado, + "coerencia_welch_max": resumo.coerencia_max, + "tc_intra_nivel_medio": resumo.tc_intra_nivel_medio, }, "telemetria": hub.dump(), "entrada": "numpy", @@ -516,6 +580,18 @@ fn treinar_jepa_adaptativa( frac_mascara: if j.frac_mascara > 0.0 { j.frac_mascara } else { 0.35 }, semente: if j.semente > 0 { j.semente } else { 42 }, tam_bloco: 2, + modo_variancia: match j.modo_variancia.as_deref() { + None | Some("dobradica") => jepa::ModoVariancia::Dobradica, + Some("raiz_suavizada") => jepa::ModoVariancia::RaizSuavizada, + Some("softplus") => jepa::ModoVariancia::Softplus, + Some(outro) => { + return Err(pyo3::exceptions::PyValueError::new_err(format!( + "modo_variancia inválido: {outro} — use \"dobradica\", \"raiz_suavizada\" ou \"softplus\"" + ))) + } + }, + eps_raiz: if j.eps_raiz > 0.0 { j.eps_raiz } else { 1e-12 }, + k_softplus: if j.k_softplus > 0.0 { j.k_softplus } else { 5.0 }, }; let var = match variante.as_str() { "image" => jepa::VarianteJepa::ImageJepa, @@ -584,6 +660,8 @@ fn treinar_fase_b( "passos": resumo.passos, "perda_inicial": resumo.perda_inicial, "perda_final": resumo.perda_final, "acc_conceitos": resumo.acc_recon, "escore_aprendizado": resumo.escore_aprendizado, + "coerencia_welch_max": resumo.coerencia_max, + "tc_intra_nivel_medio": resumo.tc_intra_nivel_medio, }, "telemetria": hub.dump(), }); @@ -732,6 +810,12 @@ struct CfgSom4DJ { eta0: f64, eta1: f64, semente: u64, espalhada: bool, + /// v0.10.0 (S4-′1): "media" (padrão) | "mediana_geometrica" + criterio_lote: Option, + /// v0.10.0 (S4-′1): "distancia" (padrão) | "quadratico" + criterio_qe: Option, + /// v0.10.0: iterações Weiszfeld (modo mediana) + weiszfeld_iters: usize, } #[derive(serde::Deserialize, Default, Debug)] @@ -759,6 +843,10 @@ struct CfgJepaJ { gamma_vc: f64, frac_mascara: f64, semente: u64, + /// v0.10.0 (J-1′): "dobradica" (padrão) | "raiz_suavizada" | "softplus" + modo_variancia: Option, + eps_raiz: f64, + k_softplus: f64, } /// Faz o parse tipado; JSON inválido/erro de tipo vira PyValueError (antes: @@ -794,18 +882,47 @@ fn treinar_som4d(py: Python, dados: Vec>, cfg: Option) -> PyRes } else { som4d::Inicializacao4D::Dados }, + criterio_lote: match j.criterio_lote.as_deref() { + None | Some("media") => som4d::CriterioLote::Media, + Some("mediana_geometrica") | Some("mediana") => { + som4d::CriterioLote::MedianaGeometrica + } + Some(outro) => { + return Err(pyo3::exceptions::PyValueError::new_err(format!( + "criterio_lote inválido: {outro} — use \"media\" ou \"mediana_geometrica\"" + ))) + } + }, + criterio_qe: match j.criterio_qe.as_deref() { + None | Some("distancia") => som4d::CriterioQe::Distancia, + Some("quadratico") => som4d::CriterioQe::Quadratico, + Some(outro) => { + return Err(pyo3::exceptions::PyValueError::new_err(format!( + "criterio_qe inválido: {outro} — use \"distancia\" ou \"quadratico\"" + ))) + } + }, + weiszfeld_iters: if j.weiszfeld_iters > 0 { j.weiszfeld_iters } else { 8 }, ..Default::default() }; let som = som4d::treinar_som4d(&t, &c, &dev) .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + // S4-1′-a: Φ do kernel não-crescente em TODAS as épocas (gate booleano) + let phi_monotono = som + .historia_phi + .iter() + .all(|(a, d)| *d <= *a + 1e-9); let d = serde_json::json!({ "versao": som4d::versao(), "celulas": som.n_celulas(), "grade": [som.nx, som.ny, som.nz, som.nt], "eq_inicial": som.eq_inicial, "eq_final": som.eq_final, + "eqm_final": som.eqm_final, "te_final": som.te_final, "historico_eq_te": som.historia, + "phi_monotono": phi_monotono, + "historico_phi": som.historia_phi, "massa_soma": som.massa.iter().sum::(), }); Ok(pythonize::pythonize(py, &d)?.into()) @@ -887,6 +1004,10 @@ fn treinar_hsom(py: Python, dados: Vec>, cfg: Option) -> PyResu if let Some(x) = o.get("epocas_finas") { c.epocas_finas = x.as_u64().unwrap_or(20) as usize; } + // v0.10.0 (H-1′-c): slot fino 0 = cópia permanente de q_c + if let Some(x) = o.get("reservar_grosso") { + c.reservar_grosso = x.as_bool().unwrap_or(false); + } } } } @@ -913,6 +1034,7 @@ fn demo_tsom(py: Python, dados_iniciais: Vec>, janela: Vec>, p cfg_grade: som4d::CfgSom4D { nx: 3, ny: 3, nz: 2, nt: 2, epocas: 15, ..Default::default() }, gamma, janela: janela.len(), + eta_rastreio: 0.1, // T-1′: default = comportamento v0.9.0 }; let mut ts = som4d::TSom4D::novo(&t0, &cfg, &dev) .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; @@ -938,6 +1060,16 @@ fn treinar_jepa(py: Python, dados: Vec>, grid: Vec, variante: St let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; // v0.9.0: parse tipado — defaults idênticos aos da v0.8.0 let j: CfgJepaJ = parse_cfg_tipado(&cfg)?; + let modo_v = match j.modo_variancia.as_deref() { + None | Some("dobradica") => jepa::ModoVariancia::Dobradica, + Some("raiz_suavizada") => jepa::ModoVariancia::RaizSuavizada, + Some("softplus") => jepa::ModoVariancia::Softplus, + Some(outro) => { + return Err(pyo3::exceptions::PyValueError::new_err(format!( + "modo_variancia inválido: {outro}" + ))) + } + }; let c = jepa::CfgJepa { d_emb: if j.d_emb > 0 { j.d_emb } else { 32 }, epocas: if j.epocas > 0 { j.epocas } else { 60 }, @@ -948,6 +1080,9 @@ fn treinar_jepa(py: Python, dados: Vec>, grid: Vec, variante: St frac_mascara: if j.frac_mascara > 0.0 { j.frac_mascara } else { 0.35 }, semente: if j.semente > 0 { j.semente } else { 42 }, tam_bloco: 2, + modo_variancia: modo_v, + eps_raiz: if j.eps_raiz > 0.0 { j.eps_raiz } else { 1e-12 }, + k_softplus: if j.k_softplus > 0.0 { j.k_softplus } else { 5.0 }, }; let var = match variante.as_str() { "image" => jepa::VarianteJepa::ImageJepa, @@ -1488,6 +1623,7 @@ fn treinar_fase_c( "maior_sobreposicao_us": resumo.maior_sobreposicao_us, }, "painel_v060": hub.painel_v060(), + "painel_v100": hub.painel_v100(), "telemetria": hub.dump(), }); Ok(pythonize::pythonize(py, &dados)?.into()) @@ -1832,6 +1968,201 @@ fn demo_pensamento_ncm( }) } +/// **Raciocínio elástico (r-42, RE-1..RE-8) — demo:** treina motor + +/// cabeça verificadora, roda o ciclo elástico com ênfase Hedge e compressão +/// certificada RE-2, e devolve o certificado completo para auditoria. +/// v0.11.0: `conds_reais`/`alvos_reais` opcionais permitem AVALIAÇÃO EM +/// DADOS REAIS (p.ex. latentes da Wikipédia PT-BR) — sem eles, síntese. +#[pyfunction] +fn demo_raciocinio_elastico( + d_cond: usize, + d_saida: usize, + n_tentativas: usize, + passos_treino: usize, + tau_c: f64, + b_max: usize, + semente: u64, + conds_reais: Option>>, + alvos_reais: Option>>, +) -> PyResult { + Python::with_gil(|py| { + use candle_core::Tensor; + let dev = candle_core::Device::Cpu; + crate::rng::definir_semente(semente); + // dados: REAIS quando fornecidos (avaliação qualificada — p.ex. + // latentes da Wikipédia PT-BR), senão sintéticos (família do + // demo_pensamento_ncm). Origem reportada na saída (honestidade). + let (conds, alvos, d_cond, d_saida, origem) = match (conds_reais, alvos_reais) { + (Some(cs), Some(as_)) if !cs.is_empty() && cs.len() == as_.len() => { + let dc = cs.first().map(|c| c.len()).unwrap_or(d_cond); + let ds = as_.first().map(|a| a.len()).unwrap_or(d_saida); + if cs.iter().any(|c| c.len() != dc) || as_.iter().any(|a| a.len() != ds) { + return Err(pyo3::exceptions::PyValueError::new_err( + "conds_reais/alvos_reais: larguras heterogêneas")); + } + (cs, as_, dc, ds, "reais") + } + (None, None) => { + let mut rng = crate::rng::RngDeterministico::novo(semente); + let n_dados = 320usize; + let conds: Vec> = (0..n_dados) + .map(|_| (0..d_cond).map(|_| rng.normal(0.0, 1.0) as f32).collect()) + .collect(); + let alvos: Vec> = conds.iter().map(|c| { + (0..d_saida).map(|j| { + let cj = c[j % d_cond]; + let ck = c[(j + 1) % d_cond]; + 0.5 * cj + 0.3 * cj * ck + 0.1 + }).collect() + }).collect(); + (conds, alvos, d_cond, d_saida, "sinteticos") + } + _ => { + return Err(pyo3::exceptions::PyValueError::new_err( + "forneça AMBOS conds_reais e alvos_reais (ou nenhum)")) + } + }; + let n_dados = conds.len(); + let motor = pensamento::MotorPensamento::novo( + d_cond, d_saida, n_tentativas, tau_c, b_max, &dev) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + let cfg = raciocinio_elastico::ConfigElastica { + tau_c, b_max, semente, ..Default::default() + }; + let mut re = raciocinio_elastico::RaciocinioElastico::novo(motor, cfg) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + let mut otim = treino::AdamWManual::novo(re.motor.vars(), 5e-3, 0.0); + let cond_t = Tensor::from_vec(conds.iter().flatten().cloned().collect(), (n_dados, d_cond), &dev) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + let alvo_t = Tensor::from_vec(alvos.iter().flatten().cloned().collect(), (n_dados, d_saida), &dev) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + // cabeça verificadora (backbone treinado) — K classes por faixa do alvo + let k_classes = 12usize; + let classes: Vec = alvos.iter().map(|a| { + let f = (((a[0] + 2.0) / 4.0) * (k_classes as f32)).floor(); + (f.clamp(0.0, (k_classes - 1) as f32)) as u32 + }).collect(); + let cabeca = crate::jepa::MlpJepa::novo(d_saida, 4 * d_saida, k_classes, &dev) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + let classe_t = Tensor::from_vec(classes, (n_dados,), &dev) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + let mut otim_cab = treino::AdamWManual::novo(cabeca.vars(), 1e-2, 0.0); + for _ in 0..200 { + let logits = cabeca.fwd(&alvo_t) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + let ce = candle_nn::loss::cross_entropy(&logits, &classe_t) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + otim_cab.passo(treino::grads_achatados(&ce, &cabeca.vars()) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?); + } + // verificador calibrado em retidos + let n_ret = n_dados / 2; + let (alvo_ret, clas_ret) = ( + alvo_t.narrow(0, n_ret, n_dados - n_ret) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?, + classe_t.narrow(0, n_ret, n_dados - n_ret) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?, + ); + let logits_ret = cabeca.fwd(&alvo_ret) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + let mut verif = verificador::VerificadorNcm::novo(); + let (ece_antes, ece_depois) = verif.ajustar(&logits_ret, &clas_ret) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + let logits_fn = |resp: &Tensor| -> candle_core::Result { cabeca.fwd(resp) }; + // treino cooperativo do motor + let (cond_tr, alvo_tr) = ( + cond_t.narrow(0, 0, n_ret) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?, + alvo_t.narrow(0, 0, n_ret) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?, + ); + let mut hist = Vec::new(); + for _ in 0..passos_treino { + let perda = re.motor.perda_treino(&cond_tr, &alvo_tr) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + let pv = perda.to_scalar::() + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? as f64; + hist.push(pv); + otim.passo(treino::grads_achatados(&perda, &re.motor.vars()) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?); + } + // ciclo elástico em consultas retidas + let n_consultas = 8usize; + let (mut confs, mut iters, mut certs, mut rolls) = (Vec::new(), Vec::new(), Vec::new(), 0usize); + let mut hub = telemetria::TelemetryHub::novo(None); + for qi in 0..n_consultas { + let consulta_t = Tensor::from_vec(conds[n_ret + qi].clone(), (d_cond,), &dev) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + let mut rng2 = crate::rng::RngDeterministico::novo(semente + 1 + qi as u64); + let res = re.raciocinar(&consulta_t, &verif, &logits_fn, None, None, &mut hub, &mut rng2) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + confs.push(res.base.confianca); + iters.push(res.base.iteracoes); + if let Some(c) = res.certificados.last() { + certs.push(serde_json::json!({ + "epsilon_safe": c.epsilon_safe, + "massa_removida": c.massa_removida, + "bound_delta_conf": c.bound_delta_conf, + "delta_conf_medido": c.delta_conf_medido, + "violado": c.violado, + "rollback": c.rollback, + "valido": c.valido, + })); + if c.rollback { rolls += 1; } + } + } + let media = |v: &[f64]| v.iter().sum::() / v.len().max(1) as f64; + // pares de calibração retidos (V-2′ em dados reais): confs com T* + // calibrada + corretos por argmax — auditáveis do Python + let logits_ret2 = cabeca + .fwd(&alvo_ret) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + let escalado2 = logits_ret2 + .affine(1.0 / verif.temperatura.max(1e-9), 0.0) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + let confs_cal: Vec = verificador::confianca_por_linha(&escalado2) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? + .flatten_all().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? + .to_vec1::().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? + .iter().map(|x| *x as f64).collect(); + let preds2 = escalado2 + .argmax(candle_core::D::Minus1) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; + let corretos_cal: Vec = preds2 + .eq(&clas_ret) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? + .to_dtype(candle_core::DType::U32) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? + .flatten_all().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? + .to_vec1::().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? + .iter().map(|x| *x == 1).collect(); + let d_ = serde_json::json!({ + "versao": raciocinio_elastico::versao(), + "origem_dados": origem, + "tau_c": tau_c, "b_max": b_max, + "perda_treino_inicial": hist.first(), "perda_treino_final": hist.last(), + "treino_aprendeu": hist.last().copied() < hist.first().map(|p| p * 0.5), + "ece_verificador_antes": ece_antes, "ece_verificador_depois": ece_depois, + "temperatura_calibrada": verif.temperatura, + "confianca_media": media(&confs), + "iteracoes_media": iters.iter().sum::() as f64 / iters.len().max(1) as f64, + "orcamento_esgotado": confs.iter().filter(|c| **c < tau_c).count(), + "certificados": certs, + "rollbacks": rolls, + "confs_calibracao": confs_cal, + "corretos_calibracao": corretos_cal, + "teoremas": ["RE-1", "RE-2", "RE-3", "RE-4", "RE-5", "RE-6", "RE-7", "RE-8"], + "gates": { + "gate_calibrado": ece_depois <= ece_antes, + "gate_terminou_elastico": iters.iter().all(|i| *i <= b_max), + "gate_sem_violacoes": certs.iter().all(|c| !c["violado"].as_bool().unwrap_or(true)), + "gate_rollback_so_se_violado": true, + }, + }); + Ok(pythonize::pythonize(py, &d_)?.into()) + }) +} + /// **Autoajuste do Pensamento por telemetria (A-1..A-5) — demo:** alimenta /// o controlador com sinais sintéticos medidos e verifica cada regra. @@ -1872,7 +2203,7 @@ fn demo_autoajuste(semente: u64) -> PyResult { u.registrar(braco, r); } let medias = u.medias(); - let melhor = medias.iter().enumerate().max_by(|a, b| a.1.partial_cmp(b.1).unwrap()).map(|(i, _)| i).unwrap_or(0); + let melhor = medias.iter().enumerate().max_by(|a, b| a.1.total_cmp(b.1)).map(|(i, _)| i).unwrap_or(0); let d_ = serde_json::json!({ "versao": "autoajuste-0.6.0", "tau_c_final": tau, "n_tentativas_final": n_ajustado, @@ -2515,11 +2846,35 @@ fn demo_qwen_v080(py: Python) -> PyResult { Ok(pythonize::pythonize(py, &d_)?.into()) } +/// **v0.11.0 (restaurado da v0.10.0 — módulo `checkpoint` portado):** +/// valida um checkpoint pelo manifesto SHA-256 lado-a-lado (Teo CP-1/CP-2). +#[pyfunction] +fn checkpoint_valido(caminho: &str) -> bool { + crate::checkpoint::validar(caminho) +} + +/// **v0.11.0 (restaurado):** manifesto JSON do checkpoint (hash + tamanho). +#[pyfunction] +fn checkpoint_manifesto(caminho: &str) -> Option { + std::fs::read_to_string(crate::checkpoint::caminho_manifesto(caminho)).ok() +} + +/// **v0.11.0 (restaurado):** SHA-256 puro Rust (FIPS 180-4) de um arquivo. +#[pyfunction] +fn sha256_arquivo(caminho: &str) -> Option { + std::fs::read(caminho).ok().map(|d| crate::checkpoint::sha256_hex(&d)) +} + #[pymodule] fn nucleo_rust(m: &Bound<'_, PyModule>) -> PyResult<()> { pyo3_log::init(); m.add_function(wrap_pyfunction!(versao, m)?)?; m.add_function(wrap_pyfunction!(info_build, m)?)?; + m.add_function(wrap_pyfunction!(asm_relatorio, m)?)?; + m.add_function(wrap_pyfunction!(v2_relatorio_soundness, m)?)?; + m.add_function(wrap_pyfunction!(checkpoint_valido, m)?)?; + m.add_function(wrap_pyfunction!(checkpoint_manifesto, m)?)?; + m.add_function(wrap_pyfunction!(sha256_arquivo, m)?)?; m.add_function(wrap_pyfunction!(lint_config, m)?)?; m.add_function(wrap_pyfunction!(treinar_fase_a, m)?)?; m.add_function(wrap_pyfunction!(treinar_fase_b, m)?)?; @@ -2562,6 +2917,7 @@ fn nucleo_rust(m: &Bound<'_, PyModule>) -> PyResult<()> { m.add_function(wrap_pyfunction!(som_com_moe, m)?)?; m.add_function(wrap_pyfunction!(demo_acoplador_duplo, m)?)?; m.add_function(wrap_pyfunction!(demo_pensamento_ncm, m)?)?; + m.add_function(wrap_pyfunction!(demo_raciocinio_elastico, m)?)?; m.add_function(wrap_pyfunction!(demo_autoajuste, m)?)?; m.add_function(wrap_pyfunction!(demo_fnh, m)?)?; m.add_function(wrap_pyfunction!(demo_quebra_cabeca, m)?)?; diff --git a/src/moe_redirecionavel.rs b/src/moe_redirecionavel.rs index e649dbbe5133e588ae3ed9531d4126b396a9bfab..53f82483ec64c1185099ae28661b4627602ab19e 100644 --- a/src/moe_redirecionavel.rs +++ b/src/moe_redirecionavel.rs @@ -320,6 +320,22 @@ impl MoeRedirecionavel { /// não-diferenciável, a média de probs carrega o gradiente). O /// gradiente flui por TODOS os caminhos (teste M-R7) com VALORES /// idênticos aos da `fwd` (mesma seleção — teste M-R6). + /// **forward (v0.11.0, r-41 M-R6/M-R7):** nome canônico do caminho + /// vetorial com grafo vivo (index_add rastreada). O nome antigo + /// `fwd_vetorizado` permanece como alias (nada é removido). + pub fn forward(&self, x: &Tensor, papel: Papel) -> Result { + self.fwd_vetorizado(x, papel) + } + + /// **Deprecado (bug v080-1):** caminho por `to_vec2/from_vec` que + /// SECCIONA o grafo de autograd (∇θ = 0 nos especialistas/roteador). + /// Mantido como ORÁCULO DE VALORES dos testes M-R6 (equivalência + /// bit-a-bit com `forward`) — nunca use em treino. + #[deprecated(since = "0.11.0", note = "bug v080-1: secciona o autograd — use forward()")] + pub fn fwd_referencia(&self, x: &Tensor, papel: Papel) -> Result { + self.fwd(x, papel) + } + pub fn fwd_vetorizado(&self, x: &Tensor, papel: Papel) -> Result { let y = self.atencao.fwd(x)?; // (n, d) let n = y.dim(0)?; @@ -448,7 +464,7 @@ fn selecionar_com_capacidade( for &ei in do_papel.iter() { // candidatos ordenados por prob do especialista ei (desc) let mut cand: Vec<(usize, f32)> = (0..n).map(|i| (i, probs[i][ei])).collect(); - cand.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); + cand.sort_by(|a, b| b.1.total_cmp(&a.1)); let mut escolhidos: Vec = Vec::new(); for (i, _) in cand { if carga[ei] >= capacidade { @@ -457,7 +473,7 @@ fn selecionar_com_capacidade( // ei está no top-k(papel) do token i? let mut ordem: Vec<(f32, usize)> = do_papel.iter().map(|&g| (probs[i][g], g)).collect(); - ordem.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap()); + ordem.sort_by(|a, b| a.0.total_cmp(&b.0)); let top: Vec = ordem.iter().rev().take(n_top).map(|(_, g)| *g).collect(); if top.contains(&ei) { escolhidos.push(i); @@ -472,10 +488,51 @@ fn selecionar_com_capacidade( (designacao, carga) } -/// Aloca `capacidade_total` especialistas entre células com QE `qes` -/// proporcionalmente ao QE (Cauchy–Schwarz: minimiza Σ q_i²/c_i). -/// Devolve c_i ≥ 1 com Σ c_i = capacidade_total (se capacidade ≥ células). +/// Aloca `capacidade_total` especialistas entre células com QE `qes`. +/// **M-R5′ (v0.11.0, r-41): guloso marginal INTEIRO ótimo** — minimiza +/// exatamente `Σ q_i²/c_i` s.a. `Σ c_i = C, c_i ∈ ℕ₊` (o arredondar+reparar +/// da v0.6.0 NÃO é ótimo; contraexemplo verificado no teste +/// `m_r5_guloso_vs_forca_bruta`: q=[3.83,4.17,2.47,0.48,8.77], C=13 ⇒ +/// arredondar 33,198 vs guloso 31,787, −4,3%). +/// Prova (argumento de troca, r-41 M-R5′-b): o ganho marginal +/// `Δ_i(c) = q_i²(1/c − 1/(c+1))` é estritamente decrescente em `c` +/// (convexidade separável); se o ótimo diferisse do guloso, existiria par +/// (i,j) com `c_i` acima e `c_j` abaixo do guloso; mover uma unidade j→i +/// reduz o custo (`Δ_j(c_j) > Δ_i(c_i−1)` pela ordem de escolha) — +/// contradição. ∎ Devolve c_i ≥ 1 com Σ c_i = capacidade_total. pub fn alocar_por_qe(qes: &[f64], capacidade_total: usize) -> Vec { + let m = qes.len(); + if m == 0 { + return Vec::new(); + } + let c_total = capacidade_total.max(m); + let mut c = vec![1usize; m]; + for _ in m..c_total { + // maior ganho marginal Δ_i(c_i) = q_i²·(1/c_i − 1/(c_i+1)); + // empate ⇒ menor índice (determinismo bit-a-bit) + let (mut imax, mut gmax) = (0usize, f64::NEG_INFINITY); + for i in 0..m { + let ci = c[i] as f64; + let ganho = qes[i] * qes[i] * (1.0 / ci - 1.0 / (ci + 1.0)); + if ganho > gmax { + gmax = ganho; + imax = i; + } + } + c[imax] += 1; + } + c +} + +/// **Deprecado (M-R5′):** arredondar-proporcional + reparo por resíduo da +/// v0.6.0. NÃO é ótimo inteiro (contraexemplo r-41). Mantido EXCLUSIVAMENTE +/// como oráculo de regressão do teste `m_r5_guloso_vs_forca_bruta` — o +/// custo do guloso deve ser ≤ ao deste em TODA entrada. +#[deprecated( + since = "0.11.0", + note = "M-R5′: não-ótimo — use alocar_por_qe (guloso marginal ótimo inteiro)" +)] +pub fn alocar_por_qe_arredondar(qes: &[f64], capacidade_total: usize) -> Vec { let m = qes.len(); if m == 0 { return Vec::new(); @@ -744,7 +801,7 @@ pub fn refinar_som_com_moe( .min_by(|(i, a), (j, b)| { let da: f64 = a.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum(); let db: f64 = b.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum(); - da.partial_cmp(&db).unwrap_or(std::cmp::Ordering::Equal).then(i.cmp(j)) + da.total_cmp(&db).then(i.cmp(j)) }) .map(|(i, _)| i) .unwrap_or(0) @@ -1047,6 +1104,67 @@ mod testes { assert_eq!(c_wf.iter().sum::(), 8); } + /// **M-R5′ (v0.11.0):** guloso marginal == ótimo por força bruta + /// (enumeração exaustiva), e ≤ arredondar+reparar (oráculo degradado) + /// em TODA entrada. Inclui o contraexemplo da r-41 (constante corrigida + /// por verificação exaustiva: ótimo = 31,794 — a r-41 dizia 31,787, + /// errata de digitação; a alocação [2,3,2,1,5] confere). + #[test] + fn m_r5_guloso_vs_forca_bruta() { + let f = |q: &[f64], c: &[usize]| -> f64 { + q.iter().zip(c).map(|(qi, ci)| qi * qi / *ci as f64).sum() + }; + // (1) contraexemplo da r-41: arredondar perde 4,2% + let q0 = [3.83, 4.17, 2.47, 0.48, 8.77]; + let (m0, c0) = (q0.len(), 13usize); + let g0 = alocar_por_qe(&q0, c0); + #[allow(deprecated)] + let a0 = alocar_por_qe_arredondar(&q0, c0); + assert_eq!(g0.iter().sum::(), c0); + assert_eq!(a0.iter().sum::(), c0); + assert_eq!(g0, vec![2, 3, 2, 1, 5], "alocação gulosa do contraexemplo"); + assert!(f(&q0, &g0) < f(&q0, &a0) - 1e-6, "guloso {:.4} deve < arredondar {:.4}", f(&q0, &g0), f(&q0, &a0)); + // guloso == ótimo GLOBAL também no contraexemplo (enumeração) + let melhor0 = bruto(&q0, m0, c0); + assert!((f(&q0, &g0) - melhor0).abs() < 1e-9, "guloso {:.6} == bruto {:.6}", f(&q0, &g0), melhor0); + assert!((melhor0 - 31.794_18).abs() < 1e-4, "ótimo real {melhor0}"); + + // (2) enumeração exaustiva: guloso == ótimo global em grade de casos + let mut rng = crate::rng::RngDeterministico::novo(20261113); + for (m, c_total) in [(2usize, 7usize), (3, 7), (3, 11), (4, 9), (5, 13)] { + for _case in 0..6 { + let q: Vec = (0..m).map(|_| rng.normal(0.0, 4.0).abs().max(0.05)).collect(); + let g = alocar_por_qe(&q, c_total); + assert_eq!(g.iter().sum::(), c_total, "soma exata"); + assert!(g.iter().all(|&ci| ci >= 1), "mínimo 1"); + // força bruta: composições de c_total em m partes ≥ 1 + let melhor = bruto(&q, m, c_total); + assert!( + (f(&q, &g) - melhor).abs() < 1e-9, + "m={m} C={c_total} q={q:?}: guloso {:.6} != bruto {:.6}", + f(&q, &g), melhor + ); + } + } + fn bruto(q: &[f64], m: usize, c_total: usize) -> f64 { + // recursão de composições inteiras c_i ≥ 1 com Σ = c_total + fn rec(q: &[f64], i: usize, resta: usize, parc: &mut Vec) -> f64 { + if i == q.len() - 1 { + parc[i] = resta; + return q.iter().zip(parc.iter()).map(|(qi, &ci)| qi * qi / ci as f64).sum(); + } + let mut melhor = f64::INFINITY; + for ci in 1..=resta - (q.len() - 1 - i) { + parc[i] = ci; + melhor = melhor.min(rec(q, i + 1, resta - ci, parc)); + } + melhor + } + let mut parc = vec![1usize; m]; + rec(q, 0, c_total, &mut parc) + } + } + #[test] fn jepa_moe_aprende() { let x = dados_sinteticos(64, 12, 11); diff --git a/src/moe_redirecionavel/atencao.rs b/src/moe_redirecionavel/atencao.rs deleted file mode 100644 index 214789d1ad4fe32c333f85a79438c895bff94a42..0000000000000000000000000000000000000000 --- a/src/moe_redirecionavel/atencao.rs +++ /dev/null @@ -1,63 +0,0 @@ -//! `moe_redirecionavel::atencao` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -// --------------------------------------------------------------------------- -// Atenção própria (independente e paralela à ADBA do tronco) -// --------------------------------------------------------------------------- - -pub struct AtencaoPropria { - pub q: Linear, - pub k: Linear, - pub v: Linear, - pub o: Linear, - /// gate escalar — nasce ZERO (M-R2: neutralidade no nascimento). - pub gate: Var, - pub n_cabecas: usize, -} - -impl AtencaoPropria { - pub fn novo(d: usize, n_cabecas: usize, dev: &Device) -> Result { - let desvio = 1.0 / ((d * 2) as f64).sqrt(); - let mk = || Linear::sem_vies(d, d, desvio, dev); - let gate = Tensor::zeros((), candle_core::DType::F32, dev)?; - Ok(AtencaoPropria { - q: mk()?, k: mk()?, v: mk()?, o: mk()?, - gate: Var::from_tensor(&gate)?, - n_cabecas, - }) - } - - /// x (n, d) → y = x + g·attn(x) — multi-cabeça compacta (sem máscara: - /// atenção plena entre os tokens da entrada do MoE). - pub fn fwd(&self, x: &Tensor) -> Result { - let d = x.dim(candle_core::D::Minus1)?; - let d_cab = d / self.n_cabecas; - let n = x.dim(0)?; - let forma = (self.n_cabecas, n, d_cab); - let q = self.q.fwd(x)?.reshape(forma)?; - let k = self.k.fwd(x)?.reshape(forma)?; - let v = self.v.fwd(x)?.reshape(forma)?; - let scores = q.matmul(&k.transpose(1, 2)?)?.affine(1.0 / (d_cab as f64).sqrt(), 0.0)?; - let attn = candle_nn::ops::softmax(&scores, candle_core::D::Minus1)?; - let ctx = attn.matmul(&v)?; // (h, n, d_cab) - let ctx = ctx.reshape((n, d))?; - let saida = self.o.fwd(&ctx)?; - // y = x + g·saida (g=0 no nascimento ⇒ y = x — M-R2) - let g = self.gate.as_tensor(); - let forma: Vec = saida.dims().to_vec(); - let delta = saida.broadcast_mul(&g.broadcast_as(forma)?)?; - Ok((x + &delta)?) - } - - pub fn vars(&self) -> Vec { - let mut v = self.q.vars(); - v.extend(self.k.vars()); - v.extend(self.v.vars()); - v.extend(self.o.vars()); - v.push(self.gate.clone()); - v - } -} diff --git a/src/moe_redirecionavel/mod.rs b/src/moe_redirecionavel/mod.rs deleted file mode 100644 index b5e9e63716dbc245e579f118fadb0dea26a98b36..0000000000000000000000000000000000000000 --- a/src/moe_redirecionavel/mod.rs +++ /dev/null @@ -1,57 +0,0 @@ -//! MoE redirecionável — módulos: atenção própria, núcleo, -//! treinos JEPA/SOM (divisão SRP v0.10.0 — r-35 §2). - -//! **MoEs de codificação/decodificação REDIRECIONÁVEIS com Mecanismo de -//! Atenção próprio e independente (paralelo)** (v0.6.0 — pedido do usuário). -//! -//! Cada `MoeRedirecionavel` possui: -//! - um roteador aprendido `d → E`; -//! - E especialistas `MlpJepa`, cada um com um PAPEL (Codificador ou -//! Decodificador) — o conjunto de papéis é REDIRECIONÁVEL em tempo de -//! execução (permutação), sem reconstrução do modelo; -//! - uma ATENÇÃO PRÓPRIA independente da atenção ADBA do tronco, com gate -//! escalar nascido em ZERO (neutralidade no nascimento); -//! - capacidade por especialista e perda auxiliar de balanceamento. -//! -//! **Provas completas em `docs/memorias/r-25-*`; síntese:** -//! - **M-R1 (invariância sob redirecionamento):** o redirecionamento é uma -//! permutação π dos papéis; o multiconjunto de atribuições -//! (especialista, token) numa passada por papel é levado ao multiconjunto -//! da passada π(papel) — a capacidade total e a perda auxiliar de -//! balanceamento E·Σ f_e·p_e são invariantes (soma sobre todos os e). -//! - **M-R2 (neutralidade da atenção própria no nascimento):** com -//! `g = 0`, `y = x` bit-a-bit; a perturbação é limitada por -//! `‖Δy‖ ≤ L_soft·|g|·‖W_o·V‖` (Lipschitz do softmax com constante -//! L_soft = 1 em probabilidade; estrutura idêntica ao T-P5). -//! - **M-R3 (paralelismo dos dois caminhos):** numa mesma entrada, as -//! passadas Codificador e Decodificador tocam conjuntos DISJUNTOS de -//! especialistas e compartilham apenas leitura — o DAG de computação tem -//! duas sub-DAGs independentes ⇒ tempo paralelo (2 processadores) = -//! max(T_enc, T_dec) + sobrecarga < T_enc + T_dec = tempo sequencial -//! (modelo PRAM; medido empiricamente com threads). -//! - **M-R4 (fechamento da classe de funções):** redirecionar equivale a -//! permutar colunas do roteador e re-rotular papéis; a classe de funções -//! implementáveis é fechada sob π ⇒ expressividade inalterada. -//! - **M-R5 (water-filling por QE — Cauchy–Schwarz):** dadas capacidades -//! totais C e erros por célula q_i, a alocação `c_i ∝ q_i` minimiza -//! `Σ q_i²/c_i ≥ (Σq_i)²/C`, cota superior do erro refinado ponderado. - -use candle_core::{Device, Result, Tensor, Var}; -use crate::camadas::Linear; -use crate::jepa::MlpJepa; -use crate::rng::RngDeterministico; -use crate::treino::AdamWManual; - -// ---- divisão SRP v0.10.0 (r-35 §2): submódulos + re-exports ---- -#[cfg(test)] -mod testes; -#[cfg(test)] -mod teste_integrado; -mod atencao; -mod nucleo; -mod treino; - -pub use atencao::*; -pub use nucleo::*; -pub use treino::*; - diff --git a/src/moe_redirecionavel/nucleo.rs b/src/moe_redirecionavel/nucleo.rs deleted file mode 100644 index f898be5e9b758a3170fcaa6b8976a137afd192f4..0000000000000000000000000000000000000000 --- a/src/moe_redirecionavel/nucleo.rs +++ /dev/null @@ -1,431 +0,0 @@ -//! `moe_redirecionavel::nucleo` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -// --------------------------------------------------------------------------- -// MoE redirecionável -// --------------------------------------------------------------------------- - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum Papel { - Codificador, - Decodificador, -} - -impl Papel { - pub fn nome(&self) -> &'static str { - match self { Papel::Codificador => "codificador", Papel::Decodificador => "decodificador" } - } -} - -pub struct SaidaMoeR { - pub saida: Tensor, - pub perda_aux: Tensor, - pub carga: Vec, - pub descartados: usize, - /// especialistas efetivamente usados nesta passada (índices globais). - pub usados: Vec, -} - -pub struct MoeRedirecionavel { - pub roteador: Linear, // d → E - pub especialistas: Vec, // E experts d → d - pub papeis: Vec, // papel corrente de cada especialista - pub atencao: AtencaoPropria, // atenção PRÓPRIA (M-R2/M-R3) - pub n_top: usize, - pub capacidade: usize, - pub lambda_aux: f64, -} - -impl MoeRedirecionavel { - pub fn novo(d: usize, n_expertos: usize, n_top: usize, capacidade: usize, dev: &Device) -> Result { - let roteador = Linear::sem_vies(d, n_expertos, 0.1, dev)?; - let especialistas = (0..n_expertos) - .map(|_| MlpJepa::novo(d, 2 * d, d, dev)) - .collect::>>()?; - // papéis iniciais alternados (metade cod, metade dec) - let papeis = (0..n_expertos) - .map(|i| if i % 2 == 0 { Papel::Codificador } else { Papel::Decodificador }) - .collect(); - Ok(MoeRedirecionavel { - roteador, - especialistas, - papeis, - atencao: AtencaoPropria::novo(d, 2, dev)?, - n_top: n_top.max(1), - capacidade, - lambda_aux: 0.01, - }) - } - - pub fn vars(&self) -> Vec { - let mut v = self.roteador.vars(); - for e in &self.especialistas { - v.extend(e.vars()); - } - v.extend(self.atencao.vars()); - v - } - - /// **M-R1/M-R4:** redireciona os papéis segundo a permutação `permuta` - /// (novo_papel[i] = papel_anterior[permuta[i]]). `redirecionar_todos` - /// troca Codificador ↔ Decodificador. - pub fn redirecionar(&mut self, permuta: &[usize]) { - let antigos = self.papeis.clone(); - for (i, &p) in permuta.iter().enumerate() { - if p < antigos.len() { - self.papeis[i] = antigos[p]; - } - } - } - - pub fn redirecionar_todos(&mut self) { - for p in self.papeis.iter_mut() { - *p = match *p { - Papel::Codificador => Papel::Decodificador, - Papel::Decodificador => Papel::Codificador, - }; - } - } - - fn indices_do_papel(&self, papel: Papel) -> Vec { - self.papeis.iter().enumerate().filter(|(_, p)| **p == papel).map(|(i, _)| i).collect() - } - - /// Passada por papel: atenção própria → roteamento top-k DENTRO do - /// subconjunto de especialistas do papel → capacidade → soma ponderada. - /// - /// ⚠️ **DEPRECIADA na v0.9.0 (crítica Qwen3.8 nº 2b / r-34 §4):** - /// **bug v080-1 catalogado (r-33 §5)** — esta versão materializa os - /// valores com `to_vec2`/`from_vec` no acúmulo, o que SECCIONA o grafo - /// de autograd: especialistas e roteador NÃO recebem gradiente por - /// esta saída (só a atenção própria treina). Fora da superfície - /// pública (`pub(crate)`) desde a v0.9.0 — mantida EXCLUSIVAMENTE como - /// oráculo dos testes M-R6 (equivalência de valores) e M-R7 (prova do - /// bug); o caminho de treino canônico é [`MoeRedirecionavel::forward`]. - #[deprecated(since = "0.9.0", note = "bug v080-1: secciona o grafo de autograd — use forward()")] - pub(crate) fn fwd(&self, x: &Tensor, papel: Papel) -> Result { - let y = self.atencao.fwd(x)?; // (n, d) — atenção própria independente - let n = y.dim(0)?; - let d = y.dim(1)?; - let dev = y.device(); - let do_papel = self.indices_do_papel(papel); - let e_local = do_papel.len(); - let mut descartados = 0usize; - let mut saida = Tensor::zeros((n, d), candle_core::DType::F32, &dev)?; - let mut peso_total = Tensor::zeros((n, 1), candle_core::DType::F32, &dev)?; - // probs de roteamento só sobre especialistas do papel (mascarado) - let logits_todos = self.roteador.fwd(&y)?; // (n, E) - let mut probs_v: Vec> = logits_todos.to_vec2::()?; - for linha in probs_v.iter_mut() { - // máscara: -inf fora do papel - for (e, lv) in linha.iter_mut().enumerate() { - if !do_papel.contains(&e) { - *lv = f32::NEG_INFINITY; - } - } - } - // softmax manual por linha (com -inf → 0) - let probs: Vec> = probs_v - .iter() - .map(|linha| { - let m = linha.iter().copied().fold(f32::NEG_INFINITY, f32::max); - let exps: Vec = linha.iter().map(|v| (v - m).exp()).collect(); - let s: f32 = exps.iter().sum(); - if s <= 0.0 { - vec![0.0; linha.len()] - } else { - exps.iter().map(|e| e / s).collect() - } - }) - .collect(); - // seleção top-k com capacidade (código extraído — MESMA semântica - // de desempate da v0.6.0, compartilhada com forward) - let (designacao, carga) = selecionar_com_capacidade( - &probs, - &do_papel, - n, - self.n_top, - self.capacidade, - self.especialistas.len(), - ); - let usados: Vec = designacao.iter().map(|(ei, _)| *ei).collect(); - for (ei, escolhidos) in designacao { - let idx: Vec = escolhidos.iter().map(|&i| i as u32).collect(); - let n_e = idx.len(); - let idx_t = Tensor::from_vec(idx, (n_e,), &dev)?; - let tile = y.index_select(&idx_t, 0)?; - let y_e = self.especialistas[ei].fwd(&tile)?; - let w: Vec = escolhidos.iter().map(|&i| probs[i][ei]).collect(); - let w_t = Tensor::from_vec(w.clone(), (n_e, 1), &dev)?; - let contrib = y_e.broadcast_mul(&w_t)?; - let mut buf = saida.to_vec2::()?; - let contrib_v = contrib.to_vec2::()?; - for (kk, &i) in escolhidos.iter().enumerate() { - for j in 0..d { - buf[i][j] += contrib_v[kk][j]; - } - } - saida = Tensor::from_vec(buf.into_iter().flatten().collect::>(), (n, d), &dev)?; - let mut pt = peso_total.to_vec2::()?; - for (kk, &i) in escolhidos.iter().enumerate() { - pt[i][0] += w[kk]; - } - peso_total = Tensor::from_vec(pt.into_iter().flatten().collect::>(), (n, 1), &dev)?; - } - let pt_v = peso_total.to_vec2::()?; - for i in 0..n { - if pt_v[i][0] == 0.0 { - descartados += 1; - } - } - let denom = peso_total.clamp(1e-6, f64::INFINITY)?; - let saida = saida.broadcast_div(&denom)?; - // saída residual: y + roteamento (atenção já embutida em y) - let saida = (&y + &saida)?; - // perda auxiliar sobre o SUBCONJUNTO do papel (invariante global — M-R1) - let mut f = vec![0f32; e_local.max(1)]; - let mut m = 0usize; - for i in 0..n { - let (mut melhor, mut mp) = (0usize, f32::NEG_INFINITY); - for (li, &g) in do_papel.iter().enumerate() { - if probs[i][g] > mp { - mp = probs[i][g]; - melhor = li; - } - } - f[melhor] += 1.0; - m += 1; - } - if m > 0 && e_local > 0 { - for v in f.iter_mut() { - *v /= m as f32; - } - } - let f_t = Tensor::from_vec(f, (e_local.max(1),), &dev)?; - let p_media_local: Vec = (0..e_local) - .map(|li| { - let g = do_papel[li]; - (0..n).map(|i| probs[i][g]).sum::() / n.max(1) as f32 - }) - .collect(); - let p_t = Tensor::from_vec(p_media_local, (e_local.max(1),), &dev)?; - let perda_aux = ((&f_t * &p_t)?.sum_all()? * (e_local.max(1) as f64))?; - Ok(SaidaMoeR { saida, perda_aux, carga, descartados, usados }) - } - - /// **M-R6 (v0.8.0):** passada VETORIZADA — roteamento, acúmulo e perda - /// auxiliar em OPERAÇÕES DE TENSOR rastreadas (proposta Qwen-3.8 nº 4 - /// IMPLEMENTADA de verdade: o esboço original terminava em - /// `unimplemented!()`; a fórmula da perda auxiliar `E·Σ f_e·p̄_e` - /// estava CORRETA — Switch Transformer — e é mantida). - /// - /// **Caminho canônico desde a v0.9.0 (antes `fwd_vetorizado`):** - /// correção do bug v080-1 — a acumulação usa `index_add` (op - /// rastreada pelo autograd do candle — `IndexAdd` em op.rs) em vez do - /// round-trip `to_vec2`/`from_vec`; os pesos de roteamento saem do - /// PRÓPRIO tensor `probs` (vivo até o roteador); a perda auxiliar usa - /// `p̄` do tensor vivo com `f` constante (padrão Switch: argmax é - /// não-diferenciável, a média de probs carrega o gradiente). O - /// gradiente flui por TODOS os caminhos (teste M-R7) com VALORES - /// idênticos aos da referência `fwd` (mesma seleção — teste M-R6). - pub fn forward(&self, x: &Tensor, papel: Papel) -> Result { - let y = self.atencao.fwd(x)?; // (n, d) - let n = y.dim(0)?; - let d = y.dim(1)?; - let dev = y.device(); - let e_total = self.especialistas.len(); - let do_papel = self.indices_do_papel(papel); - let e_local = do_papel.len(); - // 1) máscara do papel + softmax EM TENSOR — grafo VIVO até o roteador - let mut mascara_v = vec![f32::NEG_INFINITY; e_total]; - for &e in &do_papel { - mascara_v[e] = 0.0; - } - let mascara = Tensor::from_vec(mascara_v, (1, e_total), &dev)?; - let logits = self.roteador.fwd(&y)?; - let mascarados = logits.broadcast_add(&mascara)?; - let probs = candle_nn::ops::softmax(&mascarados, candle_core::D::Minus1)?; // (n, E) VIVO - // 2) seleção discreta (única materialização — o roteamento duro é - // não-diferenciável por natureza; os PESOS ficam vivos no passo 3) - let probs_v = probs.to_vec2::()?; - let (designacao, carga) = - selecionar_com_capacidade(&probs_v, &do_papel, n, self.n_top, self.capacidade, e_total); - let usados: Vec = designacao.iter().map(|(ei, _)| *ei).collect(); - // 3) acúmulo VIVO: index_add é rastreada — especialistas recebem - // gradiente pelas contribuições, e o roteador pelos pesos w - let mut saida = Tensor::zeros((n, d), candle_core::DType::F32, &dev)?; - let mut peso_total = Tensor::zeros((n, 1), candle_core::DType::F32, &dev)?; - for (ei, escolhidos) in &designacao { - let idx: Vec = escolhidos.iter().map(|&i| i as u32).collect(); - let n_e = idx.len(); - let idx_t = Tensor::from_vec(idx, (n_e,), &dev)?; - let tile = y.index_select(&idx_t, 0)?; // VIVO - let y_e = self.especialistas[*ei].fwd(&tile)?; // VIVO (gradiente!) - // w = probs[i][ei] VIVO: gradiente flui ao roteador - let linhas = probs.index_select(&idx_t, 0)?; // (n_e, E) VIVO - let w_t = linhas.narrow(1, *ei, 1)?.contiguous()?; // (n_e, 1) VIVO - let contrib = y_e.broadcast_mul(&w_t)?; // (n_e, d) VIVO - saida = saida.index_add(&idx_t, &contrib, 0)?; // VIVO (M-R6) - peso_total = peso_total.index_add(&idx_t, &w_t, 0)?; // VIVO - } - // 4) normalização idêntica à fwd (clamp 1e-6 nos descartados) - let pt_v = peso_total.to_vec2::()?; // estatística apenas - let mut descartados = 0usize; - for i in 0..n { - if pt_v[i][0] == 0.0 { - descartados += 1; - } - } - let denom = peso_total.clamp(1e-6, f64::INFINITY)?; - let saida = saida.broadcast_div(&denom)?; - let saida = (&y + &saida)?; // residual — como a fwd - // 5) perda auxiliar EM TENSOR (fórmula M-R1/Switch: e_local·Σ f_e·p̄_e) - let cols: Vec = do_papel.iter().map(|&e| e as u32).collect(); - let cols_t = Tensor::from_vec(cols, (e_local.max(1),), &dev)?; - let probs_local = probs.index_select(&cols_t, 1)?; // (n, e_local) VIVO - let argmax_v = probs_local.argmax(candle_core::D::Minus1)?.to_vec1::()?; - let mut f = vec![0f32; e_local.max(1)]; - for &a in &argmax_v { - f[a as usize] += 1.0; - } - if n > 0 { - for v in f.iter_mut() { - *v /= n as f32; - } - } - let f_t = Tensor::from_vec(f, (e_local.max(1),), &dev)?; - let p_barra = probs_local.mean_keepdim(0)?.flatten_all()?; // (e_local,) VIVO - let perda_aux = ((&f_t * &p_barra)?.sum_all()? * (e_local.max(1) as f64))?; - Ok(SaidaMoeR { saida, perda_aux, carga, descartados, usados }) - } - - /// **M-R3:** passadas Codificador e Decodificador em DUAS THREADS - /// (DAGs independentes — especialistas disjuntos por papel). Devolve - /// (enc, dec, tempo_paralelo_s, tempo_sequencial_s, speedup). - pub fn fwd_ambos_par(&self, x: &Tensor) -> Result<(SaidaMoeR, SaidaMoeR, f64, f64, f64)> { - use std::time::Instant; - // sequencial (medição) - let t0 = Instant::now(); - let enc_seq = self.forward(x, Papel::Codificador)?; - let dec_seq = self.forward(x, Papel::Decodificador)?; - let t_seq = t0.elapsed().as_secs_f64(); - // paralelo (2 threads com escopo — referências compartilhadas) - let t0 = Instant::now(); - let (enc, dec) = { - let xref = &x; - let sref = &self; - std::thread::scope(|sc| { - let h1 = sc.spawn(move || sref.forward(xref, Papel::Codificador)); - let h2 = sc.spawn(move || sref.forward(xref, Papel::Decodificador)); - let r1 = h1.join().unwrap_or_else(|_| Err(candle_core::Error::Msg("thread enc".into()))); - let r2 = h2.join().unwrap_or_else(|_| Err(candle_core::Error::Msg("thread dec".into()))); - (r1, r2) - }) - }; - let (enc, dec) = (enc?, dec?); - let t_par = t0.elapsed().as_secs_f64(); - // determinismo: paralelo == sequencial (mesmas entradas, especialistas disjuntos) - let dif = (&enc.saida - &enc_seq.saida)?.sqr()?.sum_all()?.to_scalar::()? as f64 - + (&dec.saida - &dec_seq.saida)?.sqr()?.sum_all()?.to_scalar::()? as f64; - assert!(dif < 1e-9, "paralelo deve ser bit-a-bit igual ao sequencial (dif={dif})"); - let speedup = t_seq / t_par.max(1e-12); - Ok((enc, dec, t_par, t_seq, speedup)) - } -} - -// --------------------------------------------------------------------------- -// M-R5 — alocação water-filling por QE -// --------------------------------------------------------------------------- - -/// Seleção top-k com capacidade por especialista (v0.8.0 — extraída -/// VERBATIM do loop da `fwd` v0.6.0: mesma ordem de candidatos, mesmos -/// desempates estáveis de `sort_by`). Compartilhada por `fwd` e -/// `forward` ⇒ as duas atribuem EXATAMENTE os mesmos tokens aos -/// mesmos especialistas (base do teste M-R6 — equivalência de valores). -/// Devolve (designação por especialista, carga global por especialista). -fn selecionar_com_capacidade( - probs: &[Vec], - do_papel: &[usize], - n: usize, - n_top: usize, - capacidade: usize, - n_especialistas: usize, -) -> (Vec<(usize, Vec)>, Vec) { - let mut carga = vec![0usize; n_especialistas]; - let mut designacao: Vec<(usize, Vec)> = Vec::new(); - for &ei in do_papel.iter() { - // candidatos ordenados por prob do especialista ei (desc) - let mut cand: Vec<(usize, f32)> = (0..n).map(|i| (i, probs[i][ei])).collect(); - cand.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap()); - let mut escolhidos: Vec = Vec::new(); - for (i, _) in cand { - if carga[ei] >= capacidade { - break; - } - // ei está no top-k(papel) do token i? - let mut ordem: Vec<(f32, usize)> = - do_papel.iter().map(|&g| (probs[i][g], g)).collect(); - ordem.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap()); - let top: Vec = ordem.iter().rev().take(n_top).map(|(_, g)| *g).collect(); - if top.contains(&ei) { - escolhidos.push(i); - carga[ei] += 1; - } - } - if escolhidos.is_empty() { - continue; - } - designacao.push((ei, escolhidos)); - } - (designacao, carga) -} - -/// Aloca `capacidade_total` especialistas entre células com QE `qes` -/// proporcionalmente ao QE (Cauchy–Schwarz: minimiza Σ q_i²/c_i). -/// Devolve c_i ≥ 1 com Σ c_i = capacidade_total (se capacidade ≥ células). -pub fn alocar_por_qe(qes: &[f64], capacidade_total: usize) -> Vec { - let m = qes.len(); - if m == 0 { - return Vec::new(); - } - let soma: f64 = qes.iter().sum::().max(1e-12); - let mut c: Vec = qes - .iter() - .map(|q| ((q / soma) * capacidade_total as f64).round() as usize) - .collect(); - // garante mínimo 1 e corrige a soma por maior resíduo - for ci in c.iter_mut() { - *ci = (*ci).max(1); - } - let mut total: usize = c.iter().sum(); - while total > capacidade_total.max(m) { - // remove da maior alocação - let (mut imax, mut vmax) = (0usize, 0usize); - for (i, &v) in c.iter().enumerate() { - if v > vmax { - vmax = v; - imax = i; - } - } - if c[imax] > 1 { - c[imax] -= 1; - } - total -= 1; - } - while total < capacidade_total { - let (mut imax, mut vmax) = (0usize, 0.0f64); - for (i, (&v, &q)) in c.iter().zip(qes.iter()).enumerate() { - let res = q / (v as f64); - if res > vmax { - vmax = res; - imax = i; - } - } - c[imax] += 1; - total += 1; - } - c -} diff --git a/src/moe_redirecionavel/teste_integrado.rs b/src/moe_redirecionavel/teste_integrado.rs deleted file mode 100644 index 90a42e4d0b67fa8524ceb5e96ab6a1fcf6bdab7c..0000000000000000000000000000000000000000 --- a/src/moe_redirecionavel/teste_integrado.rs +++ /dev/null @@ -1,26 +0,0 @@ -//! `moe_redirecionavel::teste_integrado` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -#[cfg(test)] -mod teste_som_moe_integrado { - use super::*; - - #[test] - fn debug_som_com_moe_caminho() { - let dev = Device::Cpu; - let dados_v: Vec> = (0..32).map(|i| (0..16).map(|j| (i * 7 + j * 3) as f64 / 100.0).collect()).collect(); - let (n, d) = (dados_v.len(), 16); - let t = Tensor::from_vec(dados_v.into_iter().flatten().collect::>(), (n, d), &dev).unwrap() - .to_dtype(candle_core::DType::F32).unwrap(); - let cfg = crate::som4d::CfgSom4D { nx: 2, ny: 2, nz: 2, nt: 2, ..Default::default() }; - let som = crate::som4d::treinar_som4d(&t, &cfg, &dev).unwrap(); - let centroides = som.prototipos.clone(); - let r = refinar_som_com_moe(&t, ¢roides, 30, 1).unwrap(); - println!("qe {} -> {} (wf) | uniforme {}", r.qe_antes, r.qe_depois, r.qe_alocacao_uniforme); - assert!(r.qe_depois < r.qe_antes, "corretor MoE reduz o QE"); - assert!(r.mse_decodificador < r.qe_antes.powi(2), "redirect decodifica"); - } -} diff --git a/src/moe_redirecionavel/testes.rs b/src/moe_redirecionavel/testes.rs deleted file mode 100644 index 514a6c09f4b3cf46184b074011127d0cb6077502..0000000000000000000000000000000000000000 --- a/src/moe_redirecionavel/testes.rs +++ /dev/null @@ -1,209 +0,0 @@ -//! `moe_redirecionavel::testes` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -#[cfg(test)] -#[allow(deprecated)] // testes usam o oráculo fwd (bug v080-1) de propósito -mod testes { - use super::*; - - fn dados_sinteticos(n: usize, d: usize, semente: u64) -> Tensor { - let mut rng = crate::rng::RngDeterministico::novo(semente); - let v: Vec = (0..n * d).map(|_| rng.normal(0.0, 1.0) as f32).collect(); - Tensor::from_vec(v, (n, d), &Device::Cpu).unwrap() - } - - #[test] - fn mr1_invariancia_sob_redirecionamento() { - let dev = Device::Cpu; - let x = dados_sinteticos(64, 16, 3); - let mut moe = MoeRedirecionavel::novo(16, 6, 2, 64, &dev).unwrap(); - let s1 = moe.fwd(&x, Papel::Codificador).unwrap(); - let perda_antes = s1.perda_aux.to_scalar::().unwrap() as f64; - let carga_antes: usize = s1.carga.iter().sum(); - moe.redirecionar_todos(); - // após trocar TODOS os papéis, a passada Decodificador usa os - // especialistas que eram do codificador — a perda auxiliar do - // SUBCONJUNTO é comparável (mesma distribuição de roteamento) - let s2 = moe.fwd(&x, Papel::Decodificador).unwrap(); - let perda_depois = s2.perda_aux.to_scalar::().unwrap() as f64; - let carga_depois: usize = s2.carga.iter().sum(); - assert_eq!(carga_antes, carga_depois, "capacidade total conservada (M-R1)"); - assert!( - (perda_antes - perda_depois).abs() < 2.0 + 1e-6, - "perda auxiliar da família conservada: {perda_antes:.4} vs {perda_depois:.4}" - ); - } - - #[test] - fn mr2_neutralidade_no_nascimento() { - let dev = Device::Cpu; - let x = dados_sinteticos(32, 8, 5); - let moe = MoeRedirecionavel::novo(8, 4, 2, 32, &dev).unwrap(); - let g = moe.atencao.gate.as_tensor().to_scalar::().unwrap(); - assert!(g == 0.0, "gate nasce zero"); - let y = moe.atencao.fwd(&x).unwrap(); - let dif = (&y - &x).unwrap().sqr().unwrap().sum_all().unwrap().to_scalar::().unwrap(); - assert!(dif == 0.0, "y = x bit-a-bit no nascimento (dif={dif})"); - } - - #[test] - fn mr3_paralelismo_e_determinismo() { - let dev = Device::Cpu; - let x = dados_sinteticos(96, 24, 7); - let moe = MoeRedirecionavel::novo(24, 8, 2, 96, &dev).unwrap(); - let (_enc, _dec, t_par, t_seq, speedup) = moe.fwd_ambos_par(&x).unwrap(); - // determinismo já garantido por assert interno; speedup registrado - assert!(t_par > 0.0 && t_seq > 0.0); - let _ = speedup; - } - - #[test] - fn mr5_water_filling_minimiza_cota() { - // cota Σ q_i²/c_i: water-filling ≤ uniforme (Cauchy–Schwarz) - let qes = vec![0.2, 0.5, 1.0, 0.3]; - let c_wf = alocar_por_qe(&qes, 8); - let c_un = vec![2usize; 4]; - let f = |c: &[usize]| qes.iter().zip(c).map(|(q, ci)| q * q / *ci as f64).sum::(); - assert!( - f(&c_wf) <= f(&c_un) + 1e-9, - "water-filling {c_wf:?} (cota {:.4}) deve ≤ uniforme (cota {:.4})", - f(&c_wf), f(&c_un) - ); - assert_eq!(c_wf.iter().sum::(), 8); - } - - #[test] - fn jepa_moe_aprende() { - let x = dados_sinteticos(64, 12, 11); - let r = treinar_jepa_com_moe(&x, "moe", 60, 0.5, 42).unwrap(); - assert!(r.perda_pred_final < r.perda_pred_inicial, "perda preditiva cai"); - } - - /// **M-R6 (v0.8.0):** equivalência de VALORES entre `fwd` e - /// `forward` — mesma seleção (auxiliar compartilhado), mesma - /// saída, mesma perda auxiliar, mesma carga/descartados. - #[test] - fn mr6_equivalencia_de_valores() { - let dev = Device::Cpu; - for (n, d, e, k, cap, seed) in [ - (64usize, 16usize, 6usize, 2usize, 64usize, 3u64), - (96, 24, 8, 2, 96, 5), - (48, 12, 4, 1, 24, 9), // capacidade apertada: força descartados - ] { - let x = dados_sinteticos(n, d, seed); - let moe = MoeRedirecionavel::novo(d, e, k, cap, &dev).unwrap(); - let s_ref = moe.fwd(&x, Papel::Codificador).unwrap(); - let s_vet = moe.forward(&x, Papel::Codificador).unwrap(); - assert_eq!(s_ref.carga, s_vet.carga, "M-R6: mesma carga (n={n})"); - assert_eq!(s_ref.usados, s_vet.usados, "M-R6: mesmos usados"); - assert_eq!(s_ref.descartados, s_vet.descartados, "M-R6: mesmos descartados"); - let dif = (&s_ref.saida - &s_vet.saida).unwrap() - .abs().unwrap().max_all().unwrap().to_scalar::().unwrap(); - assert!(dif < 1e-4, "M-R6: max|Δsaída| = {dif} (n={n}, cap={cap})"); - let pa = s_ref.perda_aux.to_scalar::().unwrap(); - let pb = s_vet.perda_aux.to_scalar::().unwrap(); - assert!( - (pa - pb).abs() < 1e-4, - "M-R6: perda auxiliar {pa:.6} vs {pb:.6} (n={n})" - ); - } - } - - /// **M-R7 (v0.8.0):** restauração do fluxo de gradiente — bug v080-1. - /// Com a `fwd` (referência de valores) os especialistas e o roteador - /// NÃO recebem gradiente (grafo seccionado por to_vec2/from_vec); com - /// a `forward` TODOS recebem (index_add/index_select vivos). - #[test] - fn mr7_restauracao_do_gradiente() { - let dev = Device::Cpu; - let x = dados_sinteticos(48, 12, 13); - let moe = MoeRedirecionavel::novo(12, 6, 2, 48, &dev).unwrap(); - let norma_grads = |vetorizada: bool| -> (f64, f64) { - let s = if vetorizada { - moe.forward(&x, Papel::Codificador).unwrap() - } else { - moe.fwd(&x, Papel::Codificador).unwrap() - }; - let perda = s.saida.sqr().unwrap().sum_all().unwrap(); - let grads = perda.backward().unwrap(); - let mut n_roteador = 0.0f64; - for v in moe.roteador.vars() { - if let Some(g) = grads.get(&v) { - n_roteador += g.sqr().unwrap().sum_all().unwrap() - .to_scalar::().unwrap() as f64; - } - } - let mut n_experts = 0.0f64; - for e in &moe.especialistas { - for v in e.vars() { - if let Some(g) = grads.get(&v) { - n_experts += g.sqr().unwrap().sum_all().unwrap() - .to_scalar::().unwrap() as f64; - } - } - } - (n_roteador, n_experts) - }; - // (a) o bug v080-1 é REAL: na fwd, roteador e especialistas têm - // gradiente ZERO (grafo seccionado) — documentado, não corrigido na - // fwd (referência de valores preservada por decisão de projeto) - let (r_ref, e_ref) = norma_grads(false); - assert!( - r_ref == 0.0 && e_ref == 0.0, - "M-R7: bug v080-1 documentado — fwd secciona o grafo (roteador {r_ref}, experts {e_ref})" - ); - // (b) a correção: na vetorizada, TODOS recebem gradiente - let (r_vet, e_vet) = norma_grads(true); - assert!( - r_vet > 0.0, - "M-R7: roteador recebe gradiente na vetorizada ({r_vet})" - ); - assert!( - e_vet > 0.0, - "M-R7: especialistas recebem gradiente na vetorizada ({e_vet})" - ); - } - - /// **M-R8 (v0.8.0):** fim-a-fim — com a vetorizada, o treino REALMENTE - /// atualiza os pesos dos especialistas (regressão do bug v080-1: antes - /// só a atenção própria treinava no braço MoE). - #[test] - fn mr8_treino_atualiza_especialistas() { - let dev = Device::Cpu; - let x = dados_sinteticos(48, 12, 17); - let moe = MoeRedirecionavel::novo(12, 6, 2, 48, &dev).unwrap(); - // snapshot com dados PRÓPRIOS (to_vec1) — detach() compartilha o - // storage e o set() do otimizador sobrescreveria a "cópia" - let snapshot: Vec> = moe - .especialistas - .iter() - .map(|e| { - e.vars()[0].as_tensor().flatten_all().unwrap().to_vec1::().unwrap() - }) - .collect(); - // treino curto com gradiente fluindo - let vars = moe.vars(); - let mut opt = crate::treino::AdamWManual::novo(vars.clone(), 3e-3, 0.0); - for _ in 0..5 { - let s = moe.forward(&x, Papel::Codificador).unwrap(); - let perda = s.saida.sqr().unwrap().sum_all().unwrap(); - let grads = crate::treino::grads_achatados(&perda, &vars).unwrap(); - opt.passo(grads); - } - let mut delta_max = 0.0f64; - for (e, antes) in moe.especialistas.iter().zip(snapshot.iter()) { - let agora = e.vars()[0].as_tensor().flatten_all().unwrap() - .to_vec1::().unwrap(); - let dif = agora.iter().zip(antes.iter()).map(|(a, b)| (a - b).abs()).fold(0f32, f32::max); - delta_max = delta_max.max(dif as f64); - } - let _ = &vars; - assert!( - delta_max > 0.0, - "M-R8: especialistas devem mudar no treino (delta_max={delta_max})" - ); - } -} diff --git a/src/moe_redirecionavel/treino.rs b/src/moe_redirecionavel/treino.rs deleted file mode 100644 index 37f3710b0d287417e857af2a55ce31179add849a..0000000000000000000000000000000000000000 --- a/src/moe_redirecionavel/treino.rs +++ /dev/null @@ -1,463 +0,0 @@ -//! `moe_redirecionavel::treino` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -// --------------------------------------------------------------------------- -// Aplicação JEPA — codificador/preditor redirecionáveis com MoE -// --------------------------------------------------------------------------- - -pub struct RelatorioJepaMoe { - pub modo: &'static str, - pub perda_pred_inicial: f64, - pub perda_pred_final: f64, - pub perda_vc_final: f64, - pub std_emb: f64, - pub carga_max: usize, - pub descartados: usize, -} - -/// Treino JEPA compacto com três braços (ablação honesta): -/// - `"pequena"`: codificador/preditor MLP simples (baseline); -/// - `"densa"`: MLP com o TOTAL de parâmetros dos especialistas (capacidade -/// equiparada, SEM roteamento — isola o ganho do roteamento); -/// - `"moe"`: `MoeRedirecionavel` nos dois caminhos (Codificador no -/// codificador, Decodificador no preditor) com atenção própria. -pub fn treinar_jepa_com_moe( - patches: &Tensor, - modo: &'static str, - passos: usize, - frac_mascara: f64, - semente: u64, -) -> Result { - let dev = patches.device(); - let n = patches.dim(0)?; - let d = patches.dim(1)?; - let mut rng = RngDeterministico::novo(semente); - // alvo = patches originais (detach); contexto = patches mascarados - let alvo = patches.detach(); - let contexto = { - let mut v = patches.flatten_all()?.to_vec1::()?; - for x in v.iter_mut() { - if rng.uniforme() < frac_mascara { - *x = 0.0; - } - } - Tensor::from_vec(v, (n, d), &dev)? - }; - let e = 4usize; // especialistas por papel no braço moe - let n_top = 2; - let capacidade = n; - - // braços - enum Braco { - Pequena(MlpJepa, MlpJepa), - Densa(MlpJepa, MlpJepa), - Moe(MoeRedirecionavel), - } - let braco = match modo { - "pequena" => Braco::Pequena( - MlpJepa::novo(d, 2 * d, d, &dev)?, - MlpJepa::novo(d, 2 * d, d, &dev)?, - ), - "densa" => { - // capacidade equiparada: oculta = soma das ocultas dos especialistas - let d_oculta = 2 * d * e; - Braco::Densa( - MlpJepa::novo(d, d_oculta, d, &dev)?, - MlpJepa::novo(d, d_oculta, d, &dev)?, - ) - } - _ => Braco::Moe(MoeRedirecionavel::novo(d, 2 * e, n_top, capacidade, &dev)?), - }; - - let perda_de = |b: &Braco, x: &Tensor| -> Result<(Tensor, Tensor, usize)> { - match b { - Braco::Pequena(e1, p1) => { - let z = e1.fwd(x)?; - let yh = p1.fwd(&z)?; - let dif = (&yh - &alvo)?; - Ok(((dif.sqr()?.sum_all()? / (n as f64 * d as f64))?, - z.sqr()?.mean_all()?, 0)) - } - Braco::Densa(e1, p1) => { - let z = e1.fwd(x)?; - let yh = p1.fwd(&z)?; - let dif = (&yh - &alvo)?; - Ok(((dif.sqr()?.sum_all()? / (n as f64 * d as f64))?, - z.sqr()?.mean_all()?, 0)) - } - Braco::Moe(m) => { - // v0.9.0: forward (ex-fwd_vetorizado) — gradiente flui aos - // especialistas e ao roteador (a fwd seccionava o grafo) - let s_enc = m.forward(x, Papel::Codificador)?; - let s_dec = m.forward(&s_enc.saida, Papel::Decodificador)?; - let dif = (&s_dec.saida - &alvo)?; - let lp = (dif.sqr()?.sum_all()? / (n as f64 * d as f64))?; - // perda total = preditiva + aux balanceamento (ambos papéis) - let lt = (lp.affine(1.0, 0.0)? + s_enc.perda_aux.affine(m.lambda_aux, 0.0)? - + s_dec.perda_aux.affine(m.lambda_aux, 0.0)?)?; - let carga_max = s_enc.carga.iter().copied().fold(0, usize::max) - .max(s_dec.carga.iter().copied().fold(0, usize::max)); - Ok((lt, lp, carga_max)) - } - } - }; - - let (mut opt, vars): (AdamWManual, Vec) = match &braco { - Braco::Pequena(a, b) => { - let v = [a.vars(), b.vars()].concat(); - (AdamWManual::novo(v.clone(), 3e-3, 0.0), v) - } - Braco::Densa(a, b) => { - let v = [a.vars(), b.vars()].concat(); - (AdamWManual::novo(v.clone(), 3e-3, 0.0), v) - } - Braco::Moe(m) => (AdamWManual::novo(m.vars(), 3e-3, 0.0), m.vars()), - }; - // atenção própria: gate nasce 0; sobe 1 passo em 8 (aquecimento honesto - // do mecanismo — T-P5 análogo: neutralidade no nascimento, gradiente flui) - if let Braco::Moe(m) = &braco { - let g0 = m.atencao.gate.as_tensor().to_scalar::()? as f64; - let _ = g0; - } - - let (l0, _, _) = perda_de(&braco, &contexto)?; - let perda_inicial = l0.to_scalar::()? as f64; - let mut perda_final = perda_inicial; - let mut vc_final = 0.0; - let mut carga_max = 0usize; - let mut descartados = 0usize; - let mut std_emb = 0.0; - for passo in 0..passos { - let (lt, lp, cm) = perda_de(&braco, &contexto)?; - if let Braco::Moe(m) = &braco { - // abre o gate gradualmente (0 → 1 em 25% dos passos) - let alvo_g = ((passo as f64 / (passos as f64 / 4.0).max(1.0)).min(1.0)) as f32; - let g_atual = m.atencao.gate.as_tensor().to_scalar::()? as f64; - if (alvo_g as f64 - g_atual).abs() > 1e-9 { - m.atencao.gate.set(&Tensor::new(alvo_g, &dev)?)?; - } - } - let grads = crate::treino::grads_achatados(<, &vars)?; - AdamWManual::clipar(&mut grads.clone(), 1.0); - let mut g2 = grads; - AdamWManual::clipar(&mut g2, 5.0); - opt.passo(g2); - perda_final = lp.to_scalar::()? as f64; - carga_max = cm; - // VC / std do embedding (para o relatório) - let (_, vc, _) = perda_de(&braco, &contexto)?; - vc_final = vc.to_scalar::()? as f64; - std_emb = { - let z = match &braco { - Braco::Pequena(a, _) => a.fwd(&contexto)?, - Braco::Densa(a, _) => a.fwd(&contexto)?, - Braco::Moe(m) => m.forward(&contexto, Papel::Codificador)?.saida, - }; - z.flatten_all()?.to_vec1::()?.iter().map(|x| *x as f64).collect::>() - .chunks(n).map(|c| { - let m = c.iter().sum::() / c.len() as f64; - (c.iter().map(|x| (x - m).powi(2)).sum::() / c.len() as f64).sqrt() - }).sum::() / n as f64 - }; - } - if let Braco::Moe(m) = &braco { - let s = m.forward(&contexto, Papel::Codificador)?; - descartados = s.descartados; - } - Ok(RelatorioJepaMoe { - modo, - perda_pred_inicial: perda_inicial, - perda_pred_final: perda_final, - perda_vc_final: vc_final, - std_emb, - carga_max, - descartados, - }) -} - -// --------------------------------------------------------------------------- -// Aplicação SOM — refinamento residual com alocação por QE (M-R5) -// --------------------------------------------------------------------------- - -pub struct RelatorioSomMoe { - pub qe_antes: f64, - pub qe_depois: f64, - pub qe_alocacao_uniforme: f64, - pub carga_por_celula: Vec, - pub tempo_treino_s: f64, - /// qualidade da DECODIFICAÇÃO após redirecionamento (mse w_bmu → x). - pub mse_decodificador: f64, -} - -/// Refina um SOM 4D treinado com um MoE redirecionável: -/// 1. aloca especialistas por célula ∝ QE (water-filling — M-R5); -/// 2. treina o papel Codificador como corretor residual -/// `x̂ = w_bmu(x) + E(x)`; -/// 3. mede QE′; repete com alocação uniforme (ablação do water-filling); -/// 4. REDIRECIONA os especialistas para Decodificador e treina -/// `x̂ = E(w_bmu)` (reconstrução a partir do código) — mede o MSE. -pub fn refinar_som_com_moe( - dados: &Tensor, - centroides: &[Vec], - passos: usize, - semente: u64, -) -> Result { - use std::time::Instant; - let t0 = Instant::now(); - let dev = dados.device(); - let n = dados.dim(0)?; - let d = dados.dim(1)?; - let m = centroides.len(); - // BMU + QE por célula (tolera F32/F64) - let dados_v: Vec> = match dados.to_vec2::() { - Ok(v) => v, - Err(_) => dados - .to_vec2::()? - .iter() - .map(|l| l.iter().map(|x| *x as f64).collect()) - .collect(), - }; - let bmu: Vec = dados_v - .iter() - .map(|x| { - centroides - .iter() - .enumerate() - .min_by(|(i, a), (j, b)| { - let da: f64 = a.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum(); - let db: f64 = b.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum(); - da.partial_cmp(&db).unwrap_or(std::cmp::Ordering::Equal).then(i.cmp(j)) - }) - .map(|(i, _)| i) - .unwrap_or(0) - }) - .collect(); - let mut qe_cel = vec![0f64; m]; - let mut cont_cel = vec![0usize; m]; - for (i, b) in bmu.iter().enumerate() { - let dist: f64 = centroides[*b].iter().zip(&dados_v[i]).map(|(w, v)| (w - v).powi(2)).sum(); - qe_cel[*b] += dist.sqrt(); - cont_cel[*b] += 1; - } - for i in 0..m { - if cont_cel[i] > 0 { - qe_cel[i] /= cont_cel[i] as f64; - } - } - let qe_antes: f64 = dados_v - .iter() - .enumerate() - .map(|(i, b)| { - let w = ¢roides[bmu[i]]; - (w.iter().zip(b).map(|(a, v)| (a - v).powi(2)).sum::()).sqrt() - }) - .sum::() - / n as f64; - - // ---------- braço water-filling ---------- - // capacidade = m células + 8 especialistas EXTRA distribuídos ∝ QE - // (com C < m o water-filling degenera em uniforme — mínimo 1 por célula) - let capacidade_total = m + 8; - let aloca_wf = alocar_por_qe(&qe_cel, capacidade_total); - let qe_wf = treinar_corretor(dados, centroides, &bmu, &aloca_wf, passos, semente, &dev)?; - // ---------- braço uniforme (ablação: MESMO total e MESMA semente — - // única diferença é a alocação; round-robin soma exatamente C) ---------- - let aloca_un = { - let mut a = vec![1usize; m]; - let mut i = 0usize; - while a.iter().sum::() < capacidade_total { - a[i % m] += 1; - i += 1; - } - a - }; - let qe_un = treinar_corretor(dados, centroides, &bmu, &aloca_un, passos, semente, &dev)?; - - // ---------- redirecionamento → decodificador ---------- - // mesma pool de especialistas, agora aprendendo w_bmu → x - let mse_dec = treinar_decodificador(dados, centroides, &bmu, &aloca_wf, passos, semente + 2, &dev)?; - - Ok(RelatorioSomMoe { - qe_antes, - qe_depois: qe_wf, - qe_alocacao_uniforme: qe_un, - carga_por_celula: aloca_wf, - tempo_treino_s: t0.elapsed().as_secs_f64(), - mse_decodificador: mse_dec, - }) -} - -/// Corretor residual: x̂ = w_bmu + E_{célula}(x). Treina com AdamW. -fn treinar_corretor( - dados: &Tensor, - centroides: &[Vec], - bmu: &[usize], - alocacao: &[usize], - passos: usize, - semente: u64, - dev: &Device, -) -> Result { - let n = dados.dim(0)?; - let d = dados.dim(1)?; - // um "especialista" = MlpJepa por CÉLULA (capacidade alocada = nº de - // especialistas extra treinados nessa célula, somados em ensemble) - let n_esp_tot: usize = alocacao.iter().sum(); - let mut ensembles: Vec> = Vec::with_capacity(centroides.len()); - for c in alocacao { - let mut v = Vec::new(); - for _ in 0..(*c).max(1) { - v.push(MlpJepa::novo(d, 4 * d, d, dev)?); - } - ensembles.push(v); - } - let mut vars: Vec = Vec::new(); - for ens in &ensembles { - for e in ens { - vars.extend(e.vars()); - } - } - let mut opt = AdamWManual::novo(vars.clone(), 3e-3, 0.0); - // tensores de apoio - let w_bmu = { - let v: Vec = (0..n).flat_map(|i| centroides[bmu[i]].iter().map(|x| *x as f32).collect::>()).collect(); - Tensor::from_vec(v, (n, d), dev)? - }; - let alvo_res = (dados - &w_bmu)?; - for _ in 0..passos { - let mut soma = Tensor::zeros((), candle_core::DType::F32, dev)?; - for (i, ens) in ensembles.iter().enumerate() { - // tokens da célula i - let idx: Vec = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect(); - if idx.is_empty() { - continue; - } - let m_idx = idx.len(); - let it = Tensor::from_vec(idx, (m_idx,), dev)?; - let x_c = dados.index_select(&it, 0)?; - let r_c = alvo_res.index_select(&it, 0)?; - // ensemble: média das saídas - let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?; - for e in ens { - y = (y.affine(1.0, 0.0)? + e.fwd(&x_c)?.affine(1.0, 0.0)?)?; - } - let k = ens.len() as f64; - let yh = y.affine(1.0 / k, 0.0)?; - let dif = (&yh - &r_c)?; - soma = (soma.affine(1.0, 0.0)? + dif.sqr()?.sum_all()?.affine(1.0 / (n as f64 * d as f64), 0.0)?)?; - } - let _ = n_esp_tot; - let grads = crate::treino::grads_achatados(&soma, &vars)?; - let mut g = grads; - AdamWManual::clipar(&mut g, 5.0); - opt.passo(g); - } - // QE refinado - let mut qe = 0f64; - for (i, ens) in ensembles.iter().enumerate() { - let idx: Vec = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect(); - if idx.is_empty() { - continue; - } - let m_idx = idx.len(); - let it = Tensor::from_vec(idx, (m_idx,), dev)?; - let x_c = dados.index_select(&it, 0)?; - let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?; - for e in ens { - y = (y.affine(1.0, 0.0)? + e.fwd(&x_c)?.affine(1.0, 0.0)?)?; - } - let k = ens.len() as f64; - let yh = y.affine(1.0 / k, 0.0)?; - let xhat = (w_bmu.index_select(&it, 0)? + &yh)?; - let dif = (&x_c - &xhat)?; - qe += dif.sqr()?.sum_all()?.to_scalar::()? as f64; - } - Ok((qe / (n as f64 * d as f64)).sqrt() * (d as f64).sqrt()) // QE médio por ponto (norma L2) -} - -/// Decodificador (pós-redirecionamento): x̂ = E(w_bmu) — reconstrução -/// a partir apenas do código (centróide). Mede o MSE final. -fn treinar_decodificador( - dados: &Tensor, - centroides: &[Vec], - bmu: &[usize], - alocacao: &[usize], - passos: usize, - semente: u64, - dev: &Device, -) -> Result { - let _ = semente; - let n = dados.dim(0)?; - let d = dados.dim(1)?; - let mut ensembles: Vec> = Vec::with_capacity(centroides.len()); - for c in alocacao { - let mut v = Vec::new(); - for _ in 0..(*c).max(1) { - v.push(MlpJepa::novo(d, 4 * d, d, dev)?); - } - ensembles.push(v); - } - let mut vars: Vec = Vec::new(); - for ens in &ensembles { - for e in ens { - vars.extend(e.vars()); - } - } - let mut opt = AdamWManual::novo(vars.clone(), 3e-3, 0.0); - let w_bmu = { - let v: Vec = (0..n).flat_map(|i| centroides[bmu[i]].iter().map(|x| *x as f32).collect::>()).collect(); - Tensor::from_vec(v, (n, d), dev)? - }; - for _ in 0..passos { - let mut soma = Tensor::zeros((), candle_core::DType::F32, dev)?; - for (i, ens) in ensembles.iter().enumerate() { - let idx: Vec = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect(); - if idx.is_empty() { - continue; - } - let m_idx = idx.len(); - let it = Tensor::from_vec(idx, (m_idx,), dev)?; - let w_c = w_bmu.index_select(&it, 0)?; - let x_c = dados.index_select(&it, 0)?; - let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?; - for e in ens { - y = (y.affine(1.0, 0.0)? + e.fwd(&w_c)?.affine(1.0, 0.0)?)?; - } - let k = ens.len() as f64; - let yh = y.affine(1.0 / k, 0.0)?; - let dif = (&yh - &x_c)?; - soma = (soma.affine(1.0, 0.0)? + dif.sqr()?.sum_all()?.affine(1.0 / (n as f64 * d as f64), 0.0)?)?; - } - let grads = crate::treino::grads_achatados(&soma, &vars)?; - let mut g = grads; - AdamWManual::clipar(&mut g, 5.0); - opt.passo(g); - } - // MSE final do decodificador - let mut mse = 0f64; - for (i, ens) in ensembles.iter().enumerate() { - let idx: Vec = (0..n).filter(|&k| bmu[k] == i).map(|k| k as u32).collect(); - if idx.is_empty() { - continue; - } - let m_idx = idx.len(); - let it = Tensor::from_vec(idx, (m_idx,), dev)?; - let w_c = w_bmu.index_select(&it, 0)?; - let x_c = dados.index_select(&it, 0)?; - let mut y = Tensor::zeros((m_idx, d), candle_core::DType::F32, dev)?; - for e in ens { - y = (y.affine(1.0, 0.0)? + e.fwd(&w_c)?.affine(1.0, 0.0)?)?; - } - let k = ens.len() as f64; - let yh = y.affine(1.0 / k, 0.0)?; - let dif = (&yh - &x_c)?; - mse += dif.sqr()?.sum_all()?.to_scalar::()? as f64; - } - Ok(mse / (n as f64 * d as f64)) -} - -pub fn versao() -> &'static str { - "moe-redirecionavel-0.6.0" -} diff --git a/src/nlg.rs b/src/nlg.rs index c60d7587a67ea4e2d32780af6b5ad4f7728386ca..7081e51ce21942843ed77f635e0164d6b6286893 100644 --- a/src/nlg.rs +++ b/src/nlg.rs @@ -162,7 +162,7 @@ impl UnidadeNlg { } // normaliza logp por z-score robusto (mediana) let mut ordenado = logps.to_vec(); - ordenado.sort_by(|a, b| a.partial_cmp(b).unwrap()); + ordenado.sort_by(|a, b| a.total_cmp(b)); let med = ordenado[n / 2]; for (i, c) in candidatos.iter().enumerate() { let lp = logps[i] - med; @@ -258,7 +258,7 @@ impl DecodificadorEspeculativo { let take = self.c_por_cabeca.min(self.c_por_cabeca.saturating_sub(k).max(1)); let v = lg.flatten_all().unwrap().to_vec1::().unwrap(); let mut idx: Vec = (0..v.len()).collect(); - idx.sort_by(|&a, &b| v[b].partial_cmp(&v[a]).unwrap()); + idx.sort_by(|&a, &b| v[b].total_cmp(&v[a])); for t in idx.into_iter().take(take) { if !candidatos.contains(&t) { candidatos.push(t); diff --git a/src/pensamento.rs b/src/pensamento.rs index 35d7ee7a96d86ac5dcd3e7a57a0ad34f945864b8..144ebb48d64bad40afe6a1e553f327d2221184e7 100644 --- a/src/pensamento.rs +++ b/src/pensamento.rs @@ -117,8 +117,29 @@ pub struct ResultadoPensamento { pub telemetria: HashMap, } +/// Resultado dos limites de Lipschitz do gate (T-P5′, v0.10.0). +#[derive(Debug, Clone)] +pub struct LipschitzGate { + /// ‖y_ext − y_base‖ máximo medido (exato, computacional). + pub delta_max: f64, + /// cota a priori `m_extra_cota·(V_b_max + V_e_max)` (válida SEMPRE). + pub cota: f64, + /// massa extra máxima medida (valida `m_extra ≤ min(1, E·e^{s̄_e−s_b})`). + pub m_extra_max: f64, + pub m_extra_cota: f64, + /// (s̄_e,r, s_b,r) por linha de q — diagnóstico/telemetria. + pub s_por_linha: Vec<(f64, f64)>, + /// fórmula `‖q‖·K_e_max·V_e_max/√d` proposta pela crítica DeepSeek — + /// INVÁLIDA como cota (contraexemplo tp5_formula_deepseek_invalida). + pub formula_deepseek: f64, + pub n_q: usize, + _b: usize, +} + impl MotorPensamento { /// Cria o motor com N tentativas. `d_cond` = dim(a) + dim(b) + dim(c). + /// Usa o RNG global do candle (comportamento v0.10 preservado); para + /// determinismo bit-a-bit use [`MotorPensamento::novo_com_rng`]. pub fn novo( d_cond: usize, d_saida: usize, @@ -129,12 +150,7 @@ impl MotorPensamento { ) -> Result { let n = n.max(1); let tentativas = (0..n) - .map(|i| { - let mut m = MlpJepa::novo(d_cond, 2 * d_saida, d_saida, dev)?; - // heterogeneidade: re-semeia cada tentativa - let _ = i; - Ok(m) - }) + .map(|_| MlpJepa::novo(d_cond, 2 * d_saida, d_saida, dev)) .collect::>>()?; let combinador = Linear::sem_vies(d_saida * n, d_saida, 0.05, dev)?; let gate = Tensor::zeros((), candle_core::DType::F32, dev)?; @@ -150,6 +166,38 @@ impl MotorPensamento { }) } + /// **v0.11.0 (determinismo — débito r-34 §12 parcialmente pago):** + /// construtor SEMEADO do motor — as tentativas e o combinador saem do + /// `RngDeterministico` do chamador (nunca do RNG global do candle): + /// mesma semente ⇒ mesmo motor, bit-a-bit. Distribuição IDÊNTICA à do + /// `novo` (mesmas escalas 0,9/√d e 0,05 — só a fonte de ruído muda). + pub fn novo_com_rng( + d_cond: usize, + d_saida: usize, + n: usize, + limiar_conf: f64, + orcamento: usize, + dev: &Device, + rng: &mut crate::rng::RngDeterministico, + ) -> Result { + let n = n.max(1); + let tentativas = (0..n) + .map(|_| MlpJepa::novo_semeado(d_cond, 2 * d_saida, d_saida, dev, rng)) + .collect::>>()?; + let combinador = Linear::sem_vies_semeado(d_saida * n, d_saida, 0.05, dev, rng)?; + let gate = Tensor::zeros((), candle_core::DType::F32, dev)?; + Ok(Self { + tentativas, + combinador, + gate_atencao: Var::from_tensor(&gate)?, + n, + d_cond, + d_saida, + limiar_conf, + orcamento, + }) + } + pub fn vars(&self) -> Vec { let mut v: Vec = Vec::new(); for t in &self.tentativas { @@ -405,6 +453,159 @@ impl MotorPensamento { Ok((&y_base + &delta)?) } + /// v0.10.0 (T-P5′, crítica DeepSeek — análise r-35 §3.2): limites de + /// Lipschitz EXPLÍCITOS da mistura `y_int − y_base = g·Δ`. + /// + /// **Lema (identidade exata da massa extra).** Sejam `α` o softmax + /// sobre as chaves base e `β` o softmax sobre `[base; extra]`. Como + /// `β_j = e^{s_j}/(Z_b + Z_e)` e `α_j = e^{s_j}/Z_b`, vale + /// `β_j = α_j·(1 − m_extra)` para toda chave base j, com + /// `m_extra = Σ_{j∈extra} β_j = Z_e/(Z_b+Z_e) ∈ [0,1]`. Logo + /// `Δ = y_ext − y_base = Σ_{j∈extra}β_j·v_j − m_extra·y_base` e + /// + /// `‖Δ‖ ≤ m_extra·(‖y_base‖ + V_e_max) ≤ m_extra·(V_b_max + V_e_max)` + /// + /// com `m_extra ≤ min(1, E·e^{s̄_e − s_b_max})`, `s̄_e = ‖q‖·K_e_max/√d` + /// (logit extra máximo), `s_b_max` = logit base máximo. TODOS os fatores + /// são computáveis a priori (sem rodar a atenção combinada). + /// + /// **Refutação da fórmula proposta pela crítica** (`L = ‖q‖·K_e_max· + /// V_e_max/√d`): ela ignora o efeito de blindagem dos logits base — + /// com `s_b → −∞` toda a massa vai para as chaves extras + /// (`m_extra → 1`, `‖Δ‖ ≈ ‖v_e − y_base‖`) enquanto a fórmula pode ser + /// arbitramente PEQUENA (`‖q‖·‖k_e‖/√d → 0` com d grande e q⊥k_e) — + /// contraexemplo no teste `tp5_formula_deepseek_invalida`. + pub fn limites_gate( + &self, + q: &Tensor, + k_base: &Tensor, + v_base: &Tensor, + candidatos: &Tensor, + ) -> Result { + // mesmas projeções de atencao_integrada (d e d_v do contexto) + let dev = q.device(); + let d = k_base.dim(candle_core::D::Minus1)?; + let d_v = v_base.dim(candle_core::D::Minus1)?; + let b = q.dim(0)?; + let n_q = q.dim(1)?; + let cand = if self.d_saida == d { + candidatos.clone() + } else if self.d_saida > d { + let v = candidatos + .flatten_all()? + .to_vec1::()? + .chunks(self.d_saida) + .map(|c| c[..d].to_vec()) + .flatten() + .collect::>(); + Tensor::from_vec(v, (self.n, d), &dev)? + } else { + let mut v = candidatos.flatten_all()?.to_vec1::()?; + let mut linhas = Vec::new(); + for i in 0..self.n { + let mut linha = v[i * self.d_saida..(i + 1) * self.d_saida].to_vec(); + linha.extend(std::iter::repeat(0f32).take(d - self.d_saida)); + linhas.push(linha); + } + v = linhas.into_iter().flatten().collect(); + Tensor::from_vec(v, (self.n, d), &dev)? + }; + let k_extra = cand.broadcast_as((b, self.n, d))?; + let v_extra = if d_v == d { + k_extra.clone() + } else { + let media = k_extra.mean_keepdim(candle_core::D::Minus1)?; + media.broadcast_as((b, self.n, d_v))? + }; + // Δ medido (exato, via atencao_integrada com g=1... computa direto) + let delta = { + let k = Tensor::cat(&[k_base.clone(), k_extra.clone()], 1)?; + let v = Tensor::cat(&[v_base.clone(), v_extra.clone()], 1)?; + let scores = (q.matmul(&k.transpose(1, 2)?)? / (d as f64).sqrt())?; + let attn = candle_nn::ops::softmax(&scores, candle_core::D::Minus1)?; + let y_ext = attn.matmul(&v)?; + let scores_base = (q.matmul(&k_base.transpose(1, 2)?)? / (d as f64).sqrt())?; + let attn_base = candle_nn::ops::softmax(&scores_base, candle_core::D::Minus1)?; + let y_base = attn_base.matmul(v_base)?; + (&y_ext - &y_base)?.abs()?.max_all()?.to_scalar::()? as f64 + }; + // cota a priori: m_extra ≤ min(1, E·e^{s̄_e − s_b_max}) por linha + let q_norm: f64 = q + .sqr()? + .sum_keepdim(candle_core::D::Minus1)? + .sqrt()? + .max_all()? + .to_scalar::()? as f64; // max ‖q‖ por linha (só p/ referência) + let k_e_max: f64 = k_extra + .sqr()? + .sum_keepdim(candle_core::D::Minus1)? + .sqrt()? + .max_all()? + .to_scalar::()? as f64; // max ‖k_extra‖ + let v_e_max: f64 = v_extra + .sqr()? + .sum_keepdim(candle_core::D::Minus1)? + .sqrt()? + .max_all()? + .to_scalar::()? as f64; + let v_b_max: f64 = v_base + .sqr()? + .sum_keepdim(candle_core::D::Minus1)? + .sqrt()? + .max_all()? + .to_scalar::()? as f64; + // cota POR LINHA de q (válida linha a linha — usar máximos GLOBAIS de + // s_b subestimaria o denominador de linhas individuais): + // m_extra_r ≤ min(1, E·e^{s̄_e,r − s_b,r}), cota_r = m_extra_r·(V_b+V_e) + let s_e_por_linha = (q.matmul(&k_extra.transpose(1, 2)?)? / (d as f64).sqrt())? + .max_keepdim(candle_core::D::Minus1)?; // (b, n_q, 1) + let s_b_por_linha = (q.matmul(&k_base.transpose(1, 2)?)? / (d as f64).sqrt())? + .max_keepdim(candle_core::D::Minus1)?; // (b, n_q, 1) + let e_extra = self.n as f64; + // BUG v100-2 (meu, capturado pelo próprio teste): a primeira versão + // computava exp((Δs)·E) em vez de E·exp(Δs) — 5 ordens de magnitude + // abaixo do correto. Ordem correta: exp PRIMEIRO, depois ×E. + let m_por_linha = ((&s_e_por_linha - &s_b_por_linha)?.exp()? * e_extra)? + .clamp(0.0, 1.0)?; // min(1, E·e^{Δs}) por linha + let m_vals = m_por_linha.flatten_all()?.to_vec1::()?; + let m_extra_bnd = m_vals.iter().fold(0f64, |a, &x| a.max(x as f64)); + let se_v = s_e_por_linha.flatten_all()?.to_vec1::()?; + let sb_v = s_b_por_linha.flatten_all()?.to_vec1::()?; + let s_por_linha: Vec<(f64, f64)> = se_v + .iter() + .zip(&sb_v) + .map(|(&a, &b)| (a as f64, b as f64)) + .collect(); + let cota = m_extra_bnd * (v_b_max + v_e_max); + // massa extra MEDIDA (validação da cota intermediária) + let m_extra_med = { + let k = Tensor::cat(&[k_base.clone(), k_extra], 1)?; + let scores = (q.matmul(&k.transpose(1, 2)?)? / (d as f64).sqrt())?; + let attn = candle_nn::ops::softmax(&scores, candle_core::D::Minus1)?; + // soma das colunas extras (últimas n) por linha — máximo global + let todas = attn.flatten_all()?.to_vec1::()?; + let n_kv = k_base.dim(1)? + self.n; + let mut mx = 0f64; + for linha in todas.chunks(n_kv) { + let soma_extra: f32 = linha[k_base.dim(1)?..].iter().sum(); + mx = mx.max(soma_extra as f64); + } + mx + }; + // fórmula proposta pela crítica (para o contraexemplo do teste) + let formula_deepseek = q_norm * k_e_max * v_e_max / (d as f64).sqrt(); + Ok(LipschitzGate { + delta_max: delta, + cota, + m_extra_max: m_extra_med, + m_extra_cota: m_extra_bnd, + s_por_linha, + formula_deepseek, + n_q, + _b: b, + }) + } + // ----------------------------------------------------------------------- // v0.6.0 — verificador NCM (sem oráculo) + tentativas PARALELAS // ----------------------------------------------------------------------- @@ -966,6 +1167,180 @@ mod testes { assert!(dif == 0.0, "gate=0 deveria dar bit-a-bit, dif = {dif}"); } + // ----------------------------------------------------------------- + // v0.10.0 — T-P5′ (Lipschitz explícito) e T-P1′ (causalidade + // contrafactual). Crítica DeepSeek — provas em r-35 §3. + // ----------------------------------------------------------------- + + #[test] + fn teste_tp5_cota_valida_montecarlo() { + // T-P5′: a cota a priori m_extra·(V_b+V_e) domina o Δ medido em + // TODAS as 40 configurações aleatórias (e a massa extra medida + // respeita a cota por linha). A fórmula DeepSeek NÃO é checada + // aqui porque não é cota válida (teste abaixo refuta). + let dev = Device::Cpu; + let mut rng = RngDeterministico::novo(101); + for cfg_i in 0..40 { + let (n_q, n_kv, d, n) = (2, 5, 8usize, 3usize); + let motor = MotorPensamento::novo(d, d, n, 0.5, n, &dev).unwrap(); + let escala = if cfg_i % 2 == 0 { 1.0 } else { 3.0 }; + let q = Tensor::from_vec( + (0..n_q * d).map(|_| rng.normal(0.0, escala) as f32).collect::>(), + (1, n_q, d), &dev, + ).unwrap(); + let k = Tensor::from_vec( + (0..n_kv * d).map(|_| rng.normal(0.0, escala) as f32).collect::>(), + (1, n_kv, d), &dev, + ).unwrap(); + let v = Tensor::from_vec( + (0..n_kv * d).map(|_| rng.normal(0.0, escala) as f32).collect::>(), + (1, n_kv, d), &dev, + ).unwrap(); + let cand = Tensor::from_vec( + (0..n * d).map(|_| rng.normal(0.0, escala) as f32).collect::>(), + (n, d), &dev, + ).unwrap(); + let lg = motor.limites_gate(&q, &k, &v, &cand).unwrap(); + assert!( + lg.delta_max <= lg.cota + 1e-5, + "cfg {cfg_i}: Δ medido {medido:.4} > cota {cota:.4} (m_med={mm:.4e}, m_cota={mc:.4e})", + medido = lg.delta_max, + cota = lg.cota, + mm = lg.m_extra_max, + mc = lg.m_extra_cota + ); + assert!( + lg.m_extra_max <= lg.m_extra_cota + 1e-5, + "cfg {cfg_i}: m_extra {me:.4} > cota {mc:.4}", + me = lg.m_extra_max, + mc = lg.m_extra_cota + ); + } + } + + #[test] + fn teste_tp5_formula_deepseek_invalida() { + // REFUTAÇÃO da fórmula L = ‖q‖·max‖k_extra‖·max‖v_extra‖/√d: + // base com logits MUITO negativos (blindagem nula — toda a massa + // vai para as chaves extras) e q⊥k_e com d grande. O Δ real fica + // da ordem de ‖v_e‖ + ‖y_base‖ enquanto a fórmula ~ 1/√d → 0. + let dev = Device::Cpu; + let d = 4096usize; + let n = 1usize; + let motor = MotorPensamento::novo(d, d, n, 0.5, n, &dev).unwrap(); + // q = e_1 (norma 1); k_extra = e_2 (norma 1, ortogonal) — logit 0 + let mut qd = vec![0f32; d]; + qd[0] = 1.0; + let mut ked = vec![0f32; d]; + ked[1] = 1.0; + // valores: v_extra unitário; v_base idem (y_base = média convexa) + let mut ved = vec![0f32; d]; + ved[0] = 1.0; + let q = Tensor::from_vec(qd, (1, 1, d), &dev).unwrap(); + // base: 4 chaves ANTI-ALINHADAS com q (logit = −60 cada — a + // "blindagem" dos logits base é NULA: nenhuma chave base compete) + let mut kbd = vec![0f32; 4 * d]; + for i in 0..4 { + kbd[i * d] = -(60.0 * (d as f64).sqrt()) as f32; // q·k/√d = −60 + } + let k = Tensor::from_vec(kbd, (1, 4, d), &dev).unwrap(); + let mut vbd = vec![0f32; 4 * d]; + for i in 0..4 { + vbd[i * d + 1] = 1.0; + } + let v = Tensor::from_vec(vbd, (1, 4, d), &dev).unwrap(); + let cand = Tensor::from_vec(ved.clone(), (n, d), &dev).unwrap(); + let lg = motor.limites_gate(&q, &k, &v, &cand).unwrap(); + // Δ real: massa extra ≈ 1 ⇒ y_ext ≈ v_e = e_1; y_base = e_2 + // ⇒ componente máx de Δ ≈ 1 (medida = max-abs componente) + assert!( + lg.delta_max > 0.9, + "Δ medido {d:.4} deveria ser ~1 (massa extra domina)", + d = lg.delta_max + ); + assert!( + lg.delta_max > 10.0 * lg.formula_deepseek, + "fórmula DeepSeek {f:.6} deveria ser VIOLADA pelo Δ real {d:.4} (cota válida: {c:.4})", + f = lg.formula_deepseek, + d = lg.delta_max, + c = lg.cota + ); + // a NOSSA cota continua válida + assert!(lg.delta_max <= lg.cota + 1e-5); + } + + #[test] + fn teste_tp1_causalidade_contrfatual() { + // T-P1′ (formalização pedida pela crítica): a filtração + // 𝓕_t = σ(z_{1:t}, cond_{1:t}) — computacionalmente, o gatilho + // G_t = 1[conf(z_t) < τ_c] é INVARIANTE a perturbações + // contrafactuais do FUTURO (z_{t+1:T} re-amostrados). Rodando a + // sequência duas vezes com futuros independentes, o valor de G_t + // (e a confiança) deve ser IDÊNTICO em todos os t. + let dev = Device::Cpu; + let mut rng = RngDeterministico::novo(7); + let k = 8usize; + let mut zs: Vec> = Vec::new(); + for _ in 0..12 { + zs.push((0..k).map(|_| rng.normal(0.0, 1.5) as f32).collect()); + } + let conf_de = |z: &[f32]| -> f64 { + let t = Tensor::from_vec(z.to_vec(), (k,), &dev).unwrap(); + confianca_de_logits(&t).unwrap() + }; + let tau_c = 0.3f64; + // linha do tempo 1: futuros ORIGINAIS + let g1: Vec<(f64, bool)> = zs + .iter() + .map(|z| { + let c = conf_de(z); + (c, c < tau_c) + }) + .collect(); + // linha do tempo 2 (contrafactual): z_{t+1:} re-amostrados de + // distribuição DIFERENTE (futuro adversarial) — o passado é o mesmo + let mut zs2 = zs.clone(); + for z in zs2.iter_mut().skip(1) { + for v in z.iter_mut() { + *v = rng.normal(3.0, 4.0) as f32; // futuro completamente outro + } + } + let g2: Vec<(f64, bool)> = zs2 + .iter() + .map(|z| { + let c = conf_de(z); + (c, c < tau_c) + }) + .collect(); + // G_t para o MESMO t deve ser idêntico nas duas linhas do tempo + // (z_t não mudou em nenhuma posição: zs2[t] == zs[t] ∀t? NÃO — o + // contrafático muda CADA z_t independente; o teste correto é: + // conf(z_t) depende só de z_t — muda-se o FUTURO (a lista APÓS t) + // e o valor em t não pode mudar. Como cada conf é função de z_t + // isolado, verificamos a propriedade mais forte: igualdade + // pontual quando z_t é igual E invariância ao conteúdo dos outros. + for t in 0..zs.len() { + let c_a = conf_de(&zs[t]); + // futuro trocado, z_t preservado + let mut misto = zs.clone(); + for (i, z) in misto.iter_mut().enumerate() { + if i > t { + *z = (0..k).map(|_| rng.normal(9.0, 2.0) as f32).collect(); + } + } + let c_b = conf_de(&misto[t]); + assert!( + (c_a - c_b).abs() < 1e-12, + "causalidade violada: conf(z_{t}) mudou de {c_a} para {c_b} com o futuro perturbado" + ); + assert_eq!(c_a < tau_c, c_b < tau_c, "gatilho G_{t} não é causal"); + } + // sanity: as confianças das duas linhas do tempo DIFEREM (o + // contrafático realmente mudou os futuros) + let dif_algum = g1.iter().zip(&g2).any(|(a, b)| (a.0 - b.0).abs() > 1e-6); + assert!(dif_algum, "contrafático não mudou nada — teste vazio"); + } + #[test] fn teste_treino_cooperativo_e_agregacao() { // item a: as tentativas + combinador APRENDEM a função alvo; a @@ -1043,7 +1418,7 @@ mod testes { .collect(); let erro_media: f64 = media.iter().zip(alvo.iter()).map(|(m, a)| (m - a).abs()).sum(); let mut ordenado = erros.clone(); - ordenado.sort_by(|a, b| a.partial_cmp(b).unwrap()); + ordenado.sort_by(|a, b| a.total_cmp(b)); let mediana = ordenado[n / 2]; if erro_media <= mediana { venceu += 1; diff --git a/src/pensamento/combinador.rs b/src/pensamento/combinador.rs deleted file mode 100644 index 00e80bfc75a77ad9cf8a6c4705f05d20aa804be1..0000000000000000000000000000000000000000 --- a/src/pensamento/combinador.rs +++ /dev/null @@ -1,73 +0,0 @@ -//! `pensamento::combinador` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -// --------------------------------------------------------------------------- -// Combinador algébrico (T-P3 — projeção ridge, Teo V-1' portado) -// --------------------------------------------------------------------------- - -/// Projeção ridge: `r* = (WᵀW + εI)^{−1} Wᵀ r_alvo` — minimizador de -/// `‖W r − r_alvo‖² + ε‖r‖²` (o montador algébrico do "re-encaixe de peças"). -/// -/// **Prova (T-P3):** a função é quadrática estritamente convexa (ε > 0); -/// o gradiente anula-se exatamente em `r*` acima; o resíduo mínimo é -/// `‖(I − W(WᵀW+εI)^{−1}Wᵀ) r_alvo‖` — análogo direto do Teo V-1'. -pub fn projetar_ridge(w: &Tensor, r_alvo: &Tensor, eps: f64) -> Result { - // w: (m, n), r_alvo: (m, d) ⇒ r*: (n, d) - let n = w.dim(1)?; - let dev = w.device(); - let wt = w.transpose(0, 1)?; - let wtw = wt.matmul(w)?; - let ident = Tensor::eye(n, candle_core::DType::F32, &dev)?.affine(eps, 0.0)?; - let m = (&wtw + &ident)?; - let rhs = wt.matmul(r_alvo)?; - resolver_simetrica(&m, &rhs) -} - -/// Resolve `M x = B` para M simétrica (n, n) por eliminação de Gauss com -/// pivoteamento parcial (Cholesky não assumido — M pode ser só PSD+εI). -pub fn resolver_simetrica(m: &Tensor, b: &Tensor) -> Result { - let n = m.dim(0)?; - let d = b.dim(1)?; - let dev = m.device(); - let mut a = m.to_vec2::()?; - let mut rhs = b.to_vec2::()?; - for col in 0..n { - // pivoteamento parcial - let (mut pivo, mut linha_p) = (a[col][col].abs(), col); - for r in col + 1..n { - if a[r][col].abs() > pivo { - pivo = a[r][col].abs(); - linha_p = r; - } - } - if pivo < 1e-12 { - candle_core::bail!("matriz singular (pivo ~ 0 na coluna {col})"); - } - a.swap(col, linha_p); - rhs.swap(col, linha_p); - for r in col + 1..n { - let f = a[r][col] / a[col][col]; - for c in col..n { - a[r][c] -= f * a[col][c]; - } - for c in 0..d { - rhs[r][c] -= f * rhs[col][c]; - } - } - } - let mut x = vec![vec![0f32; d]; n]; - for r in (0..n).rev() { - for c in 0..d { - let mut s = rhs[r][c]; - for k in r + 1..n { - s -= a[r][k] * x[k][c]; - } - x[r][c] = s / a[r][r]; - } - } - let flat: Vec = x.into_iter().flatten().collect(); - Ok(Tensor::from_vec(flat, (n, d), &dev)?) -} diff --git a/src/pensamento/mod.rs b/src/pensamento/mod.rs deleted file mode 100644 index 5bb72c5c67cc70b7507004c8f659627dff4c7dfe..0000000000000000000000000000000000000000 --- a/src/pensamento/mod.rs +++ /dev/null @@ -1,71 +0,0 @@ -//! Tecnologia Pensamento — módulos: motor, combinador ridge, -//! quebra-cabeça pós-treino (divisão SRP v0.10.0 — r-35 §2). - -//! Tecnologia **Pensamento** v0.5.0 — N-redes neurais flexíveis paralelizadas -//! integradas ao NCM, conectadas ao Mecanismo de Atenção, com raciocínio -//! temporal-estratégico (item d = a + b + c). -//! -//! **O que é (motivação do usuário):** Pensamento é semelhante ao -//! pós-treinamento — N-redes paralelas de tentativas cooperativas para -//! resolver o problema do item c (requisição do usuário) quando a -//! informação tem POUCA CONFIANÇA para gerar novo conhecimento (fora dos -//! padrões comuns), a partir de: -//! - **a)** conhecimento aprendido durante o treinamento; -//! - **b)** estado de inferência corrente; -//! - **c)** a requisição (prompt) do usuário; -//! e da ativação de **difusores** (exploração estocástica) e -//! **combinadores/montadores** (re-encaixe de peças por projeção algébrica). -//! -//! **Ciclo d (raciocínio temporal-estratégico):** -//! `planejamento → construção de etapas e distribuição/desmembramento de -//! competências → volta ao planejamento OU envio da resposta ao usuário`. -//! -//! **Provas (completas em `docs/memorias/r-21-provas-pensamento-v050.md`):** -//! - **T-P1 (gatilho mensurável e causal):** o gatilho -//! `1{conf(p) < τ_c}` com `conf = 1 − H(p)/log K` é função apenas da -//! distribuição preditiva CORRENTE — não transporta informação do futuro, -//! preservando a causalidade (mesma estrutura do gate G1 do NCM). -//! - **T-P2 (tentativas paralelas — auto-consistência):** com N tentativas -//! independentes, cada uma correta com prob. `p > 1/2`, a votação por -//! maioria tem `P(erro) ≤ exp(−2N(p−1/2)²)` (Hoeffding); com seleção -//! best-of-N por verificador exato, `P(sucesso) ≥ 1−(1−p)^N`. -//! - **T-P3 (combinador ótimo):** o montador por mínimos quadrados com -//! regularização ridge resolve `r* = (WᵀW+εI)^{−1}Wᵀr_alvo` — o resíduo é -//! o MÍNIMO possível na norma (pseudo-inversa, Teo V-1' do outro agente). -//! - **T-P4 (terminação e soundness do planejador):** o potencial -//! `Φ(k) = B − k` decresce estritamente a cada iteração do ciclo d ⇒ o -//! loop termina em ≤ B iterações (indução bem-fundada); a resposta só é -//! emitida com confiança ≥ τ_c OU com orçamento esgotado (declaração -//! honesta de queda de confiança na telemetria). -//! - **T-P5 (neutralidade no nascimento na atenção):** com o gate de -//! atenção das tentativas inicializado em ZERO, a saída da atenção é -//! bit-a-bit a da atenção base; a perturbação é limitada por -//! `‖Δy‖ ≤ L·|g|·‖W_k z‖` (Lipschitz com constante L do softmax). -//! - **T-P6 (composição d = a + b + c):** o condicionamento de cada -//! tentativa é `cond = [a; b; c]` — a estrutura de independência -//! condicional `p(resposta | a, b, c)` fatoriza pelo estado conjunto; as -//! tentativas só veem o PASSADO (causalidade preservada). - -use candle_core::{Device, Result, Tensor, Var}; -use crate::camadas::Linear; -use crate::jepa::MlpJepa; -use crate::rng::RngDeterministico; -use std::collections::HashMap; - -// ---- divisão SRP v0.10.0 (r-35 §2): submódulos + re-exports ---- -#[cfg(test)] -mod testes; -mod combinador; -mod motor; -mod quebra_cabeca; - -pub use combinador::*; -pub use motor::*; -pub use quebra_cabeca::*; - -// ---- itens mantidos no próprio mod.rs ---- - - -pub fn versao() -> &'static str { - "pensamento-0.7.0" -} diff --git a/src/pensamento/motor.rs b/src/pensamento/motor.rs deleted file mode 100644 index bc7f0ddcfa5a9c3b8a1b7aaaba1fc7fc4f4785f5..0000000000000000000000000000000000000000 --- a/src/pensamento/motor.rs +++ /dev/null @@ -1,549 +0,0 @@ -//! `pensamento::motor` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -// --------------------------------------------------------------------------- -// Confiança e gatilho (T-P1) -// --------------------------------------------------------------------------- - -/// Confiança da distribuição preditiva: `conf = 1 − H(softmax(z))/log K`. -/// -/// **T-P1:** conf é função mensurável de `z` (diferenciável exceto em -/// medida zero), invariante a translação dos logits e satisfaz -/// `conf = 1` na massa de Dirac e `conf = 0` na uniforme — gatilho correto -/// para "pouca confiança". -pub fn confianca_de_logits(logits: &Tensor) -> Result { - let p = candle_nn::ops::softmax(logits, candle_core::D::Minus1)?; - let logp = p.log()?; - let entropia = (&p * &logp)?.sum_all()?.to_scalar::()? as f64 * -1.0; - let k = logits.dim(candle_core::D::Minus1)? as f64; - if k <= 1.0 { - return Ok(1.0); - } - Ok(1.0 - entropia / k.ln()) -} - -// --------------------------------------------------------------------------- -// Motor de Pensamento -// --------------------------------------------------------------------------- - -pub struct MotorPensamento { - /// N redes de tentativa (flexíveis: heterogêneas por semente de - /// inicialização e por ruído de exploração). - pub tentativas: Vec, - /// Montador/combinador: concatena as N saídas → resposta agregada. - pub combinador: Linear, - /// Gate de atenção (T-P5): inicializado em ZERO (neutralidade no - /// nascimento). Escalar multiplicativo sobre a contribuição das - /// tentativas na atenção. - pub gate_atencao: Var, - pub n: usize, - pub d_cond: usize, - pub d_saida: usize, - /// limiar de confiança para emitir resposta (T-P4 soundness). - pub limiar_conf: f64, - /// orçamento de iterações do ciclo d (T-P4 terminação). - pub orcamento: usize, -} - -#[derive(Debug, Clone)] -pub enum EventoCiclo { - Planejamento { iteracao: usize, temperatura: f64 }, - DistribuicaoCompetencias { por_tentativa: Vec }, - RePlanejamento { motivo: String }, - Resposta { confianca: f64, iteracoes: usize }, -} - -#[derive(Debug, Clone)] -pub struct ResultadoPensamento { - /// resposta agregada (d_saida,). - pub resposta: Option, - /// candidatos das N tentativas na última iteração (n, d_saida). - pub candidatos: Tensor, - /// pesos do combinador na agregação final (positivos, soma ~1). - pub pesos: Vec, - /// confiança do verificador na resposta emitida (ou da última tentativa). - pub confianca: f64, - /// nº de iterações do ciclo d executadas. - pub iteracoes: usize, - pub trajetoria: Vec, - pub telemetria: HashMap, -} - -impl MotorPensamento { - /// Cria o motor com N tentativas. `d_cond` = dim(a) + dim(b) + dim(c). - pub fn novo( - d_cond: usize, - d_saida: usize, - n: usize, - limiar_conf: f64, - orcamento: usize, - dev: &Device, - ) -> Result { - let n = n.max(1); - let tentativas = (0..n) - .map(|i| { - let mut m = MlpJepa::novo(d_cond, 2 * d_saida, d_saida, dev)?; - // heterogeneidade: re-semeia cada tentativa - let _ = i; - Ok(m) - }) - .collect::>>()?; - let combinador = Linear::sem_vies(d_saida * n, d_saida, 0.05, dev)?; - let gate = Tensor::zeros((), candle_core::DType::F32, dev)?; - Ok(Self { - tentativas, - combinador, - gate_atencao: Var::from_tensor(&gate)?, - n, - d_cond, - d_saida, - limiar_conf, - orcamento, - }) - } - - pub fn vars(&self) -> Vec { - let mut v: Vec = Vec::new(); - for t in &self.tentativas { - v.extend(t.vars()); - } - v.extend(self.combinador.vars()); - v.push(self.gate_atencao.clone()); - v - } - - /// Re-semeia a tentativa `i` com ruído (heterogeneidade estrutural — - /// "redes flexíveis"): injeta perturbação gaussiana nos pesos. - pub fn flexibilizar(&mut self, i: usize, amplitude: f64, rng: &mut RngDeterministico) -> Result<()> { - let t = &mut self.tentativas[i]; - for v in t.vars() { - let forma: Vec = v.dims().to_vec(); - let total: usize = forma.iter().product(); - let ruido: Vec = (0..total).map(|_| rng.normal(0.0, amplitude) as f32).collect(); - let rt = Tensor::from_vec(ruido, forma, v.device())?; - v.set(&(v.as_tensor().affine(1.0, 0.0)? + rt.affine(1.0, 0.0)?)?)?; - } - Ok(()) - } - - /// Candidatos das N tentativas para o condicionamento `cond` (d_cond,) - /// com temperatura de difusor `temp` (ruído exploratório nas saídas). - /// - /// **T-P6:** `cond = [a; b; c]` — as tentativas veem exatamente a união - /// dos três estados; nada do futuro entra. - pub fn candidatos(&self, cond: &Tensor, temp: f64, rng: &mut RngDeterministico) -> Result { - let dev = cond.device(); - let mut saidas: Vec = Vec::with_capacity(self.n); - let cond_b = if cond.dims().len() == 1 { - cond.broadcast_as((1, self.d_cond))? - } else { - cond.clone() - }; - for t in &self.tentativas { - let o = t.fwd(&cond_b)?; - let o = if temp > 0.0 { - let total = self.d_saida; - let ruido: Vec = - (0..total).map(|_| rng.normal(0.0, temp as f64) as f32).collect(); - let rt = Tensor::from_vec(ruido, (1, self.d_saida), &dev)?; - (o.clone() + rt.affine(1.0, 0.0)?)? - } else { - o - }; - saidas.push(o); - } - Ok(Tensor::cat(&saidas, 0)?) // (n, d_saida) - } - - /// **Combinador/montador (T-P3):** agregação por pesos de coerência — - /// tentativas que concordam com o consenso recebem mais peso (voto - /// contínuo), seguido da projeção linear aprendida do combinador. - pub fn agregar(&self, candidatos: &Tensor) -> Result<(Tensor, Vec)> { - let consenso = candidatos.mean_keepdim(0)?; // (1, d) - // pesos de coerência: similaridade de cosseno com o consenso - let dot = candidatos.matmul(&consenso.transpose(0, 1)?)?; // (n, 1) - let nc = candidatos.sqr()?.sum_keepdim(candle_core::D::Minus1)?.sqrt()?; - let ncs = consenso.sqr()?.sum_keepdim(candle_core::D::Minus1)?.sqrt()?; - let cos = dot.broadcast_div(&nc.broadcast_mul(&ncs)?)?; // (n, 1) - let cos_v = cos.flatten_all()?.to_vec1::()?; - let exps: Vec = cos_v.iter().map(|c| (*c as f64 * 4.0).exp()).collect(); - let soma: f64 = exps.iter().sum(); - let pesos: Vec = exps.iter().map(|e| e / soma).collect(); - // média ponderada = "peças re-encaixadas" - let mut media = Tensor::zeros((1, self.d_saida), candle_core::DType::F32, candidatos.device())?; - for (i, p) in pesos.iter().enumerate() { - let linha = candidatos.get(i)?.broadcast_as((1, self.d_saida))?; - media = (media.affine(1.0, 0.0)? + linha.affine(*p, 0.0)?)?; - } - // montagem final pelo combinador aprendido - let concat = candidatos.flatten_all()?.broadcast_as((1, self.d_saida * self.n))?; - let montado = self.combinador.fwd(&concat)?; - // mistura 50/50: montagem aprendida + consenso ponderado (o - // combinador pode especializar-se; o consenso dá robustez T-P2) - let resposta = (montado.affine(0.5, 0.0)? + media.affine(0.5, 0.0)?)?; - Ok((resposta, pesos)) - } - - /// **Ciclo d completo (T-P4):** planejar → distribuir → agregar → - /// avaliar → (re-planejar | responder). O verificador externo devolve a - /// confiança `[0,1]` de uma resposta candidata. - pub fn raciocinar( - &mut self, - cond: &Tensor, - verificador: &dyn Fn(&Tensor) -> f64, - rng: &mut RngDeterministico, - ) -> Result { - let mut trajetoria = Vec::new(); - let mut telemetria: HashMap = HashMap::new(); - let mut temperatura = 0.1f64; - let mut melhor = (None::, -1.0f64, Vec::::new()); - let mut iteracoes = 0usize; - let mut candidatos_final = Tensor::zeros( - (self.n, self.d_saida), - candle_core::DType::F32, - cond.device(), - )?; - - loop { - iteracoes += 1; - // (1) PLANEJAMENTO: gerar candidatos com a temperatura corrente - trajetoria.push(EventoCiclo::Planejamento { iteracao: iteracoes, temperatura }); - let candidatos = self.candidatos(cond, temperatura, rng)?; - candidatos_final = candidatos.clone(); - // (2) DISTRIBUIÇÃO/DESMEMBRAMENTO DE COMPETÊNCIAS: pesos por - // coerência (quem concorda mais lidera a montagem) - let (resposta, pesos) = self.agregar(&candidatos)?; - trajetoria.push(EventoCiclo::DistribuicaoCompetencias { por_tentativa: pesos.clone() }); - // (3) AVALIAÇÃO pelo verificador - let conf = verificador(&resposta); - telemetria.insert(format!("conf_iter_{}", iteracoes), conf); - if conf > melhor.1 { - melhor = (Some(resposta), conf, pesos.clone()); - } - // (4) DECISÃO: responder ou re-planejar - if conf >= self.limiar_conf { - trajetoria.push(EventoCiclo::Resposta { confianca: conf, iteracoes }); - telemetria.insert("iteracoes".into(), iteracoes as f64); - telemetria.insert("confianca_final".into(), conf); - telemetria.insert("temperatura_final".into(), temperatura); - return Ok(ResultadoPensamento { - resposta: melhor.0, - candidatos: candidatos_final, - pesos: melhor.2, - confianca: conf, - iteracoes, - trajetoria, - telemetria, - }); - } - if iteracoes >= self.orcamento { - // Φ = B − k atingiu 0: termina SEM confiança — honestidade - trajetoria.push(EventoCiclo::Resposta { confianca: melhor.1, iteracoes }); - telemetria.insert("iteracoes".into(), iteracoes as f64); - telemetria.insert("confianca_final".into(), melhor.1); - telemetria.insert("temperatura_final".into(), temperatura); - telemetria.insert("orcamento_esgotado".into(), 1.0); - return Ok(ResultadoPensamento { - resposta: melhor.0, - candidatos: candidatos_final, - pesos: melhor.2, - confianca: melhor.1, - iteracoes, - trajetoria, - telemetria, - }); - } - // (5) RE-PLANEJAMENTO: aumenta a exploração (difusor mais quente) - temperatura = (temperatura * 1.6).min(2.0); - trajetoria.push(EventoCiclo::RePlanejamento { - motivo: format!("confiança {conf:.3} < limiar {}", self.limiar_conf), - }); - } - } - - /// **Perda de treino das tentativas + combinador (item a):** treino - /// cooperativo — cada tentativa minimiza sua perda contra o alvo E o - /// combinador minimiza a perda da agregação (o gradiente flui para - /// todos através do concat). - pub fn perda_treino(&self, cond: &Tensor, alvo: &Tensor) -> Result { - // cond (b, d_cond), alvo (b, d_saida) - let b = cond.dim(0)?; - let mut perdas: Vec = Vec::new(); - let mut saidas: Vec = Vec::with_capacity(self.n); - for t in &self.tentativas { - let o = t.fwd(cond)?; - let dif = (&o - alvo)?; - perdas.push((dif.sqr()?.sum_all()? / (self.d_saida as f64 * b as f64))?); - saidas.push(o); - } - let concat = Tensor::cat(&saidas, candle_core::D::Minus1)?; // (b, n·d) - let montado = self.combinador.fwd(&concat)?; - let dif_m = (&montado - alvo)?; - perdas.push((dif_m.sqr()?.sum_all()? / (self.d_saida as f64 * b as f64))?); - // soma das perdas (cooperação: todas as redes + montador) - let mut total = perdas[0].clone(); - for p in perdas.iter().skip(1) { - total = (total + p.clone())?; - } - Ok(total) - } - - /// **Integração com o mecanismo de atenção (T-P5):** anexa as saídas das - /// tentativas como chaves/valores extra com gate escalar. - /// - /// Com `gate = 0` (nascimento): saída IDÊNTICA à atenção base - /// (neutralidade); o gradiente flui pelo gate (não-degenerado). - pub fn atencao_integrada( - &self, - q: &Tensor, - k_base: &Tensor, - v_base: &Tensor, - candidatos: &Tensor, - ) -> Result { - // q (b, n_q, d), k_base (b, n_kv, d), v_base (b, n_kv, d_v), - // candidatos (n_tent, d) — projetados para d e d_v - let dev = q.device(); - let d = k_base.dim(candle_core::D::Minus1)?; - let d_v = v_base.dim(candle_core::D::Minus1)?; - let b = q.dim(0)?; - // projeta candidatos (média simples — sem parâmetros extra): os - // candidatos têm d_saida; se d == d_saida usa direto, senão padding/ - // truncamento honesto - let cand = if self.d_saida == d { - candidatos.clone() - } else if self.d_saida > d { - let v = candidatos - .flatten_all()? - .to_vec1::()? - .chunks(self.d_saida) - .map(|c| c[..d].to_vec()) - .flatten() - .collect::>(); - Tensor::from_vec(v, (self.n, d), &dev)? - } else { - let mut v = candidatos.flatten_all()?.to_vec1::()?; - let mut linhas = Vec::new(); - for i in 0..self.n { - let mut linha = v[i * self.d_saida..(i + 1) * self.d_saida].to_vec(); - linha.extend(std::iter::repeat(0f32).take(d - self.d_saida)); - linhas.push(linha); - } - v = linhas.into_iter().flatten().collect(); - Tensor::from_vec(v, (self.n, d), &dev)? - }; - let k_extra = cand.broadcast_as((b, self.n, d))?; - let v_extra = if d_v == d { - k_extra.clone() - } else { - // projeção simples por média de colunas quando d_v != d - let media = k_extra.mean_keepdim(candle_core::D::Minus1)?; - media.broadcast_as((b, self.n, d_v))? - }; - // atenção sobre [base; extra] - let k = Tensor::cat(&[k_base.clone(), k_extra], 1)?; - let v = Tensor::cat(&[v_base.clone(), v_extra], 1)?; - let scores = (q.matmul(&k.transpose(1, 2)?)? / (d as f64).sqrt())?; - let attn = candle_nn::ops::softmax(&scores, candle_core::D::Minus1)?; - let y_base_e_extra = attn.matmul(&v)?; - // atenção apenas-base (para neutralidade: gate = 0 ⇒ saída = base) - let scores_base = (q.matmul(&k_base.transpose(1, 2)?)? / (d as f64).sqrt())?; - let attn_base = candle_nn::ops::softmax(&scores_base, candle_core::D::Minus1)?; - let y_base = attn_base.matmul(v_base)?; - // mistura: y = y_base + gate·(y_completo − y_base) - let g = self.gate_atencao.as_tensor(); - let delta = (&y_base_e_extra - &y_base)?; - let forma: Vec = delta.dims().to_vec(); - let delta = (delta.affine(1.0, 0.0)? * g.broadcast_as(forma)?)?; - Ok((&y_base + &delta)?) - } - - // ----------------------------------------------------------------------- - // v0.6.0 — verificador NCM (sem oráculo) + tentativas PARALELAS - // ----------------------------------------------------------------------- - - /// Candidatos das N tentativas em PARALELO (rayon) — as N redes têm - /// parâmetros disjuntos e entradas idênticas ⇒ N sub-DAGs independentes - /// no grafo de computação (mesma estrutura da prova M-R3): tempo - /// paralelo = max_i T_i + sobrecarga de agendamento. - /// Determinismo: o ruído da tentativa i usa a semente `semente + i` - /// (fluxos independentes por construção — reprodutível em qualquer - /// nº de threads). - pub fn candidatos_par( - &self, - cond: &Tensor, - temp: f64, - semente: u64, - ) -> Result<(Tensor, f64)> { - use rayon::prelude::*; - let dev = cond.device(); - let cond_b = if cond.dims().len() == 1 { - cond.broadcast_as((1, self.d_cond))? - } else { - cond.clone() - }; - let t0 = std::time::Instant::now(); - let saidas: Vec = self - .tentativas - .par_iter() - .enumerate() - .map(|(i, t)| -> Result { - let o = t.fwd(&cond_b)?; - if temp > 0.0 { - let mut rng = RngDeterministico::novo(semente + i as u64); - let ruido: Vec = - (0..self.d_saida).map(|_| rng.normal(0.0, temp) as f32).collect(); - let rt = Tensor::from_vec(ruido, (1, self.d_saida), &dev)?; - Ok((&o + &rt.affine(1.0, 0.0)?)?) - } else { - Ok(o) - } - }) - .collect::>>()?; - let dt = t0.elapsed().as_secs_f64(); - Ok((Tensor::cat(&saidas, 0)?, dt)) // (n, d_saida), tempo paralelo - } - - /// **Variante em LOTE (v0.6.0 — fase C):** cond (b, d_cond) → - /// candidatos (b, n, d_saida) — as N tentativas processam o lote - /// inteiro (paralelas entre si; ruído por (linha, tentativa) com - /// semente determinística `semente + i`). - pub fn candidatos_lote(&self, cond: &Tensor, temp: f64, semente: u64) -> Result { - let b = cond.dim(0)?; - let dev = cond.device(); - let mut saidas: Vec = Vec::with_capacity(self.n); - for (i, t) in self.tentativas.iter().enumerate() { - let o = t.fwd(cond)?; // (b, d_saida) - let o = if temp > 0.0 { - let mut rng = RngDeterministico::novo(semente + i as u64); - let ruido: Vec = (0..b * self.d_saida) - .map(|_| rng.normal(0.0, temp) as f32) - .collect(); - let rt = Tensor::from_vec(ruido, (b, self.d_saida), &dev)?; - (&o + &rt)? - } else { - o - }; - saidas.push(o.unsqueeze(1)?); // (b, 1, d_saida) - } - Ok(Tensor::cat(&saidas, 1)?) // (b, n, d_saida) - } - - /// **Agregação em LOTE (v0.6.0):** candidatos (b, n, d) → resposta - /// (b, d) — mesma mistura 50/50 (montagem aprendida + consenso - /// ponderado por coerência) da versão 1-D, VETORIZADA e totalmente - /// diferenciável (gradiente flui pelos DOIS caminhos). Devolve também - /// os pesos médios (telemetria). - pub fn agregar_lote(&self, candidatos: &Tensor) -> Result<(Tensor, Vec)> { - let b = candidatos.dim(0)?; - let n = candidatos.dim(1)?; - let d = candidatos.dim(2)?; - let dev = candidatos.device(); - // consenso (b, d) - let consenso = candidatos.mean(1)?; - // cosseno por (b, n): ⟨cand_i, consenso⟩ / (‖cand_i‖·‖consenso‖) - let dot = candidatos.matmul(&consenso.unsqueeze(2)?)?; // (b, n, 1) - let nc = candidatos.sqr()?.sum_keepdim(candle_core::D::Minus1)?.sqrt()?; // (b, n, 1) - let ncs = consenso.sqr()?.sum_keepdim(candle_core::D::Minus1)?.sqrt()?.unsqueeze(1)?; // (b, 1, 1) - let cos = dot.broadcast_div(&nc.broadcast_mul(&ncs)?)?; // (b, n, 1) - // pesos softmax de coerência (b, n, 1) — tensor puro (grafo intacto) - let exps = cos.affine(4.0, 0.0)?.exp()?; - let soma = exps.sum_keepdim(1)?; // (b, 1, 1) - let pesos = exps.broadcast_div(&soma)?; // (b, n, 1) - // média ponderada: Σ_n pesos·cand → (b, d) - let media = candidatos.broadcast_mul(&pesos)?.sum(1)?; // (b, d) - // montagem aprendida: concat sobre n → combinador - let concat = candidatos.reshape((b, n * d))?; - let montado = self.combinador.fwd(&concat)?; // (b, d) - let resposta = (montado.affine(0.5, 0.0)? + media.affine(0.5, 0.0)?)?; - // pesos médios para telemetria (leitura — não afeta o grafo) - let pesos_v = pesos.flatten_all()?.to_vec1::()?; - let mut pesos_medios = vec![0f64; n]; - for (k, p) in pesos_v.iter().enumerate() { - pesos_medios[k % n] += *p as f64 / b as f64; - } - let _ = d; - let _ = dev; - Ok((resposta, pesos_medios)) - } - - /// **Ciclo d com o VERIFICADOR NCM (v0.6.0 — fecha o débito r-21 §3.1).** - /// - /// `logits_fn` mapeia uma resposta candidata (1, d_saida) → logits da - /// distribuição preditiva do BACKBONE condicionada à correção (passada - /// corrente — V-4 causal). O verificador calibrado devolve a confiança; - /// NENHUM acesso ao alvo verdadeiro (o oráculo morre aqui). - pub fn raciocinar_ncm( - &mut self, - cond: &Tensor, - verificador: &crate::verificador::VerificadorNcm, - logits_fn: &dyn Fn(&Tensor) -> Result, - rng: &mut RngDeterministico, - ) -> Result { - let mut trajetoria = Vec::new(); - let mut telemetria: HashMap = HashMap::new(); - let mut temperatura = 0.1f64; - let mut melhor = (None::, -1.0f64, Vec::::new()); - let mut iteracoes = 0usize; - let mut candidatos_final = Tensor::zeros( - (self.n, self.d_saida), - candle_core::DType::F32, - cond.device(), - )?; - loop { - iteracoes += 1; - trajetoria.push(EventoCiclo::Planejamento { iteracao: iteracoes, temperatura }); - let candidatos = self.candidatos(cond, temperatura, rng)?; - candidatos_final = candidatos.clone(); - let (resposta, pesos) = self.agregar(&candidatos)?; - trajetoria.push(EventoCiclo::DistribuicaoCompetencias { por_tentativa: pesos.clone() }); - // AVALIAÇÃO pelo VERIFICADOR NCM (sem oráculo): confiança - // calibrada da distribuição preditiva do backbone - let logits = logits_fn(&resposta)?; - let conf = verificador.confianca_1d(&logits)?; - telemetria.insert(format!("conf_iter_{}", iteracoes), conf); - if conf > melhor.1 { - melhor = (Some(resposta), conf, pesos.clone()); - } - if conf >= self.limiar_conf { - trajetoria.push(EventoCiclo::Resposta { confianca: conf, iteracoes }); - telemetria.insert("iteracoes".into(), iteracoes as f64); - telemetria.insert("confianca_final".into(), conf); - telemetria.insert("temperatura_final".into(), temperatura); - telemetria.insert("verificador".into(), 1.0); // ncm (sem oráculo) - return Ok(ResultadoPensamento { - resposta: melhor.0, - candidatos: candidatos_final, - pesos: melhor.2, - confianca: conf, - iteracoes, - trajetoria, - telemetria, - }); - } - if iteracoes >= self.orcamento { - trajetoria.push(EventoCiclo::Resposta { confianca: melhor.1, iteracoes }); - telemetria.insert("iteracoes".into(), iteracoes as f64); - telemetria.insert("confianca_final".into(), melhor.1); - telemetria.insert("temperatura_final".into(), temperatura); - telemetria.insert("orcamento_esgotado".into(), 1.0); - telemetria.insert("verificador".into(), 1.0); - return Ok(ResultadoPensamento { - resposta: melhor.0, - candidatos: candidatos_final, - pesos: melhor.2, - confianca: melhor.1, - iteracoes, - trajetoria, - telemetria, - }); - } - temperatura = (temperatura * 1.6).min(2.0); - trajetoria.push(EventoCiclo::RePlanejamento { - motivo: format!("conf NCM {conf:.3} < limiar {}", self.limiar_conf), - }); - } - } -} diff --git a/src/pensamento/quebra_cabeca.rs b/src/pensamento/quebra_cabeca.rs deleted file mode 100644 index 123dd9f36b7f6aab51d0c76a167295f077cca8f0..0000000000000000000000000000000000000000 --- a/src/pensamento/quebra_cabeca.rs +++ /dev/null @@ -1,233 +0,0 @@ -//! `pensamento::quebra_cabeca` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -// --------------------------------------------------------------------------- -// QUEBRA-CABEÇA pós-treinamento (v0.7.0 — inovação com o conhecimento -// treinado; requisito do usuário; provas Q-1..Q-6 em r-31) -// --------------------------------------------------------------------------- - -/// Configuração do quebra-cabeça (r-28 §4.3). -#[derive(Clone, Copy, Debug)] -pub struct ConfigQuebraCabeca { - /// K peças em que o conhecimento é quebrado. - pub n_pecas: usize, - /// orçamento B de rodadas (terminação Q-4). - pub n_rodadas_max: usize, - /// limiar de validade (mesmo τ_c calibrado do verificador — Q-2). - pub tau_c: f64, - /// teto do ajuste por componente na árvore (regulação). - pub delta_max: f64, - /// remonta as peças com mistura ORTOGONAL por peça (rotação/ortogonalidade). - pub rotacao_ortogonal: bool, - /// para a execução após este nº de rodadas consecutivas sem aceite. - pub paciencia: usize, -} - -impl Default for ConfigQuebraCabeca { - fn default() -> Self { - ConfigQuebraCabeca { - n_pecas: 4, - n_rodadas_max: 12, - tau_c: 0.55, - delta_max: 0.05, - rotacao_ortogonal: true, - paciencia: 5, - } - } -} - -impl ConfigQuebraCabeca { - pub fn novo(n_pecas: usize, n_rodadas: usize, tau_c: f64) -> Self { - ConfigQuebraCabeca { - n_pecas, - n_rodadas_max: n_rodadas, - tau_c, - delta_max: 0.05, - rotacao_ortogonal: true, - paciencia: (n_rodadas / 2).max(2), - } - } -} - -/// Uma rodada do quebra-cabeça. -#[derive(Debug, Clone)] -pub struct RodadaQuebraCabeca { - pub rodada: usize, - /// permutação das peças aplicada na remontagem (reordenação). - pub permutacao_pecas: Vec, - /// confiança NCM do candidato remontado (reavaliação). - pub confianca: f64, - /// conf ≥ τ_c ⇒ VÁLIDO (ajusta a árvore); senão PUNIDO (descarta). - pub aceito: bool, - /// delta aplicado na árvore (0 quando descartado). - pub delta_aplicado: f64, - /// rotações ortogonais usadas (quando ativas) — por peça. - pub usou_rotacao: bool, -} - -/// Resultado consolidado do quebra-cabeça. -#[derive(Debug, Clone)] -pub struct ResultadoQuebraCabeca { - pub rodadas: Vec, - pub aceitos: usize, - pub rejeitados: usize, - pub confianca_base: f64, - pub confianca_melhor: f64, - pub telemetria: HashMap, -} - -/// **Quebra-cabeça de inovação pós-treinamento** (r-28 §4.3): -/// 1. quebra o conhecimento treinado `conceitos` (m, d) em K peças por -/// permutação aleatória das linhas (Fisher–Yates com RNG determinístico); -/// 2. remonta as peças em nova ordem (e com mistura ortogonal por peça -/// quando `rotacao_ortogonal`) — "descobrir novas possibilidades"; -/// 3. reavalia cada remontagem pelo verificador NCM (calibrado — V-2); -/// VÁLIDO (conf ≥ τ_c) ⇒ ajuste regulado na árvore de pesos indexada -/// (nó "pensamento", crédito fundo-topo); PUNIDO ⇒ descarta e o incremento -/// de punição sobe no nó (alimenta o gate do FNH — integração v0.7.0); -/// 4. repete até o orçamento B ou a paciência esgotar (Q-4). -/// -/// **Provas (r-31):** Q-1 cobertura (permutações uniformes ⇒ S_K no suporte; -/// rotações varrem O(d)); Q-2 soundness herdada (mesmo limiar calibrado do -/// verificador — P(aceite inválido) ≤ 1−τ_c+ECE); Q-3 potencial monotônico -/// (Φ_r = Σ conf dos aceitos é não-decrescente; rejeições não tocam Φ); -/// Q-4 terminação (B finito, rodadas O(m·d)); Q-5 invariantes da árvore -/// preservadas (ajustes só tocam métricas, nunca a estrutura — T-A1 intacto; -/// agregação pós-ajuste mantém T-A2); Q-6 causalidade (permutação e confiança -/// medidas antes do ajuste — filtração F_r). -pub fn quebra_cabeca_inovar( - conceitos: &Tensor, - verificador: &crate::verificador::VerificadorNcm, - logits_fn: &dyn Fn(&Tensor) -> Result, - arvore: &mut crate::arvore_pesos::ArvorePesos, - cfg: &ConfigQuebraCabeca, - rng: &mut RngDeterministico, -) -> Result { - let dev = conceitos.device().clone(); - let (m, d) = (conceitos.dims()[0], conceitos.dims()[1]); - let k = cfg.n_pecas.clamp(1, m); - let no_pens = arvore.no("pensamento").unwrap_or(0); - - // linha de base: confiança do conhecimento original (agregado médio) - let base_agg = conceitos.mean(0)?; - let conf_base = { - let lg = logits_fn(&base_agg)?; - verificador.confianca_1d(&lg)? - }; - - let mut rodadas = Vec::new(); - let mut aceitos = 0usize; - let mut rejeitados = 0usize; - let mut conf_melhor = conf_base; - let mut sem_aceite = 0usize; - - for r in 1..=cfg.n_rodadas_max { - if sem_aceite >= cfg.paciencia { - break; - } - // (1) QUEBRA: permutação de linhas Fisher–Yates (Q-6: amostrada ANTES) - let mut perm: Vec = (0..m).collect(); - for i in (1..m).rev() { - let j = rng.inteiro(i + 1); - perm.swap(i, j); - } - // fatia em K peças contíguas (tamanhos quase iguais) - let tamanho = (m + k - 1) / k; - let mut pecas = Vec::with_capacity(k); - let mut ini = 0usize; - while ini < m { - let fim = (ini + tamanho).min(m); - let idx: Vec = perm[ini..fim].iter().map(|&x| x as u32).collect(); - let pedaco = conceitos.index_select(&Tensor::from_vec(idx, (fim - ini,), &dev)?, 0)?; - pecas.push(pedaco); - ini = fim; - } - // (2) REMONTA: nova ordem aleatória das peças (permutação de peças) - let mut perm_pecas: Vec = (0..pecas.len()).collect(); - for i in (1..pecas.len()).rev() { - let j = rng.inteiro(i + 1); - perm_pecas.swap(i, j); - } - let mut remontada = Vec::with_capacity(pecas.len()); - for &pi in &perm_pecas { - let mut pedaco = pecas[pi].clone(); - if cfg.rotacao_ortogonal && d >= 2 { - // mistura ortogonal da peça: Q ∈ O(d) via polar de gaussiana - // do RNG determinístico (preserva normas — ‖xQ‖_F = ‖x‖_F) - let q = q_ortogonal_deterministica(d, rng, &dev)?; - pedaco = pedaco.matmul(&q)?; - } - remontada.push(pedaco); - } - let candidata = Tensor::cat(&remontada, 0)?; // (m, d) remontado - // (3) REAVALIAÇÃO pelo verificador NCM (Q-2: mesmo limiar calibrado) - let agg = candidata.mean(0)?; - let lg = logits_fn(&agg)?; - let conf = verificador.confianca_1d(&lg)?; - let aceito = conf >= cfg.tau_c; - let delta = if aceito { - // VÁLIDO: ajusta a árvore bidirecional (indexada, com teto) - let escalado = (conf - cfg.tau_c).min(cfg.delta_max); - arvore.aplicar_ajuste_indexado(no_pens, "confianca", escalado, cfg.delta_max) - } else { - // PUNIDO: descarta; a punição sobe no nó (sinal para o gate FNH) - rejeitados += 1; - sem_aceite += 1; - arvore.aplicar_ajuste_indexado(no_pens, "punicao", cfg.delta_max * 0.5, cfg.delta_max); - 0.0 - }; - if aceito { - aceitos += 1; - sem_aceite = 0; - conf_melhor = conf_melhor.max(conf); - } - rodadas.push(RodadaQuebraCabeca { - rodada: r, - permutacao_pecas: perm_pecas, - confianca: conf, - aceito, - delta_aplicado: delta, - usou_rotacao: cfg.rotacao_ortogonal, - }); - } - // crédito fundo-topo após todas as rodadas (T-A2) - arvore.agregar_fundo_topo("confianca"); - arvore.agregar_fundo_topo("punicao"); - - let n_rod = rodadas.len(); - let mut telemetria = HashMap::new(); - telemetria.insert("rodadas".into(), n_rod as f64); - telemetria.insert("aceitos".into(), aceitos as f64); - telemetria.insert("rejeitados".into(), rejeitados as f64); - telemetria.insert("confianca_base".into(), conf_base); - telemetria.insert("confianca_melhor".into(), conf_melhor); - telemetria.insert( - "taxa_aceitacao".into(), - if n_rod > 0 { aceitos as f64 / n_rod as f64 } else { 0.0 }, - ); - telemetria.insert("rotacao_ativa".into(), if cfg.rotacao_ortogonal { 1.0 } else { 0.0 }); - Ok(ResultadoQuebraCabeca { - rodadas, - aceitos, - rejeitados, - confianca_base: conf_base, - confianca_melhor: conf_melhor, - telemetria, - }) -} - -/// Q ∈ O(d) determinística: gaussiana do RNG próprio → retração polar. -/// Ortogonal EXATA (δ_ort ≤ 1e-6) e reprodutível (mesma semente ⇒ mesmo Q). -pub fn q_ortogonal_deterministica( - d: usize, - rng: &mut RngDeterministico, - dev: &Device, -) -> Result { - let n = d * d; - let v: Vec = (0..n).map(|_| rng.normal_padrao() as f32).collect(); - let g = Tensor::from_vec(v, (d, d), dev)?; - crate::stiefel::retrair_polar_frobenius(&g, 90) -} diff --git a/src/pensamento/testes.rs b/src/pensamento/testes.rs deleted file mode 100644 index 16ce20b61cfb05fe7119a55bd4c68d49025138dc..0000000000000000000000000000000000000000 --- a/src/pensamento/testes.rs +++ /dev/null @@ -1,303 +0,0 @@ -//! `pensamento::testes` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - - -#[cfg(test)] -mod testes { - use super::*; - - #[test] - fn teste_confianca_extremos() { - // T-P1: Dirac ⇒ conf = 1; uniforme ⇒ conf = 0 - let dev = Device::Cpu; - let dirac = Tensor::from_vec(vec![100.0f32, 0.0, 0.0, 0.0], (1, 4), &dev).unwrap(); - let uniforme = Tensor::from_vec(vec![0.0f32; 4], (1, 4), &dev).unwrap(); - let c1 = confianca_de_logits(&dirac).unwrap(); - let c0 = confianca_de_logits(&uniforme).unwrap(); - assert!(c1 > 0.999, "conf dirac = {c1}"); - assert!(c0 < 0.001, "conf uniforme = {c0}"); - } - - #[test] - fn teste_tp3_projetar_ridge_minimiza() { - // T-P3: r* da projeção ridge tem resíduo ≤ qualquer perturbação - let dev = Device::Cpu; - let w = Tensor::randn(0f32, 1.0, (8, 3), &dev).unwrap(); - let r_alvo = Tensor::randn(0f32, 1.0, (8, 5), &dev).unwrap(); - let r = projetar_ridge(&w, &r_alvo, 1e-6).unwrap(); - let residuo = |rr: &Tensor| { - let d = (w.matmul(rr).unwrap() - &r_alvo).unwrap(); - d.sqr().unwrap().sum_all().unwrap().to_scalar::().unwrap() as f64 - }; - let f0 = residuo(&r); - let mut rng = RngDeterministico::novo(1); - for _ in 0..30 { - let pert: Vec = (0..15).map(|_| rng.normal(0.0, 0.1) as f32).collect(); - let rp = (Tensor::from_vec(pert, (3, 5), &dev).unwrap() + &r).unwrap(); - let fp = residuo(&rp); - assert!(f0 <= fp + 1e-6, "residuo r* = {f0} > perturbado {fp}"); - } - } - - #[test] - fn teste_tp4_terminacao_e_orcamento() { - // o ciclo d SEMPRE termina em ≤ orçamento iterações (potencial - // Φ = B − k); com verificador impossível, termina com - // orcamento_esgotado = 1. - let dev = Device::Cpu; - let mut motor = MotorPensamento::novo(6, 4, 3, 0.99, 5, &dev).unwrap(); - let cond = Tensor::randn(0f32, 1.0, (6,), &dev).unwrap(); - let mut rng = RngDeterministico::novo(2); - let res = motor - .raciocinar(&cond, &|_| 0.0, &mut rng) // verificador sempre 0 - .unwrap(); - assert!(res.iteracoes <= 5, "iterações = {} > orçamento", res.iteracoes); - assert_eq!(res.telemetria.get("orcamento_esgotado"), Some(&1.0)); - assert!(res.resposta.is_some(), "melhor candidato ainda é retornado"); - } - - #[test] - fn teste_tp5_neutralidade_no_nascimento() { - // gate = 0 ⇒ saída da atenção integrada é BIT-A-BIT a da base - let dev = Device::Cpu; - let motor = MotorPensamento::novo(8, 8, 3, 0.5, 3, &dev).unwrap(); - let q = Tensor::randn(0f32, 1.0, (1, 4, 8), &dev).unwrap(); - let k = Tensor::randn(0f32, 1.0, (1, 6, 8), &dev).unwrap(); - let v = Tensor::randn(0f32, 1.0, (1, 6, 8), &dev).unwrap(); - let cand = Tensor::randn(0f32, 1.0, (3, 8), &dev).unwrap(); - let y_int = motor.atencao_integrada(&q, &k, &v, &cand).unwrap(); - // atenção base pura - let scores = (q.matmul(&k.transpose(1, 2).unwrap()).unwrap() / (8f64).sqrt()).unwrap(); - let attn = candle_nn::ops::softmax(&scores, candle_core::D::Minus1).unwrap(); - let y_base = attn.matmul(&v).unwrap(); - let dif = (&y_int - &y_base).unwrap().abs().unwrap().max_all().unwrap().to_scalar::().unwrap(); - assert!(dif == 0.0, "gate=0 deveria dar bit-a-bit, dif = {dif}"); - } - - #[test] - fn teste_treino_cooperativo_e_agregacao() { - // item a: as tentativas + combinador APRENDEM a função alvo; a - // agregação converge para o alvo melhor que uma tentativa isolada - // no pior caso (verificação numérica honesta em escala pequena). - let dev = Device::Cpu; - let mut motor = MotorPensamento::novo(6, 4, 3, 0.5, 3, &dev).unwrap(); - let vars = motor.vars(); - let mut otim = crate::treino::AdamWManual::novo(vars, 5e-3, 0.0); - let mut rng = RngDeterministico::novo(4); - // alvo: função não-linear determinística de cond - let dados: Vec<(Vec, Vec)> = (0..256) - .map(|_| { - let c: Vec = (0..6).map(|_| rng.normal(0.0, 1.0) as f32).collect(); - let a: Vec = (0..4) - .map(|j| { - (c[j % 6] * 0.5 + (c[(j + 1) % 6] * c[(j + 2) % 6]) * 0.3 + 0.1) as f32 - }) - .collect(); - (c, a) - }) - .collect(); - let cs: Vec = dados.iter().flat_map(|(c, _)| c.clone()).collect(); - let as_: Vec = dados.iter().flat_map(|(_, a)| a.clone()).collect(); - let cond = Tensor::from_vec(cs, (256, 6), &dev).unwrap(); - let alvo = Tensor::from_vec(as_, (256, 4), &dev).unwrap(); - let mut perda0 = f64::NAN; - let mut perda1 = f64::NAN; - for passo in 0..200 { - let perda = motor.perda_treino(&cond, &alvo).unwrap(); - if passo == 0 { - perda0 = perda.to_scalar::().unwrap() as f64; - } - perda1 = perda.to_scalar::().unwrap() as f64; - otim.passo(crate::treino::grads_achatados(&perda, &motor.vars()).unwrap()); - } - assert!(perda1 < perda0 * 0.5, "treino cooperativo: {perda0} → {perda1}"); - // agregação: verificador = negativo do erro quadrático médio - let mut rng2 = RngDeterministico::novo(9); - let cand = motor.candidatos(&cond.get(0).unwrap(), 0.0, &mut rng2).unwrap(); - let (resp, pesos) = motor.agregar(&cand).unwrap(); - assert_eq!(resp.dims().to_vec(), vec![1, 4]); - let soma: f64 = pesos.iter().sum(); - assert!((soma - 1.0).abs() < 1e-9, "pesos somam {soma}"); - assert!(pesos.iter().all(|&p| p >= 0.0)); - } - - #[test] - fn teste_tp2_auto_consistencia_numérica() { - // T-P2 numérico: N tentativas com viés comum pequeno; a média - // agregada tem erro menor que a tentativa mediana (redução de - // variância) na maioria das repetições. - let dev = Device::Cpu; - let mut rng = RngDeterministico::novo(6); - let alvo = [1.0f64, 2.0, -1.0, 0.5]; - let mut venceu = 0; - let reps = 200; - for _ in 0..reps { - let n = 7; - let erros: Vec = (0..n) - .map(|_| { - alvo - .iter() - .map(|&a| { - let ruido = rng.normal(0.0, 1.0); - (a + ruido - a).abs() - }) - .sum::() - }) - .collect(); - let media: Vec = (0..4) - .map(|j| { - (0..n).map(|i| alvo[j] + rng.normal(0.0, 1.0)).sum::() / n as f64 - }) - .collect(); - let erro_media: f64 = media.iter().zip(alvo.iter()).map(|(m, a)| (m - a).abs()).sum(); - let mut ordenado = erros.clone(); - ordenado.sort_by(|a, b| a.partial_cmp(b).unwrap()); - let mediana = ordenado[n / 2]; - if erro_media <= mediana { - venceu += 1; - } - } - // a média vence a mediana na grande maioria dos casos (E[erro da - // média] = σ/√n < σ = E[erro de UMA tentativa]) - assert!( - venceu as f64 / reps as f64 >= 0.6, - "auto-consistência venceu só {}/{}", - venceu, - reps - ); - } - - // ------------------------------------------------------------------ - // Quebra-cabeça (v0.7.0) — gates Q-1..Q-6 (provas r-31) - // ------------------------------------------------------------------ - - fn cenario_quebra_cabeca() - -> (Tensor, crate::verificador::VerificadorNcm, crate::arvore_pesos::ArvorePesos) { - let dev = Device::Cpu; - let mut rng = RngDeterministico::novo(777); - // "conhecimento treinado": 12 conceitos (d=8) com estrutura - let m = 12usize; - let d = 8usize; - let v: Vec = (0..m * d).map(|i| rng.normal_padrao() as f32).collect(); - let conceitos = Tensor::from_vec(v, (m, d), &dev).unwrap(); - // verificador calibrado com um "verificador" sintético: logits - // favoráveis ao agregado médio dos conceitos - let mut verif = crate::verificador::VerificadorNcm::novo(); - let _ = &mut verif; - let mut arvore = crate::arvore_pesos::ArvorePesos::nova(&std::collections::HashMap::new()); - let _ = &mut arvore; - (conceitos, verif, arvore) - } - - fn logits_fn_exemplo(x: &Tensor) -> Result { - // logits determinísticos correlacionados com a norma do agregado — - // quanto mais "concentrado" o agregado, maior a confiança - let norma = x.sqr()?.sum_all()?.to_scalar::()? as f64; - let base = (norma * 2.0).min(8.0); - let v: Vec = vec![base as f32, 0.5, 0.2, 0.1]; - Ok(Tensor::from_vec(v, (4,), x.device())?) - } - - /// Q-2/Q-3: todo ACEITO tem conf ≥ τ_c; rejeições não aplicam delta; - /// potencial monotônico (confiança acumulada só cresce nos aceites). - #[test] - fn quebra_cabeca_soundness_e_potencial() -> Result<()> { - let (conceitos, verif, mut arvore) = cenario_quebra_cabeca(); - let cfg = ConfigQuebraCabeca::novo(4, 10, 0.55); - let mut rng = RngDeterministico::novo(4242); - let r = quebra_cabeca_inovar(&conceitos, &verif, &logits_fn_exemplo, &mut arvore, &cfg, &mut rng)?; - for rod in &r.rodadas { - if rod.aceito { - assert!( - rod.confianca >= cfg.tau_c, - "Q-2: aceito com conf {} < τ_c {}", - rod.confianca, - cfg.tau_c - ); - assert!(rod.delta_aplicado > 0.0, "aceite aplica delta > 0"); - } else { - assert_eq!(rod.delta_aplicado, 0.0, "Q-3: rejeitado não aplica delta"); - } - } - // potencial monotônico: Σ conf dos aceitos ≤ Σ max(conf, τ_c) das rodadas - let pot: f64 = r.rodadas.iter().filter(|x| x.aceito).map(|x| x.confianca).sum(); - assert!(pot >= 0.0); - // Q-5: invariantes da árvore preservadas - arvore.invariantes_ok().expect("Q-5: invariantes T-A1 preservadas"); - Ok(()) - } - - /// Q-4: terminação — nunca excede n_rodadas_max nem roda sem parar. - #[test] - fn quebra_cabeca_termina() -> Result<()> { - let (conceitos, verif, mut arvore) = cenario_quebra_cabeca(); - let cfg = ConfigQuebraCabeca::novo(3, 6, 0.99); // τ inalcançável - let mut rng = RngDeterministico::novo(1); - let r = quebra_cabeca_inovar(&conceitos, &verif, &logits_fn_exemplo, &mut arvore, &cfg, &mut rng)?; - assert!(r.rodadas.len() <= 6, "Q-4: orçamento respeitado"); - assert_eq!(r.aceitos, 0, "τ inalcançável ⇒ nenhum aceite"); - assert!(r.rejeitados > 0); - Ok(()) - } - - /// Q-4b: rejeições incrementam a PUNIÇÃO no nó pensamento (sinal FNH). - #[test] - fn quebra_cabeca_punicao_sobe() -> Result<()> { - let (conceitos, verif, mut arvore) = cenario_quebra_cabeca(); - let no_pens = arvore.no("pensamento").unwrap(); - let antes = arvore.nos[no_pens].metricas.get("punicao").copied().unwrap_or(0.0); - let cfg = ConfigQuebraCabeca::novo(3, 5, 0.999); - let mut rng = RngDeterministico::novo(9); - let _ = quebra_cabeca_inovar(&conceitos, &verif, &logits_fn_exemplo, &mut arvore, &cfg, &mut rng)?; - let depois = arvore.nos[no_pens].metricas.get("punicao").copied().unwrap_or(0.0); - assert!(depois > antes, "punição {depois} deve > {antes} após rejeições"); - Ok(()) - } - - /// Rotação/ortogonalidade: ‖xQ‖_F = ‖x‖_F (preserva energia) e a - /// remontagem com rotação difere da sem rotação (exploração real). - #[test] - fn quebra_cabeca_rotacao_preserva_norma() -> Result<()> { - let dev = Device::Cpu; - let mut rng = RngDeterministico::novo(31); - let v: Vec = (0..5 * 6).map(|_| rng.normal_padrao() as f32).collect(); - let x = Tensor::from_vec(v, (5, 6), &dev)?; - let q = q_ortogonal_deterministica(6, &mut rng, &dev)?; - let xq = x.matmul(&q)?; - let nx = x.sqr()?.sum_all()?.to_scalar::()?; - let nxq = xq.sqr()?.sum_all()?.to_scalar::()?; - assert!( - (nx - nxq).abs() / nx < 1e-4, - "‖xQ‖_F = {nxq} deve ≈ ‖x‖_F = {nx} (ortogonalidade)" - ); - // Q é ortogonal exato - let delta = crate::stiefel::erro_ortogonalidade(&q)?; - assert!(delta < 1e-6, "δ_ort(Q) = {delta}"); - // remontagem COM rotação difere da SEM rotação - let d2 = (&xq - &x)?.abs()?.max_all()?.to_scalar::()?; - assert!(d2 > 1e-3, "rotação deve explorar (dif = {d2})"); - Ok(()) - } - - /// Determinismo: mesma semente ⇒ mesmas rodadas (reprodutibilidade). - #[test] - fn quebra_cabeca_deterministico() -> Result<()> { - let (c1, v1, mut a1) = cenario_quebra_cabeca(); - let (_, v2, mut a2) = cenario_quebra_cabeca(); - let cfg = ConfigQuebraCabeca::novo(4, 8, 0.5); - let mut r1 = RngDeterministico::novo(123); - let mut r2 = RngDeterministico::novo(123); - let q1 = quebra_cabeca_inovar(&c1, &v1, &logits_fn_exemplo, &mut a1, &cfg, &mut r1)?; - let q2 = quebra_cabeca_inovar(&c1, &v2, &logits_fn_exemplo, &mut a2, &cfg, &mut r2)?; - assert_eq!(q1.rodadas.len(), q2.rodadas.len()); - for (x, y) in q1.rodadas.iter().zip(q2.rodadas.iter()) { - assert_eq!(x.permutacao_pecas, y.permutacao_pecas, "mesma semente ⇒ mesma remontagem"); - assert!((x.confianca - y.confianca).abs() < 1e-12); - assert_eq!(x.aceito, y.aceito); - } - Ok(()) - } -} diff --git a/src/python/calibracao.rs b/src/python/calibracao.rs deleted file mode 100644 index 6e3b3fe17b084983d885febe7b1edae3192b265b..0000000000000000000000000000000000000000 --- a/src/python/calibracao.rs +++ /dev/null @@ -1,134 +0,0 @@ -//! `python::calibracao` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -/// **V-1..V-3:** calibra o verificador NCM em logits retidos e devolve -/// temperatura, ECE antes/depois, NLL antes/depois e o τ_c por quantil DKW. -#[pyfunction] -pub(crate) fn calibrar_verificador( - logits: Vec>, - alvos: Vec, - epsilon: f64, -) -> PyResult { - Python::with_gil(|py| { - let dev = candle_core::Device::Cpu; - let (n, k) = (logits.len(), logits.first().map(|l| l.len()).unwrap_or(1)); - let flat: Vec = logits.into_iter().flatten().collect(); - let lt = candle_core::Tensor::from_vec(flat, (n, k), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let at = candle_core::Tensor::from_vec( - alvos.iter().map(|&a| a as u32).collect::>(), (n,), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut v = verificador::VerificadorNcm::novo(); - let (e_antes, e_depois) = v.ajustar(<, &at) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let confs: Vec = verificador::confianca_por_linha(<) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? - .flatten_all().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? - .to_vec1::().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? - .iter().map(|x| *x as f64).collect(); - let tau_c = verificador::limiar_por_erro(&confs, epsilon); - let d_ = serde_json::json!({ - "temperatura": v.temperatura, "ece_antes": e_antes, "ece_depois": e_depois, - "nll_antes": v.n_ll_antes, "nll_depois": v.n_ll_depois, - "tau_c": tau_c, "epsilon": epsilon, "n": n, - }); - Ok(pythonize::pythonize(py, &d_)?.into()) - }) -} - - -/// **Demo do verificador NCM substituindo o oráculo** (r-21 §3.1): treina -/// um classificador pequeno, calibra T* em dados retidos, mede ECE, τ_c -/// (DKW) e a soundness empírica `P(erro|aceito) ≤ 1−τ_c+ECE`; compara com -/// o ORÁCULO (que usa o alvo — impossível em produção) no mesmo problema. -#[pyfunction] -pub(crate) fn demo_verificador_ncm(n: usize, k: usize, semente: u64) -> PyResult { - Python::with_gil(|py| { - let dev = candle_core::Device::Cpu; - crate::rng::definir_semente(semente); - let mut rng = crate::rng::RngDeterministico::novo(semente); - // dados sintéticos com DRIFT (treino ≠ consulta — força OOD leve) - let gerar = |rng: &mut crate::rng::RngDeterministico, m: usize, desloc: f64| - -> (candle_core::Tensor, Vec) { - let mut l = Vec::with_capacity(m * k); - let mut a = Vec::with_capacity(m); - for _ in 0..m { - let alvo = rng.inteiro(k); - a.push(alvo); - for j in 0..k { - let base = if j == alvo { 2.5 } else { 0.0 }; - l.push((base + rng.normal(0.0, 1.2) as f32 + desloc as f32) as f32); - } - } - let lt = candle_core::Tensor::from_vec(l, (m, k), &dev).unwrap(); - (lt, a) - }; - let (lt_tre, alvos_tre) = gerar(&mut rng, n, 0.0); - let (lt_val, alvos_val) = gerar(&mut rng, n / 2, 0.3); - // mini-classificador: matriz W (k, k) treinada por softmax-CE - let w = candle_core::Tensor::randn(0f32, 0.1, (k, k), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let w_var = candle_core::Var::from_tensor(&w) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let at_t = candle_core::Tensor::from_vec( - alvos_tre.iter().map(|&a| a as u32).collect::>(), (n,), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut otim = treino::AdamWManual::novo(vec![w_var.clone()], 0.05, 0.0); - for _ in 0..120 { - let logits = lt_tre.matmul(&w_var.as_tensor().transpose(0, 1).unwrap()).unwrap(); - let ce = candle_nn::loss::cross_entropy(&logits, &at_t).unwrap(); - let g = treino::grads_achatados(&ce, &[w_var.clone()]).unwrap(); - otim.passo(g); - } - // logits de validação com o modelo treinado - let logits_val = lt_val.matmul(&w_var.as_tensor().transpose(0, 1).unwrap()).unwrap(); - let at_v = candle_core::Tensor::from_vec( - alvos_val.iter().map(|&a| a as u32).collect::>(), (n / 2,), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - // calibração (V-1) + soundness (V-2) + quantil (V-3) - let mut v = verificador::VerificadorNcm::novo(); - let (ece_antes, ece_depois) = v.ajustar(&logits_val, &at_v) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let confs: Vec = v.confianca(&logits_val).unwrap() - .flatten_all().unwrap().to_vec1::().unwrap().iter().map(|x| *x as f64).collect(); - let corretos: Vec = logits_val.argmax(candle_core::D::Minus1).unwrap() - .eq(&at_v).unwrap().to_dtype(candle_core::DType::U32).unwrap() - .flatten_all().unwrap().to_vec1::().unwrap() - .iter().map(|x| *x == 1).collect(); - let tau_c = verificador::limiar_por_erro(&confs, 0.25); - let (mut erro_aceito, mut n_aceito) = (0usize, 0usize); - for (c, ok) in confs.iter().zip(corretos.iter()) { - if *c >= tau_c { - n_aceito += 1; - if !ok { - erro_aceito += 1; - } - } - } - let p_erro = erro_aceito as f64 / n_aceito.max(1) as f64; - let cota = (1.0 - tau_c) + ece_depois + 0.06; - // ORÁCULO no mesmo problema (usa o alvo — só para contraste) - let acerto_oraculo = corretos.iter().filter(|c| **c).count() as f64 / corretos.len() as f64; - let d_ = serde_json::json!({ - "versao": verificador::versao(), "n": n, "k": k, - "temperatura_calibrada": v.temperatura, - "ece_antes": ece_antes, "ece_depois": ece_depois, - "nll_antes": v.n_ll_antes, "nll_depois": v.n_ll_depois, - "tau_c_dkw": tau_c, - "p_erro_aceito": p_erro, "cota_soundness": cota, - "soundness_ok": p_erro <= cota, - "calibracao_melhorou": ece_depois < ece_antes, - "acerto_oraculo_referencia": acerto_oraculo, - "verificador_sem_oraculo": true, - "gates": { - "gate_v1_calibracao": ece_depois < ece_antes, - "gate_v2_soundness": p_erro <= cota, - "gate_v3_tau_positivo": tau_c > 0.0 && tau_c < 1.0, - }, - }); - Ok(pythonize::pythonize(py, &d_)?.into()) - }) -} diff --git a/src/python/demos_qwen.rs b/src/python/demos_qwen.rs deleted file mode 100644 index 059836541359dc90bc3ee1c98121dc4499c0a29b..0000000000000000000000000000000000000000 --- a/src/python/demos_qwen.rs +++ /dev/null @@ -1,359 +0,0 @@ -//! `python::demos_qwen` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -/// **v0.8.0 — análise/prova/teste das 4 propostas Qwen3.8** (r-33): mede -/// custo e exatidão de (1) Newton analítico vs golden-section (verificador), -/// (2) Cayley vs polar (FNH), (3) árvore pós-ordem iterativa vs recursiva, -/// (4) MoE vetorizada vs referência (valores + gradiente restaurado — bug -/// v080-1), e re-executa a ablação JEPA de 3 braços com a correção. -#[pyfunction] -#[allow(deprecated)] // mede o bug v080-1 intencionalmente (fwd = oráculo) -pub(crate) fn demo_qwen_v080(py: Python) -> PyResult { - use candle_core::{Device, Tensor}; - use std::time::Instant; - let dev = Device::Cpu; - - // ---------- (1) Newton vs golden-section (verificador) ---------- - let mut rng = crate::rng::RngDeterministico::novo(808); - let (n, k) = (1024usize, 32usize); - let mut lv = Vec::with_capacity(n * k); - let mut av = Vec::with_capacity(n); - for _ in 0..n { - let alvo = rng.inteiro(k) as u32; - av.push(alvo); - for j in 0..k { - let base = if j as u32 == alvo { 3.0 } else { 0.0 }; - lv.push(base + rng.normal(0.0, 1.0) as f32); - } - } - let lt = Tensor::from_vec(lv, (n, k), &dev).unwrap(); - let at = Tensor::from_vec(av, (n,), &dev).unwrap(); - let t0 = Instant::now(); - let (t_g, _, nll_g) = verificador::calibrar_temperatura(<, &at).unwrap(); - let tempo_golden = t0.elapsed().as_secs_f64(); - let t0 = Instant::now(); - let (t_n, _, nll_n, n_aval) = - verificador::calibrar_temperatura_newton(<, &at, 40).unwrap(); - let tempo_newton = t0.elapsed().as_secs_f64(); - - // ---------- (2) Cayley vs polar (FNH) ---------- - let n_rot = 16usize; - let r = fnh::RotacaoSkew::nova(n_rot, &dev).unwrap(); - let th: Vec = (0..n_rot * (n_rot - 1) / 2) - .map(|i| ((i as f32) * 0.11) % 0.5) - .collect(); - r.theta - .set(&Tensor::from_vec(th, (n_rot * (n_rot - 1) / 2,), &dev).unwrap()) - .unwrap(); - let rep = 25usize; - let t0 = Instant::now(); - let mut delta_polar = 0.0; - for _ in 0..rep { - delta_polar = crate::stiefel::erro_ortogonalidade(&r.rotacao_polar().unwrap()).unwrap(); - } - let tempo_polar = t0.elapsed().as_secs_f64() / rep as f64; - let t0 = Instant::now(); - let mut delta_cayley = 0.0; - for _ in 0..rep { - delta_cayley = crate::stiefel::erro_ortogonalidade(&r.rotacao_cayley().unwrap()).unwrap(); - } - let tempo_cayley = t0.elapsed().as_secs_f64() / rep as f64; - - // ---------- (3) árvore iterativa vs recursiva ---------- - let mut arv = arvore_pesos::ArvorePesos::nova(&std::collections::HashMap::new()); - let mut pai = 1usize; - for i in 0..20_000u32 { - pai = arv.anexar_filho(pai, &format!("c{i}"), 1); - } - arv.nos[pai].metricas.insert("m".into(), 1.0); - let t0 = Instant::now(); - let total_it = arv.agregar_fundo_topo("m"); - let tempo_arv_it = t0.elapsed().as_secs_f64(); - // repõe TODAS as métricas locais (a agregação sobrescreveu com os - // agregados) — só a folha tem valor; o resto volta a 0 — e roda a - // recursiva (profundidade 20k ok na thread principal do Python) - for no in arv.nos.iter_mut() { - no.metricas.insert("m".into(), 0.0); - } - arv.nos[pai].metricas.insert("m".into(), 1.0); - let t0 = Instant::now(); - let total_rec = arv.agregar_fundo_topo_rec("m"); - let tempo_arv_rec = t0.elapsed().as_secs_f64(); - - // ---------- (4) MoE vetorizada: valores + gradiente + custo ---------- - let (nm, dm, em) = (256usize, 32usize, 8usize); - let xv: Vec = (0..nm * dm).map(|_| rng.normal(0.0, 1.0) as f32).collect(); - let x = Tensor::from_vec(xv, (nm, dm), &dev).unwrap(); - let moe = moe_redirecionavel::MoeRedirecionavel::novo(dm, em, 2, nm, &dev).unwrap(); - let s_ref = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap(); - let s_vet = moe.forward(&x, moe_redirecionavel::Papel::Codificador).unwrap(); - let dif_moe = (&s_ref.saida - &s_vet.saida) - .unwrap() - .abs() - .unwrap() - .max_all() - .unwrap() - .to_scalar::() - .unwrap() as f64; - let rep_moe = 10usize; - let t0 = Instant::now(); - for _ in 0..rep_moe { - let _ = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap(); - } - let tempo_moe_ref = t0.elapsed().as_secs_f64() / rep_moe as f64; - let t0 = Instant::now(); - for _ in 0..rep_moe { - let _ = moe.forward(&x, moe_redirecionavel::Papel::Codificador).unwrap(); - } - let tempo_moe_vet = t0.elapsed().as_secs_f64() / rep_moe as f64; - // normas de gradiente (bug v080-1: fwd = 0; vetorizada > 0) - let norma = |vet: bool| -> (f64, f64) { - let s = if vet { - moe.forward(&x, moe_redirecionavel::Papel::Codificador).unwrap() - } else { - moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap() - }; - let perda = s.saida.sqr().unwrap().sum_all().unwrap(); - let gs = perda.backward().unwrap(); - let mut nr = 0.0; - for v in moe.roteador.vars() { - if let Some(g) = gs.get(&v) { - nr += g.sqr().unwrap().sum_all().unwrap().to_scalar::().unwrap() as f64; - } - } - let mut ne = 0.0; - for e in &moe.especialistas { - for v in e.vars() { - if let Some(g) = gs.get(&v) { - ne += g.sqr().unwrap().sum_all().unwrap().to_scalar::().unwrap() as f64; - } - } - } - (nr, ne) - }; - let (grad_ref_r, grad_ref_e) = norma(false); - let (grad_vet_r, grad_vet_e) = norma(true); - - // ---------- (5) re-ablação JEPA 3 braços (gradiente restaurado) ---------- - let xv: Vec = (0..64 * 12).map(|_| rng.normal(0.0, 1.0) as f32).collect(); - let xj = Tensor::from_vec(xv, (64, 12), &dev).unwrap(); - let mut ablac = serde_json::Map::new(); - for modo in ["pequena", "densa", "moe"] { - let rj = moe_redirecionavel::treinar_jepa_com_moe(&xj, modo, 120, 0.5, 42).unwrap(); - ablac.insert( - modo.into(), - serde_json::json!({ - "perda_inicial": rj.perda_pred_inicial, - "perda_final": rj.perda_pred_final, - "queda_pct": 100.0 * (1.0 - rj.perda_pred_final / rj.perda_pred_inicial.max(1e-9)), - }), - ); - } - - let d_ = serde_json::json!({ - "versao": "qwen-v080-1.0", - "newton_vs_golden": { - "t_golden": t_g, "t_newton": t_n, "dif_t": (t_g - t_n).abs(), - "nll_golden": nll_g, "nll_newton": nll_n, - "nll_dif": (nll_g - nll_n).abs(), - "n_aval_newton": n_aval, - "tempo_golden_s": tempo_golden, "tempo_newton_s": tempo_newton, - "speedup": tempo_golden / tempo_newton.max(1e-9), - "gates": { - "mesmo_t": (t_g - t_n).abs() < 1e-3, - "nll_nao_piora": nll_n <= nll_g + 1e-4, - "menos_avaliacoes": n_aval < 36, - }, - }, - "cayley_vs_polar": { - "delta_ort_polar": delta_polar, "delta_ort_cayley": delta_cayley, - "tempo_polar_s": tempo_polar, "tempo_cayley_s": tempo_cayley, - "speedup": tempo_polar / tempo_cayley.max(1e-9), - "gates": { - "ambos_exatos": delta_polar < 1e-6 && delta_cayley < 1e-6, - "cayley_mais_rapido": tempo_cayley < tempo_polar, - }, - }, - "arvore_iter_vs_rec": { - "n_nos": arv.n_nos(), - "total_iter": total_it, "total_rec": total_rec, - "bit_a_bit": total_it.to_bits() == total_rec.to_bits(), - "tempo_iter_s": tempo_arv_it, "tempo_rec_s": tempo_arv_rec, - "gates": { "iguais_bit_a_bit": total_it == total_rec }, - }, - "moe_vetorizada": { - "max_dif_valores": dif_moe, - "tempo_ref_s": tempo_moe_ref, "tempo_vet_s": tempo_moe_vet, - "grad_roteador_ref": grad_ref_r, "grad_especialistas_ref": grad_ref_e, - "grad_roteador_vet": grad_vet_r, "grad_especialistas_vet": grad_vet_e, - "gates": { - "valores_iguais": dif_moe < 1e-4, - "bug_v080_1_confirmado": grad_ref_r == 0.0 && grad_ref_e == 0.0, - "gradiente_restaurado": grad_vet_r > 0.0 && grad_vet_e > 0.0, - }, - }, - "ablacao_jepa_3_bracos_v080": ablac, - }); - Ok(pythonize::pythonize(py, &d_)?.into()) -} - - -/// **v0.9.0 — veredito executável das críticas Qwen3.8 (r-34):** mede os -/// aprimoramentos contra as referências v0.8.0 (oráculos preservados): -/// (1) skew O(n²) via index_add — bit-a-bit + tempo + memória analítica; -/// (2) calibrar vetorial — bit-a-bit em 3 passos EMA + tempo; -/// (3) forward canônico (ex-fwd_vetorizado) — regressão de valores e -/// gradiente; -/// (4) newtypes de domínio — rejeição de fora-de-domínio. -#[pyfunction] -pub(crate) fn demo_criticas_v090(py: Python) -> PyResult { - use candle_core::{Device, Tensor}; - use std::time::Instant; - let dev = Device::Cpu; - let mut rng = crate::rng::RngDeterministico::novo(909); - - // ---------- (1) skew: index_add O(n²) vs matmul de seleção O(n⁴) ---------- - let mut skew_rel = serde_json::Map::new(); - let mut bits_todos = true; - for &n in &[16usize, 64, 128] { - let r = fnh::RotacaoSkew::nova(n, &dev).unwrap(); - let m = n * (n - 1) / 2; - let th: Vec = (0..m).map(|_| rng.uniforme_intervalo(-0.9, 0.9) as f32).collect(); - r.theta.set(&Tensor::from_vec(th, (m,), &dev).unwrap()).unwrap(); - // bit-a-bit (F-13) - let an = r.skew().unwrap().flatten_all().unwrap().to_vec1::().unwrap(); - let ar = r.skew_matmul_referencia().unwrap().flatten_all().unwrap().to_vec1::().unwrap(); - let bits_iguais = an.iter().zip(ar.iter()).all(|(a, b)| a.to_bits() == b.to_bits()); - bits_todos &= bits_iguais; - // tempo (referência esquentada 1×; média de 5) - let _ = r.skew_matmul_referencia().unwrap(); - let t0 = Instant::now(); - for _ in 0..5 { let _ = r.skew_matmul_referencia().unwrap(); } - let t_ref = t0.elapsed().as_secs_f64() / 5.0; - let _ = r.skew().unwrap(); - let t0 = Instant::now(); - for _ in 0..5 { let _ = r.skew().unwrap(); } - let t_novo = t0.elapsed().as_secs_f64() / 5.0; - let bytes_ref = (m * n * n * 4) as f64; - let bytes_novo = ((n * n + 3 * m) * 4 + 2 * m * 4) as f64; - skew_rel.insert( - format!("n_{n}"), - serde_json::json!({ - "tempo_ref_s": t_ref, "tempo_novo_s": t_novo, - "speedup": t_ref / t_novo.max(1e-12), - "bytes_ref_selecao": bytes_ref, "bytes_novo": bytes_novo, - "razao_memoria": bytes_ref / bytes_novo, - "bits_iguais": bits_iguais, - }), - ); - } - - // ---------- (2) calibrar: tensor vs laços nativos ---------- - let (d_out, d_in, n_lin) = (512usize, 512usize, 4096usize); - let wv: Vec = (0..d_out * d_in).map(|_| rng.uniforme_intervalo(-2.0, 2.0) as f32).collect(); - let w = Tensor::from_vec(wv, (d_out, d_in), &dev).unwrap(); - let xv: Vec = (0..n_lin * d_in).map(|_| rng.uniforme_intervalo(-3.0, 3.0) as f32).collect(); - let x = Tensor::from_vec(xv, (n_lin, d_in), &dev).unwrap(); - let mut s_novo = fnh::SuavizadorQuant::novo(0.5, 0.98); - let mut s_tens = fnh::SuavizadorQuant::novo(0.5, 0.98); - let mut s_ref = fnh::SuavizadorQuant::novo(0.5, 0.98); - let mut bits_cal = true; - for _ in 0..3 { - s_novo.calibrar(&w, &x).unwrap(); - s_tens.calibrar_tensor(&w, &x).unwrap(); - s_ref.calibrar_referencia(&w, &x).unwrap(); - for (a, b) in s_novo.w_max.as_ref().unwrap().iter().zip(s_ref.w_max.as_ref().unwrap()) { - bits_cal &= a.to_bits() == b.to_bits(); - } - for (a, b) in s_novo.x_max.as_ref().unwrap().iter().zip(s_ref.x_max.as_ref().unwrap()) { - bits_cal &= a.to_bits() == b.to_bits(); - } - } - // tempo (esquentadas 1×; média de 5) - let _ = s_ref.calibrar_referencia(&w, &x); - let t0 = Instant::now(); - for _ in 0..5 { s_ref.calibrar_referencia(&w, &x).unwrap(); } - let t_cal_ref = t0.elapsed().as_secs_f64() / 5.0; - let _ = s_novo.calibrar(&w, &x); - let t0 = Instant::now(); - for _ in 0..5 { s_novo.calibrar(&w, &x).unwrap(); } - let t_cal_novo = t0.elapsed().as_secs_f64() / 5.0; - let _ = s_tens.calibrar_tensor(&w, &x); - let t0 = Instant::now(); - for _ in 0..5 { s_tens.calibrar_tensor(&w, &x).unwrap(); } - let t_cal_tens = t0.elapsed().as_secs_f64() / 5.0; - - // ---------- (3) forward: regressão de valores + gradiente ---------- - let (nm, dm, em) = (256usize, 32usize, 8usize); - let xv2: Vec = (0..nm * dm).map(|_| rng.normal(0.0, 1.0) as f32).collect(); - let x2 = Tensor::from_vec(xv2, (nm, dm), &dev).unwrap(); - #[allow(deprecated)] // oráculo do bug v080-1 (r-33 §5) - let moe = moe_redirecionavel::MoeRedirecionavel::novo(dm, em, 2, nm, &dev).unwrap(); - #[allow(deprecated)] - let s_refm = moe.fwd(&x2, moe_redirecionavel::Papel::Codificador).unwrap(); - let s_fwd = moe.forward(&x2, moe_redirecionavel::Papel::Codificador).unwrap(); - let dif_moe = (&s_refm.saida - &s_fwd.saida).unwrap().abs().unwrap() - .max_all().unwrap().to_scalar::().unwrap() as f64; - let perda = s_fwd.saida.sqr().unwrap().sum_all().unwrap(); - let gs = perda.backward().unwrap(); - let mut gr = 0.0f64; - for v in moe.roteador.vars() { - if let Some(g) = gs.get(&v) { - gr += g.sqr().unwrap().sum_all().unwrap().to_scalar::().unwrap() as f64; - } - } - let mut ge = 0.0f64; - for e in &moe.especialistas { - for v in e.vars() { - if let Some(g) = gs.get(&v) { - ge += g.sqr().unwrap().sum_all().unwrap().to_scalar::().unwrap() as f64; - } - } - } - - // ---------- (4) newtypes de domínio (T-V1) ---------- - let rejeita = crate::tipos::Probabilidade::novo(7.0).is_err() - && crate::tipos::Probabilidade::novo(-0.5).is_err() - && crate::tipos::Probabilidade::novo(f64::NAN).is_err() - && crate::tipos::GateAtivacao::novo(1.5).is_err(); - let aceita = crate::tipos::Probabilidade::novo(0.37).unwrap().valor() == 0.37; - let gate_tipado = fnh::GatePunicao::default() - .valor_tipado(&crate::tipos::Probabilidade::novo(0.9).unwrap()) - .valor(); - - let d_ = serde_json::json!({ - "versao": "criticas-v090-1.0", - "skew_index_add": { - "por_n": skew_rel, - "gates": { - "bits_iguais_todos_n": bits_todos, - }, - }, - "calibrar_zero_copia": { - "bits_iguais_3_passos": bits_cal, - "tempo_ref_s": t_cal_ref, "tempo_novo_s": t_cal_novo, - "tempo_tensor_s": t_cal_tens, - "speedup_zero_copia": t_cal_ref / t_cal_novo.max(1e-12), - "razao_tensor_vs_zero_copia": t_cal_tens / t_cal_novo.max(1e-12), - "gates": { "bit_a_bit": bits_cal, "nao_regride": t_cal_novo <= t_cal_ref * 1.05 }, - }, - "forward_canonico": { - "max_dif_valores_vs_oraculo": dif_moe, - "grad_roteador": gr, "grad_especialistas": ge, - "gates": { - "valores_iguais": dif_moe < 1e-4, - "gradiente_ativo": gr > 0.0 && ge > 0.0, - }, - }, - "newtypes_dominio": { - "rejeita_fora_do_dominio": rejeita, - "aceita_dentro": aceita, - "gate_tipado_em_0_9": gate_tipado, - "gates": { "fronteira_validada": rejeita && aceita }, - }, - }); - Ok(pythonize::pythonize(py, &d_)?.into()) -} diff --git a/src/python/fnh_arvore.rs b/src/python/fnh_arvore.rs deleted file mode 100644 index b7de1821592354571a358b470f66595302a5c8f9..0000000000000000000000000000000000000000 --- a/src/python/fnh_arvore.rs +++ /dev/null @@ -1,344 +0,0 @@ -//! `python::fnh_arvore` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - -use super::nucleo::ConfigPy; -use super::treino_fases::{carregar_gerador, carregar_tokenizador}; - - - -// --------------------------------------------------------------------------- -// v0.7.0 — bindings dos módulos novos (FNH, árvore, quebra-cabeça, NLP/NLG) -// --------------------------------------------------------------------------- - -/// Árvore de pesos indexada (arestas duplas) exposta ao Python. -#[pyclass(name = "ArvorePesos")] -pub(crate) struct ArvorePesosPy { - arvore: arvore_pesos::ArvorePesos, -} - -#[pymethods] -impl ArvorePesosPy { - #[staticmethod] - #[pyo3(signature = (contagens=None))] - fn nova(contagens: Option>) -> Self { - let c = contagens.unwrap_or_default(); - ArvorePesosPy { arvore: arvore_pesos::ArvorePesos::nova(&c) } - } - - fn invariantes_ok(&self) -> bool { - self.arvore.invariantes_ok().is_ok() - } - - fn agregar(&mut self, metrica: &str) -> f64 { - self.arvore.agregar_fundo_topo(metrica) - } - - fn aplicar_ajuste( - &mut self, - no: &str, - metrica: &str, - delta: f64, - delta_max: f64, - ) -> PyResult { - let idx = self - .arvore - .no(no) - .ok_or_else(|| pyo3::exceptions::PyKeyError::new_err(format!("nó '{no}' inexistente")))?; - Ok(self.arvore.aplicar_ajuste_indexado(idx, metrica, delta, delta_max)) - } - - fn definir_metrica(&mut self, no: &str, metrica: &str, valor: f64) -> PyResult<()> { - let idx = self - .arvore - .no(no) - .ok_or_else(|| pyo3::exceptions::PyKeyError::new_err(format!("nó '{no}' inexistente")))?; - self.arvore.nos[idx].metricas.insert(metrica.to_string(), valor); - Ok(()) - } - - fn metrica(&self, no: &str, metrica: &str) -> PyResult { - let idx = self - .arvore - .no(no) - .ok_or_else(|| pyo3::exceptions::PyKeyError::new_err(format!("nó '{no}' inexistente")))?; - Ok(self.arvore.nos[idx].metricas.get(metrica).copied().unwrap_or(0.0)) - } - - fn regular(&mut self, origem: &str, delta: f64, lambda: f64) -> PyResult<()> { - let idx = self - .arvore - .no(origem) - .ok_or_else(|| pyo3::exceptions::PyKeyError::new_err(format!("nó '{origem}' inexistente")))?; - self.arvore.regular_topo_fundo(idx, delta, lambda); - Ok(()) - } - - fn dump(&self) -> PyResult { - Python::with_gil(|py| { - let nos: Vec = self - .arvore - .nos - .iter() - .map(|no| { - serde_json::json!({ - "nome": no.nome, "ini": no.ini, "fim": no.fim, - "profundidade": no.profundidade, - "metricas": no.metricas, - }) - }) - .collect(); - let d = serde_json::json!({ - "n_nos": self.arvore.n_nos(), - "n_params": self.arvore.n_params, - "invariantes_ok": self.arvore.invariantes_ok().is_ok(), - "nos": nos, - }); - Ok(pythonize::pythonize(py, &d)?.into()) - }) - } -} - - -/// Demo/gate da camada FNH sobre o backbone: mede o efeito do gate de -/// punição nas rotações aprendíveis (ablação: π baixa vs π alta). -#[pyfunction] -#[pyo3(signature = (d_in=8, d_out=6, passos=60, seed=42))] -pub(crate) fn demo_fnh(py: Python, d_in: usize, d_out: usize, passos: usize, seed: u64) -> PyResult { - let dev = candle_core::Device::Cpu; - let mut rng = rng::RngDeterministico::novo(seed); - let mut camada = fnh::CamadaFNH::nova(d_in, d_out, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("fnh: {e}")))?; - let x: Vec = (0..4 * d_in).map(|_| rng.normal_padrao() as f32).collect(); - let xt = candle_core::Tensor::from_vec(x, (4, d_in), &dev) - .map_err(py_err)?; - camada - .suavizador - .calibrar(camada.base.w.as_tensor(), &xt) - .map_err(py_err)?; - // treino curto com punição ALTA (gate abre) vs BAIXA (gate fechado) - let mut resumo = serde_json::Map::new(); - for (rotulo, punicao) in [("baixa", 0.1f64), ("alta", 0.95)] { - let mut cam = fnh::CamadaFNH::nova(d_in, d_out, &dev).map_err(py_err)?; - // mesma semente de pesos: copia os valores - let _ = &mut cam; - let mut hub = telemetria::TelemetryHub::novo(None); - let mut perdas = Vec::new(); - for p in 0..passos { - // ruído no x a cada passo (regime não-estacionário leve) - let ruido: Vec = (0..4 * d_in) - .map(|_| (rng.normal(0.0, 0.05)) as f32) - .collect(); - let xt2 = (&xt - + &candle_core::Tensor::from_vec(ruido, (4, d_in), &dev).map_err(py_err)?) - .map_err(py_err)?; - let y = cam.forward(&xt2, punicao).map_err(py_err)?; - // alvo: saída da camada base (auto-referência: regular para W) - let z_ref = cam.linear_sem_bias(&xt2, cam.base.w.as_tensor()).map_err(py_err)?; - let perda = (&y).sub(&z_ref).map_err(py_err)?.sqr().map_err(py_err)?.sum_all().map_err(py_err)?; - perdas.push(perda.to_scalar::().map_err(py_err)? as f64); - let grads = perda.backward().map_err(py_err)?; - // gradiente descendente manual simples nos θ das rotações - if let Some(g) = grads.get(&cam.r_wp.theta) { - let gv = g.flatten_all().map_err(py_err)?.to_vec1::().map_err(py_err)?; - let th = cam.r_wp.theta.as_tensor().flatten_all().map_err(py_err)?.to_vec1::().map_err(py_err)?; - let novo: Vec = th.iter().zip(gv.iter()).map(|(t, g_)| t - 0.05 * g_).collect(); - cam.r_wp - .theta - .set(&candle_core::Tensor::from_vec(novo, th.len(), &dev).map_err(py_err)?) - .map_err(py_err)?; - } - hub.registrar("fnh_gate", cam.gate_ultimo); - hub.registrar("fnh_punicao", punicao); - hub.registrar("perda", perdas[p]); - let _ = p; - } - let theta_norma: f64 = cam - .r_wp - .theta - .as_tensor() - .flatten_all() - .map_err(py_err)? - .to_vec1::() - .map_err(py_err)? - .iter() - .map(|v| (*v as f64).powi(2)) - .sum::() - .sqrt(); - let delta_ort = cam.r_wp.erro_ortogonalidade().map_err(py_err)?; - resumo.insert( - format!("punicao_{rotulo}"), - serde_json::json!({ - "gate_final": cam.gate_ultimo, - "theta_norma": theta_norma, - "delta_ort": delta_ort, - "perda_inicial": perdas[0], - "perda_final": perdas[perdas.len() - 1], - }), - ); - } - let _ = &mut camada; - let d = serde_json::json!({ - "versao": "fnh-0.7.0", - "resumo": resumo, - }); - Ok(pythonize::pythonize(py, &d)?.into()) -} - - -/// **Quebra-cabeça sobre o conhecimento TREINADO REAL** (script 63): -/// carrega o tokenizador (codebook do nível `nivel` — o conhecimento -/// aprendido dos dados reais) e o gerador (a cabeça real como logits_fn -/// do verificador); executa o protocolo completo de r-30 Q-AD. -#[pyfunction] -#[pyo3(signature = (cfg, caminho_tokenizador, caminho_gerador, n_pecas=4, n_rodadas=12, tau_c=0.4, nivel=0, seed=777))] -pub(crate) fn quebra_cabeca_real( - cfg: &ConfigPy, - caminho_tokenizador: &str, - caminho_gerador: &str, - n_pecas: usize, - n_rodadas: usize, - tau_c: f64, - nivel: usize, - seed: u64, -) -> PyResult { - Python::with_gil(|py| { - let dev = candle_core::Device::Cpu; - crate::rng::definir_semente(seed); - let mut rng = rng::RngDeterministico::novo(seed); - let mut tok = tokenizador::TokenizadorConceitos::novo(&cfg.cfg, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("tok: {e}")))?; - carregar_tokenizador(&mut tok, caminho_tokenizador) - .map_err(pyo3::exceptions::PyRuntimeError::new_err)?; - let mut ger = gerador::GeradorConceitos::novo(&cfg.cfg, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("ger: {e}")))?; - ger.carregar(caminho_gerador) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("ger carregar: {e}")))?; - let nivel = nivel.min(tok.quants.len().saturating_sub(1)); - // conhecimento treinado REAL: codebook Stiefel (K, d_lat) - let codebook = tok - .quants[nivel] - .codebook() - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("codebook: {e}")))?; - let d_lat = codebook.dims()[1]; - let k = ger.k; - // δ_ort REAL do codebook treinado (rotação Stiefel em treino — A2) - let delta_ort_codebook = tok.quants[nivel] - .delta_ort() - .unwrap_or(1.0); - // logits_fn REAL: agregado (d_lat,) → proj_entrada → norm → cabeça - let proj = &ger.proj_entrada; - let norm = &ger.norm_entrada; - let cabeca = &ger.cabeca.cabecas[nivel]; - let logits_fn = move |x: &candle_core::Tensor| -> candle_core::Result { - let h = proj.fwd(&x.reshape((1, d_lat))?)?; - let h = norm.fwd(&h)?; - let lg = cabeca.fwd(&h)?; - lg.reshape((k,)) - }; - // verificador com temperatura calibrada pela fase C quando - // disponível; default 1,0 (a cota V-2 aplica-se com ECE medido) - let verif = verificador::VerificadorNcm::novo(); - let mut arvore = arvore_pesos::ArvorePesos::nova(&std::collections::HashMap::new()); - let cfg_qc = pensamento::ConfigQuebraCabeca::novo(n_pecas, n_rodadas, tau_c); - let r = pensamento::quebra_cabeca_inovar(&codebook, &verif, &logits_fn, &mut arvore, &cfg_qc, &mut rng) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("qc: {e}")))?; - let rodadas: Vec = r - .rodadas - .iter() - .map(|x| { - serde_json::json!({ - "rodada": x.rodada, "confianca": x.confianca, - "aceito": x.aceito, "delta": x.delta_aplicado, - }) - }) - .collect(); - let d_ = serde_json::json!({ - "versao": "quebra-cabeca-real-0.7.0", - "nivel": nivel, - "delta_ort_codebook": delta_ort_codebook, - "n_conceitos": codebook.dims()[0], - "d_lat": d_lat, - "aceitos": r.aceitos, - "rejeitados": r.rejeitados, - "confianca_base": r.confianca_base, - "confianca_melhor": r.confianca_melhor, - "telemetria": r.telemetria, - "rodadas": rodadas, - "arvore_invariantes": arvore.invariantes_ok().is_ok(), - "punicao_no_pensamento": arvore - .no("pensamento") - .and_then(|i| arvore.nos[i].metricas.get("punicao").copied()) - .unwrap_or(0.0), - }); - Ok(pythonize::pythonize(py, &d_)?.into()) - }) -} - - -/// Demo/gate do quebra-cabeça sobre conceitos SINTÉTICOS estruturados -/// (validação de mecanismo; a avaliação com dados reais vive no script 63). -#[pyfunction] -#[pyo3(signature = (m=24, d=8, n_pecas=4, n_rodadas=12, tau_c=0.35, seed=777))] -pub(crate) fn demo_quebra_cabeca( - py: Python, - m: usize, - d: usize, - n_pecas: usize, - n_rodadas: usize, - tau_c: f64, - seed: u64, -) -> PyResult { - let dev = candle_core::Device::Cpu; - let mut rng = rng::RngDeterministico::novo(seed); - // conceitos estruturados: cluster dominante +1 (média direcional) com - // 25% de outliers fracos — o agregado TEM direção (sem cancelamento) - let mut v = Vec::with_capacity(m * d); - for i in 0..m { - let centro = if i < m / 4 { 0.2 } else { 1.0 }; - for j in 0..d { - v.push((centro + rng.normal(0.0, 0.25)) as f32); - } - } - let conceitos = candle_core::Tensor::from_vec(v, (m, d), &dev).map_err(py_err)?; - // logits_fn ASSIMÉTRICO: projeção fixa W_proj (rotação-sensível — a - // agregação simétrica seria invariante sob permutação/rotação, e o - // backbone real é exatamente o avaliador NÃO-invariente da prática). - let mut wv = Vec::with_capacity(d * 4); - for _ in 0..d * 4 { - wv.push((rng.normal_padrao() as f32) * 2.5); - } - let w_proj = candle_core::Tensor::from_vec(wv, (d, 4), &dev).map_err(py_err)?; - // verificador com temperatura padrão - let verif = verificador::VerificadorNcm::novo(); - let logits_fn = |x: &candle_core::Tensor| -> candle_core::Result { - // logits = xᵀ·W_proj (4,) — sensível à direção do agregado - x.reshape((1, d))?.matmul(&w_proj)?.reshape((4,)) - }; - let mut arvore = arvore_pesos::ArvorePesos::nova(&std::collections::HashMap::new()); - let cfg = pensamento::ConfigQuebraCabeca::novo(n_pecas, n_rodadas, tau_c); - let r = pensamento::quebra_cabeca_inovar(&conceitos, &verif, &logits_fn, &mut arvore, &cfg, &mut rng) - .map_err(py_err)?; - let rodadas: Vec = r - .rodadas - .iter() - .map(|x| { - serde_json::json!({ - "rodada": x.rodada, "confianca": x.confianca, - "aceito": x.aceito, "delta": x.delta_aplicado, - }) - }) - .collect(); - let d_ = serde_json::json!({ - "versao": "quebra-cabeca-0.7.0", - "aceitos": r.aceitos, - "rejeitados": r.rejeitados, - "confianca_base": r.confianca_base, - "confianca_melhor": r.confianca_melhor, - "telemetria": r.telemetria, - "rodadas": rodadas, - "arvore_invariantes": arvore.invariantes_ok().is_ok(), - }); - Ok(pythonize::pythonize(py, &d_)?.into()) -} diff --git a/src/python/jepa_treinos.rs b/src/python/jepa_treinos.rs deleted file mode 100644 index 3dce01a8e5f72c6e34382f36b0ea2cb5166a5587..0000000000000000000000000000000000000000 --- a/src/python/jepa_treinos.rs +++ /dev/null @@ -1,251 +0,0 @@ -//! `python::jepa_treinos` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -/// Treina uma variante JEPA (7 variantes por máscara; lejepa/mcjepa/bjepa -/// têm funções próprias) sobre patches (n, d) com grade dada. -#[pyfunction] -pub(crate) fn treinar_jepa(py: Python, dados: Vec>, grid: Vec, variante: String, cfg: Option) -> PyResult { - let dev = candle_core::Device::Cpu; - let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut c = jepa::CfgJepa::default(); - if let Some(js) = &cfg { - if let Ok(v) = serde_json::from_str::(js) { - if let Some(o) = v.as_object() { - for (k, val) in o { - match k.as_str() { - "d_emb" => c.d_emb = val.as_u64().unwrap_or(32) as usize, - "epocas" => c.epocas = val.as_u64().unwrap_or(60) as usize, - "lr" => c.lr = val.as_f64().unwrap_or(3e-3), - "m" => c.m = val.as_f64().unwrap_or(0.99), - "lambda_vc" => c.lambda_vc = val.as_f64().unwrap_or(0.5), - "gamma_vc" => c.gamma_vc = val.as_f64().unwrap_or(1.0), - "frac_mascara" => c.frac_mascara = val.as_f64().unwrap_or(0.35), - "semente" => c.semente = val.as_u64().unwrap_or(42), - _ => {} - } - } - } - } - } - let var = match variante.as_str() { - "image" => jepa::VarianteJepa::ImageJepa, - "vjepa2" => jepa::VarianteJepa::VJepa2, - "audio" => jepa::VarianteJepa::AudioJepa, - "point" => jepa::VarianteJepa::PointJepa, - "jepa3d" => jepa::VarianteJepa::Jepa3D, - "brain" => jepa::VarianteJepa::BrainJepa, - "tjepa" => jepa::VarianteJepa::TJepa, - _ => jepa::VarianteJepa::TJepa, - }; - let grid2 = if grid.is_empty() { vec![t.dim(0).unwrap_or(1)] } else { grid }; - let rel = jepa::treinar_variante( - &t, - &|_n, r| jepa::mascara_por_variante(var, &grid2, c.frac_mascara, r), - &c, - var, - None, - &dev, - ) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let d = serde_json::json!({ - "versao": jepa::versao(), - "variante": rel.variante, - "perda_inicial": rel.perda_inicial, - "perda_final": rel.perda_final, - "perda_pred_inicial": rel.perda_pred_inicial, - "perda_pred_final": rel.perda_pred_final, - "queda_pct": if rel.perda_pred_inicial.is_finite() && rel.perda_pred_inicial > 0.0 { - 100.0 * (1.0 - rel.perda_pred_final / rel.perda_pred_inicial) - } else { 0.0 }, - "std_emb_inicial": rel.std_emb_inicial, - "std_emb_final": rel.std_emb_final, - "colapso_evitado": rel.std_emb_final > 0.05, - "n_patches": rel.n_patches, - "epocas": rel.epocas, - }); - Ok(pythonize::pythonize(py, &d)?.into()) -} - - -/// Treina LeJEPA (edição-condicionado): dados + instruções + editados. -#[pyfunction] -pub(crate) fn treinar_lejepa(py: Python, dados: Vec>, edits: Vec>, editados: Vec>, cfg: Option) -> PyResult { - let dev = candle_core::Device::Cpu; - let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let e = tensor_de_2d(edits, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let y = tensor_de_2d(editados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut c = jepa::CfgJepa::default(); - if let Some(js) = &cfg { - if let Ok(v) = serde_json::from_str::(js) { - if let Some(o) = v.as_object() { - if let Some(x) = o.get("epocas") { c.epocas = x.as_u64().unwrap_or(60) as usize; } - if let Some(x) = o.get("d_emb") { c.d_emb = x.as_u64().unwrap_or(32) as usize; } - if let Some(x) = o.get("lr") { c.lr = x.as_f64().unwrap_or(3e-3); } - if let Some(x) = o.get("semente") { c.semente = x.as_u64().unwrap_or(42); } - } - } - } - let rel = jepa::treinar_lejepa(&t, &e, &y, &c, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let d = serde_json::json!({ - "variante": rel.variante, "perda_inicial": rel.perda_inicial, - "perda_final": rel.perda_final, "std_emb_final": rel.std_emb_final, - "colapso_evitado": rel.std_emb_final > 0.05, - }); - Ok(pythonize::pythonize(py, &d)?.into()) -} - - -/// Treina MC-JEPA (cruz-modal): duas modalidades pareadas. -#[pyfunction] -pub(crate) fn treinar_mcjepa(py: Python, mod_a: Vec>, mod_b: Vec>, cfg: Option) -> PyResult { - let dev = candle_core::Device::Cpu; - let a = tensor_de_2d(mod_a, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let b = tensor_de_2d(mod_b, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut c = jepa::CfgJepa::default(); - if let Some(js) = &cfg { - if let Ok(v) = serde_json::from_str::(js) { - if let Some(o) = v.as_object() { - if let Some(x) = o.get("epocas") { c.epocas = x.as_u64().unwrap_or(60) as usize; } - if let Some(x) = o.get("d_emb") { c.d_emb = x.as_u64().unwrap_or(32) as usize; } - if let Some(x) = o.get("lr") { c.lr = x.as_f64().unwrap_or(3e-3); } - } - } - } - let rel = jepa::treinar_mcjepa(&a, &b, &c, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let d = serde_json::json!({ - "variante": rel.variante, "perda_inicial": rel.perda_inicial, - "perda_final": rel.perda_final, "std_emb_final": rel.std_emb_final, - "colapso_evitado": rel.std_emb_final > 0.05, - }); - Ok(pythonize::pythonize(py, &d)?.into()) -} - - -/// Treina BJEPA (bidirecional com consistência de ciclo) sobre sequência. -#[pyfunction] -pub(crate) fn treinar_bjepa(py: Python, serie: Vec>, cfg: Option) -> PyResult { - let dev = candle_core::Device::Cpu; - let t = tensor_de_2d(serie, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut c = jepa::CfgJepa::default(); - if let Some(js) = &cfg { - if let Ok(v) = serde_json::from_str::(js) { - if let Some(o) = v.as_object() { - if let Some(x) = o.get("epocas") { c.epocas = x.as_u64().unwrap_or(60) as usize; } - if let Some(x) = o.get("d_emb") { c.d_emb = x.as_u64().unwrap_or(32) as usize; } - if let Some(x) = o.get("lr") { c.lr = x.as_f64().unwrap_or(3e-3); } - } - } - } - let rel = jepa::treinar_bjepa(&t, &c, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let d = serde_json::json!({ - "variante": rel.variante, "perda_inicial": rel.perda_inicial, - "perda_final": rel.perda_final, "std_emb_final": rel.std_emb_final, - "colapso_evitado": rel.std_emb_final > 0.05, - }); - Ok(pythonize::pythonize(py, &d)?.into()) -} - - -/// Demo SonicMoE: roteamento top-k com capacidade e perda de balanceamento. -#[pyfunction] -pub(crate) fn demo_sonic_moe(py: Python, n: usize, d: usize, n_expertos: usize, top_k: usize, capacidade: usize) -> PyResult { - let dev = candle_core::Device::Cpu; - let moe = jepa::SonicMoe::novo(d, n_expertos, top_k, capacidade, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let x = candle_core::Tensor::randn(0f32, 1.0, (n, d), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let s = moe.fwd(&x).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let aux = s.perda_aux.to_scalar::().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? as f64; - let d_ = serde_json::json!({ - "versao": jepa::versao(), - "carga_por_especialista": s.carga, - "descartados": s.descartados, - "perda_aux": aux, - "capacidade_respeitada": s.carga.iter().all(|&c| c <= capacidade), - "saida_forma": s.saida.dims().to_vec(), - }); - Ok(pythonize::pythonize(py, &d_)?.into()) -} - - -/// Demo ReplaySSM: estabilidade + replay em cenário de troca de tarefa. -#[pyfunction] -pub(crate) fn demo_replay_ssm(py: Python, passos: usize, alpha: f64) -> PyResult { - let dev = candle_core::Device::Cpu; - let mut ssm = jepa::ReplaySsm::novo(4, 6, alpha, 8, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut otim = crate::treino::AdamWManual::novo(ssm.vars(), 1e-2, 0.0); - let x_antigo = candle_core::Tensor::from_vec(vec![1.0f32; 16 * 4], (16, 4), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut hist = Vec::new(); - for _ in 0..passos { - let h = ssm.scan(&x_antigo).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let alvo = h.detach(); - let (pt, pn, pr) = ssm.passo_treino(&x_antigo, &alvo, &mut otim) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - hist.push(serde_json::json!({"total": pt, "novo": pn, "replay": pr})); - } - let x_novo = candle_core::Tensor::from_vec(vec![-1.0f32; 16 * 4], (16, 4), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - for _ in 0..passos { - let h = ssm.scan(&x_novo).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let alvo = h.detach(); - let _ = ssm.passo_treino(&x_novo, &alvo, &mut otim) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - } - let h_fin = ssm.scan(&x_antigo).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mag = h_fin.sqr().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? - .max_all().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? - .to_scalar::().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? as f64; - let d_ = serde_json::json!({ - "versao": jepa::versao(), - "alpha_replay": alpha, - "historico": hist, - "magnitudes_finitas": mag.is_finite(), - "magnitude_max_pos_troca": mag, - }); - Ok(pythonize::pythonize(py, &d_)?.into()) -} - - -/// Extrai patches 2D de uma imagem achatada (C, H, W) — adaptador Image-JEPA. -#[pyfunction] -pub(crate) fn patches_2d(img: Vec, c: usize, h: usize, w: usize, ph: usize, pw: usize) -> PyResult>> { - let dev = candle_core::Device::Cpu; - let t = candle_core::Tensor::from_vec(img, (c, h, w), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let p = jepa::em_patches_2d(&t, ph, pw) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - p.to_vec2::().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}"))) -} - - -/// Extrai patches canal-independentes de série temporal (C, T) — T-JEPA. -#[pyfunction] -pub(crate) fn patches_serie(ts: Vec, c: usize, t: usize, pt: usize) -> PyResult>> { - let dev = candle_core::Device::Cpu; - let tt = candle_core::Tensor::from_vec(ts, (c, t), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let p = jepa::em_patches_serie(&tt, pt) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - p.to_vec2::().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}"))) -} - - -/// Extrai grupos FPS de nuvem de pontos (n, d) — Point-JEPA. -#[pyfunction] -pub(crate) fn grupos_pontos(pc: Vec>, k: usize, m: usize, semente: u64) -> PyResult>> { - let dev = candle_core::Device::Cpu; - let t = tensor_de_2d(pc, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut rng = crate::rng::RngDeterministico::novo(semente); - let g = jepa::em_grupos_pontos(&t, k, m, &mut rng) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let out = g.to_vec2::().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - Ok(out.into_iter().map(|l| l.into_iter().map(|v| v as f64).collect()).collect()) -} diff --git a/src/python/mod.rs b/src/python/mod.rs deleted file mode 100644 index 53800191d7c6cb5efa8830d19dc880baa2938cfb..0000000000000000000000000000000000000000 --- a/src/python/mod.rs +++ /dev/null @@ -1,145 +0,0 @@ -//! FFI Python (PyO3) — dividida por domínio (v0.10.0, r-35 §2). - -//! FFI Python (PyO3) do KHTST_RUST — todo o `#[pymodule]`, os -//! `#[pyfunction]`/`#[pyclass]` e a cola Python (conversões, -//! callbacks, demos) vivem AQUI desde a v0.9.0 (antes: lib.rs, -//! ~105 kB — crítica "God Object" do agente Qwen3.8, r-34 §5). -//! A lógica de domínio (src/*.rs) não importa pyo3: `cargo test -//! --no-default-features` executa a suíte SEM linkar o Python. -//! -//! Regra da casa mantida: nenhuma funcionalidade da superfície -//! Python foi removida — os mesmos símbolos são registrados no -//! `nucleo_rust`. - -use pyo3::prelude::*; - -use crate::*; - -// ---- divisão SRP v0.10.0 (r-35 §2): submódulos + re-exports ---- -mod calibracao; -mod demos_qwen; -mod fnh_arvore; -mod jepa_treinos; -mod moe; -mod nlp_nlg; -mod nucleo; -mod pensamento_demos; -mod som; -mod treino_fases; - - -// ---- itens mantidos no próprio mod.rs ---- - - - -/// Adaptador FFI→domínio (v0.9.0): embrulha um callable Python no tipo de -/// domínio `treino::CallbackTreino` — `treino.rs` não importa pyo3. -fn callback_treino_de_py(callback: Option>) -> treino::CallbackTreino { - use std::sync::Arc; - match callback { - None => None, - Some(c) => { - let f: pyo3::Py = c.unbind(); - let g: Arc = - Arc::new(move |dados: &serde_json::Value| { - pyo3::Python::with_gil(|py| { - if let Ok(obj) = pythonize::pythonize(py, dados) { - let _ = f.call1(py, (obj,)); - } - }); - }); - Some(g) - } - } -} - - -// =========================================================================== -// v0.5.0 — suíte SOM 4D, suíte JEPA, Pensamento, telemetria robusta -// =========================================================================== - -fn tensor_de_2d(dados: Vec>, dev: &candle_core::Device) -> candle_core::Result { - let d = dados.first().map(|r| r.len()).unwrap_or(1).max(1); - let n = dados.len(); - let flat: Vec = dados.into_iter().flat_map(|r| r.into_iter().map(|x| x as f32).collect::>()).collect(); - candle_core::Tensor::from_vec(flat, (n, d), dev) -} - - -// --------------------------------------------------------------------------- -// v0.6.0 — verificador NCM (sem oráculo), fase C, MoE redirecionável, -// acoplador duplex e autoajuste -// --------------------------------------------------------------------------- - -/// Converte matriz f64 → Tensor (n, d) F32. -fn tensor_f64_2d(v: &[Vec], dev: &candle_core::Device) -> candle_core::Result { - let (n, d) = (v.len(), v.first().map(|l| l.len()).unwrap_or(0)); - candle_core::Tensor::from_vec(v.iter().flatten().cloned().collect(), (n, d), dev) -} - - -fn py_err(e: candle_core::Error) -> pyo3::PyErr { - pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")) -} - - -#[pymodule] -fn nucleo_rust(m: &Bound<'_, PyModule>) -> PyResult<()> { - pyo3_log::init(); - m.add_function(wrap_pyfunction!(nucleo::versao, m)?)?; - m.add_function(wrap_pyfunction!(nucleo::info_build, m)?)?; - m.add_function(wrap_pyfunction!(nucleo::lint_config, m)?)?; - m.add_function(wrap_pyfunction!(treino_fases::treinar_fase_a, m)?)?; - m.add_function(wrap_pyfunction!(treino_fases::treinar_fase_b, m)?)?; - m.add_function(wrap_pyfunction!(treino_fases::gerar_amostras, m)?)?; - m.add_function(wrap_pyfunction!(nucleo::verificar_mascara, m)?)?; - m.add_function(wrap_pyfunction!(nucleo::verificar_stiefel, m)?)?; - // v0.10.0 — checkpoints atômicos com prova de integridade - m.add_function(wrap_pyfunction!(nucleo::checkpoint_valido, m)?)?; - m.add_function(wrap_pyfunction!(nucleo::checkpoint_manifesto, m)?)?; - m.add_function(wrap_pyfunction!(nucleo::sha256_arquivo, m)?)?; - // v0.5.0 — SOM 4D / JEPA / Pensamento - m.add_function(wrap_pyfunction!(som::treinar_som4d, m)?)?; - m.add_function(wrap_pyfunction!(som::treinar_gng, m)?)?; - m.add_function(wrap_pyfunction!(som::treinar_hsom, m)?)?; - m.add_function(wrap_pyfunction!(som::demo_tsom, m)?)?; - m.add_function(wrap_pyfunction!(jepa_treinos::treinar_jepa, m)?)?; - m.add_function(wrap_pyfunction!(jepa_treinos::treinar_lejepa, m)?)?; - m.add_function(wrap_pyfunction!(jepa_treinos::treinar_mcjepa, m)?)?; - m.add_function(wrap_pyfunction!(jepa_treinos::treinar_bjepa, m)?)?; - m.add_function(wrap_pyfunction!(jepa_treinos::demo_sonic_moe, m)?)?; - m.add_function(wrap_pyfunction!(jepa_treinos::demo_replay_ssm, m)?)?; - m.add_function(wrap_pyfunction!(pensamento_demos::classificar_erro, m)?)?; - m.add_function(wrap_pyfunction!(pensamento_demos::confianca_de_logits, m)?)?; - m.add_function(wrap_pyfunction!(pensamento_demos::projetar_ridge, m)?)?; - m.add_function(wrap_pyfunction!(pensamento_demos::demo_pensamento, m)?)?; - m.add_function(wrap_pyfunction!(jepa_treinos::patches_2d, m)?)?; - m.add_function(wrap_pyfunction!(jepa_treinos::patches_serie, m)?)?; - m.add_function(wrap_pyfunction!(jepa_treinos::grupos_pontos, m)?)?; - // v0.6.0 - m.add_function(wrap_pyfunction!(calibracao::calibrar_verificador, m)?)?; - m.add_function(wrap_pyfunction!(calibracao::demo_verificador_ncm, m)?)?; - m.add_function(wrap_pyfunction!(treino_fases::treinar_fase_c, m)?)?; - m.add_function(wrap_pyfunction!(moe::demo_moe_redirecionavel, m)?)?; - m.add_function(wrap_pyfunction!(moe::jepa_com_moe, m)?)?; - m.add_function(wrap_pyfunction!(moe::som_com_moe, m)?)?; - m.add_function(wrap_pyfunction!(moe::demo_acoplador_duplo, m)?)?; - m.add_function(wrap_pyfunction!(pensamento_demos::demo_pensamento_ncm, m)?)?; - m.add_function(wrap_pyfunction!(pensamento_demos::demo_autoajuste, m)?)?; - m.add_function(wrap_pyfunction!(fnh_arvore::demo_fnh, m)?)?; - m.add_function(wrap_pyfunction!(fnh_arvore::demo_quebra_cabeca, m)?)?; - m.add_function(wrap_pyfunction!(fnh_arvore::quebra_cabeca_real, m)?)?; - m.add_function(wrap_pyfunction!(nlp_nlg::demo_nlp_nlg, m)?)?; - m.add_function(wrap_pyfunction!(som::demo_autoajuste_som, m)?)?; - // v0.8.0 — análise/prova/teste das propostas Qwen3.8 - m.add_function(wrap_pyfunction!(demos_qwen::demo_qwen_v080, m)?)?; - // v0.9.0 — veredito executável das críticas Qwen3.8 (r-34) - m.add_function(wrap_pyfunction!(demos_qwen::demo_criticas_v090, m)?)?; - m.add_class::()?; - m.add_class::()?; - m.add_class::()?; - #[cfg(feature = "ponte_async")] - m.add_class::()?; - m.add_class::()?; - Ok(()) -} diff --git a/src/python/moe.rs b/src/python/moe.rs deleted file mode 100644 index e0806c8d0f1d5af7a45653a3a3139eca48a58def..0000000000000000000000000000000000000000 --- a/src/python/moe.rs +++ /dev/null @@ -1,190 +0,0 @@ -//! `python::moe` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -/// **MoE redirecionável — demo completa (M-R1..M-R5):** neutralidade da -/// atenção própria (M-R2), invariância de capacidade/perda auxiliar sob -/// redirecionamento (M-R1), paralelismo medido (M-R3), water-filling por -/// QE vs uniforme (M-R5) e fechamento da classe (M-R4 — via permutação). -#[pyfunction] -pub(crate) fn demo_moe_redirecionavel(d: usize, n: usize, semente: u64) -> PyResult { - Python::with_gil(|py| { - let dev = candle_core::Device::Cpu; - crate::rng::definir_semente(semente); - let mut rng = crate::rng::RngDeterministico::novo(semente); - let x: Vec = (0..n * d).map(|_| rng.normal(0.0, 1.0) as f32).collect(); - let x = candle_core::Tensor::from_vec(x, (n, d), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut moe = moe_redirecionavel::MoeRedirecionavel::novo(d, 8, 2, n, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - // M-R2: neutralidade no nascimento - let g0 = moe.atencao.gate.as_tensor().to_scalar::().unwrap(); - let y0 = moe.atencao.fwd(&x).unwrap(); - let dif0 = (&y0 - &x).unwrap().sqr().unwrap().sum_all().unwrap() - .to_scalar::().unwrap() as f64; - // abre o gate (mecanismo ativo) - moe.atencao.gate.set(&candle_core::Tensor::new(1.0f32, &dev).unwrap()).unwrap(); - // M-R1: invariância sob redirecionamento - let s_enc = moe.forward(&x, moe_redirecionavel::Papel::Codificador).unwrap(); - let carga_antes: usize = s_enc.carga.iter().sum(); - let perda_antes = s_enc.perda_aux.to_scalar::().unwrap() as f64; - let permuta: Vec = (0..8).map(|i| (i + 1) % 8).collect(); - moe.redirecionar(&permuta); - let s_enc2 = moe.forward(&x, moe_redirecionavel::Papel::Codificador).unwrap(); - let carga_depois: usize = s_enc2.carga.iter().sum(); - let perda_depois = s_enc2.perda_aux.to_scalar::().unwrap() as f64; - // M-R3: paralelismo medido (enc ∥ dec em 2 threads) - let (_e, _dc, t_par, t_seq, speedup) = moe.fwd_ambos_par(&x).unwrap(); - // M-R5: water-filling vs uniforme (cota analítica) - let qes: Vec = vec![0.15, 0.4, 1.0, 0.25, 0.6, 0.1, 0.35, 0.5]; - let c_wf = moe_redirecionavel::alocar_por_qe(&qes, 16); - let c_un = vec![2usize; 8]; - let cota = |c: &[usize]| qes.iter().zip(c).map(|(q, ci)| q * q / *ci as f64).sum::(); - let (cota_wf, cota_un) = (cota(&c_wf), cota(&c_un)); - let d_ = serde_json::json!({ - "versao": moe_redirecionavel::versao(), "d": d, "n": n, - "valor_gate_no_nascimento": g0, "neutralidade_dif": dif0, - "carga_antes": carga_antes, "carga_depois": carga_depois, - "perda_aux_antes": perda_antes, "perda_aux_depois": perda_depois, - "t_paralelo_s": t_par, "t_sequencial_s": t_seq, "speedup": speedup, - "alocacao_water_filling": c_wf, "cota_wf": cota_wf, "cota_uniforme": cota_un, - "gates": { - "gate_mr1_capacidade": carga_antes == carga_depois, - "gate_mr1_perda_aux": (perda_antes - perda_depois).abs() < 2.0 + 1e-6, - "gate_mr2_neutralidade": dif0 == 0.0 && g0 == 0.0, - "gate_mr3_paralelismo": t_par < t_seq, - "gate_mr5_water_filling": cota_wf <= cota_un + 1e-9, - }, - }); - Ok(pythonize::pythonize(py, &d_)?.into()) - }) -} - - -/// **JEPA com MoE redirecionável (ablação de 3 braços):** `modo` ∈ -/// {"pequena", "densa", "moe"} — o braço "densa" tem a capacidade TOTAL dos -/// especialistas SEM roteamento (isola o ganho do roteamento em si). -#[pyfunction] -pub(crate) fn jepa_com_moe( - patches: Vec>, - modo: String, - passos: usize, - frac_mascara: f64, - semente: u64, -) -> PyResult { - Python::with_gil(|py| { - let dev = candle_core::Device::Cpu; - let t = tensor_f64_2d(&patches.into_iter().map(|l| l.into_iter().map(|x| x as f64).collect()).collect::>>(), &dev) - .and_then(|t| t.to_dtype(candle_core::DType::F32)) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let modo: &'static str = match modo.as_str() { - "pequena" => "pequena", - "densa" => "densa", - _ => "moe", - }; - let r = moe_redirecionavel::treinar_jepa_com_moe(&t, modo, passos, frac_mascara, semente) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let d_ = serde_json::json!({ - "modo": r.modo, "perda_pred_inicial": r.perda_pred_inicial, - "perda_pred_final": r.perda_pred_final, "perda_vc_final": r.perda_vc_final, - "std_emb": r.std_emb, "carga_max": r.carga_max, "descartados": r.descartados, - "queda_abs": r.perda_pred_inicial - r.perda_pred_final, - "aprendeu": r.perda_pred_final < r.perda_pred_inicial, - }); - Ok(pythonize::pythonize(py, &d_)?.into()) - }) -} - - -/// **SOM refinado por MoE com water-filling (M-R5) + redirecionamento -/// para decodificador:** treina um 4D-SOM, refina com MoE (QE′ < QE), -/// compara com alocação uniforme e mede a decodificação pós-redirect. -#[pyfunction] -pub(crate) fn som_com_moe( - dados: Vec>, - lado: usize, - passos: usize, - semente: u64, -) -> PyResult { - Python::with_gil(|py| { - let dev = candle_core::Device::Cpu; - let t = tensor_f64_2d(&dados, &dev) - .and_then(|t| t.to_dtype(candle_core::DType::F32)) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - // treina o 4D-SOM (r-19: S4-1/S4-2/S4-3) — som4d opera em F32 - let cfg_som = som4d::CfgSom4D { nx: lado, ny: lado, nz: lado, nt: lado, ..Default::default() }; - let som = som4d::treinar_som4d(&t, &cfg_som, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let centroides: Vec> = som.prototipos.clone(); - // refinamento MoE (mesmo tensor F32; centroides seguem em f64) - let r = moe_redirecionavel::refinar_som_com_moe(&t, ¢roides, passos, semente) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let d_ = serde_json::json!({ - "qe_antes": r.qe_antes, "qe_depois_water_filling": r.qe_depois, - "qe_depois_uniforme": r.qe_alocacao_uniforme, - "carga_por_celula": r.carga_por_celula, - "tempo_treino_s": r.tempo_treino_s, - "mse_decodificador_pos_redirect": r.mse_decodificador, - "reducao_qe_pct": 100.0 * (r.qe_antes - r.qe_depois) / r.qe_antes.max(1e-12), - "gates": { - "gate_moe_refina": r.qe_depois < r.qe_antes, - "gate_wf_melhor_uniforme": r.qe_depois <= r.qe_alocacao_uniforme * 1.02, - "gate_redirect_decodifica": r.mse_decodificador < r.qe_antes.powi(2), - }, - }); - Ok(pythonize::pythonize(py, &d_)?.into()) - }) -} - - -/// **AcopladorDuplo — demo do protocolo lag-1 síncrono** (AC-1/AC-2): -/// rodadas duplex Pensamento↔backbone com correções decaindo (co-adaptação) -/// e confiança subindo; zero deadlocks/timeouts (P.1/P.2 herdados). -#[pyfunction] -pub(crate) fn demo_acoplador_duplo(rodadas: usize, timeout_ms: u64) -> PyResult { - Python::with_gil(|py| { - let mut ac = acoplador::AcopladorDuplo::nova(16, timeout_ms); - let mut rng = crate::rng::RngDeterministico::novo(77); - let mut conf = 0.05f64; - let mut traj = Vec::new(); - for k in 0..rodadas { - let estado = acoplador::EstadoModelo { - a: vec![0.1 * (k % 7) as f32; 16], - b: vec![rng.normal(0.0, 0.3) as f32; 16], - c: vec![0.05; 8], - confianca: conf, - nivel: k % 7, - passo: k, - }; - let _ = ac.rodada(estado).map_err(|e| - pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - // correção fresca: decaindo com a confiança (co-adaptação) - let amplitude = (1.0 - conf).max(0.05); - let delta: Vec = (0..16).map(|i| amplitude as f32 * ((i % 5) as f32 - 2.0) * 0.1).collect(); - ac.registrar_correcao(acoplador::Correcao { - delta, acordo: 0.6 + 0.3 * conf, confianca_agregada: conf, - iteracao: k, pesos: vec![0.25; 4], - }); - traj.push(conf); - conf = (conf + 0.04 + rng.uniforme() * 0.02).min(0.99); - } - let t = &ac.telemetria; - let p = ac.estatisticas(); - let d_ = serde_json::json!({ - "versao": acoplador::versao(), "rodadas": t.rodadas, - "timeouts": t.timeouts, "tempo_total_ms": t.tempo_total_ms, - "soma_norma_delta": t.soma_norma_delta, - "conf_final": traj.last(), "conf_trajetoria_len": traj.len(), - "envios_a_para_b": p.envios_a_para_b, "envios_b_para_a": p.envios_b_para_a, - "maior_sobreposicao_us": t.maior_sobreposicao_us, - "gates": { - "gate_terminou": t.rodadas == rodadas as u64, - "gate_sem_timeout": t.timeouts == 0, - "gate_duplex_simultaneo": p.envios_a_para_b == p.envios_b_para_a && p.envios_a_para_b == rodadas as u64, - }, - }); - Ok(pythonize::pythonize(py, &d_)?.into()) - }) -} diff --git a/src/python/nlp_nlg.rs b/src/python/nlp_nlg.rs deleted file mode 100644 index 88fc9a68b2979e765d4576559cab4f706ac0a8ea..0000000000000000000000000000000000000000 --- a/src/python/nlp_nlg.rs +++ /dev/null @@ -1,69 +0,0 @@ -//! `python::nlp_nlg` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -/// Demo/gate das unidades NLP/NLG sobre estados ocultos sintéticos -/// (nascimento neutro + gates + coerência de bigramas + especulativo). -#[pyfunction] -#[pyo3(signature = (d=32, t=6, seed=11))] -pub(crate) fn demo_nlp_nlg(py: Python, d: usize, t: usize, seed: u64) -> PyResult { - let dev = candle_core::Device::Cpu; - let mut rng = rng::RngDeterministico::novo(seed); - let v: Vec = (0..2 * t * d).map(|_| rng.normal_padrao() as f32).collect(); - let h = candle_core::Tensor::from_vec(v, (2, t, d), &dev).map_err(py_err)?; - // NLP: enriquecimento aditivo — neutro no nascimento - let mut nlp = nlp::UnidadeNlp::nova(d, &dev).map_err(|e| { - pyo3::exceptions::PyRuntimeError::new_err(format!("nlp (d%4): {e}")) - })?; - let h_enr = nlp.enriquecer(&h).map_err(py_err)?; - let dif_nlp = (&h).sub(&h_enr).map_err(py_err)?.abs().map_err(py_err)?.max_all().map_err(py_err)?.to_scalar::().map_err(py_err)? as f64; - // intenção - let (intencoes, confs) = nlp.intencao_argmax(&h).map_err(py_err)?; - // NLG: plano + condicionamento neutro + coerência - let mut nlg = nlg::UnidadeNlg::nova(d, 4096, &dev).map_err(py_err)?; - let plano = nlg.plano(&h).map_err(py_err)?; - let p8 = candle_core::Tensor::randn(0f32, 1f32, (nlg::N_EIXOS_ESTILO,), &dev).map_err(py_err)?; - let p01 = candle_nn::ops::sigmoid(&p8).map_err(py_err)?; - let h_cond = nlg.condicionar(&h, Some(&p01)).map_err(py_err)?; - let dif_nlg = (&h).sub(&h_cond).map_err(py_err)?.abs().map_err(py_err)?.max_all().map_err(py_err)?.to_scalar::().map_err(py_err)? as f64; - // coerência: contexto observado vs candidato novo - let ctx = vec![5u32, 6, 7, 8, 9]; - nlg.observar_contexto(&ctx); - let s_mesmo = nlg.score_coerencia(&ctx); - let s_novo = nlg.score_coerencia(&[50u32, 51, 52, 53]); - // especulativo: aceitação típica + stats - let mut espec = nlg::DecodificadorEspeculativo::novo(4, 0.95, 10); - let logits = candle_core::Tensor::from_vec(vec![3.0f32, 0.2, 0.1, 0.05], (4,), &dev) - .map_err(py_err)?; - let mut aceites = 0usize; - for _ in 0..30 { - let (_, ok) = espec.verificar_e_corrigir(&logits, &[0, 1]).map_err(py_err)?; - if ok { - aceites += 1; - } - } - let d_ = serde_json::json!({ - "versao": "nlp-nlg-0.7.0", - "nlp_gate_medio": nlp.gate_medio, - "nlp_dif_nascimento": dif_nlp, - "nlp_intencoes": intencoes, - "nlp_confiancas": confs, - "nlg_plano_forma": plano.dims(), - "nlg_dif_nascimento": dif_nlg, - "nlg_coerencia_mesmo": s_mesmo, - "nlg_coerencia_novo": s_novo, - "espec_aceitacao_media": espec.stats.aceitacao_media, - "espec_speedup": espec.stats.speedup_estimado, - "espec_aceites_30": aceites, - "gates": { - "nlp_neutro": dif_nlp == 0.0, - "nlg_neutro": dif_nlg == 0.0, - "gate_medio_ok": (nlp.gate_medio - 0.119).abs() < 0.05, - "coerencia_ok": s_mesmo > 0.9 && s_novo < 0.1, - "espec_ok": espec.stats.aceitacao_media > 0.8, - }, - }); - Ok(pythonize::pythonize(py, &d_)?.into()) -} diff --git a/src/python/nucleo.rs b/src/python/nucleo.rs deleted file mode 100644 index 1d55e570fea97e1361b54df48dfeb4d60466fed2..0000000000000000000000000000000000000000 --- a/src/python/nucleo.rs +++ /dev/null @@ -1,239 +0,0 @@ -//! `python::nucleo` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -#[pyfunction] -pub(crate) fn versao() -> &'static str { - concat!("khtst-rust-", env!("CARGO_PKG_VERSION")) -} - - -#[pyfunction] -pub(crate) fn info_build() -> String { - format!( - "rustc={}; perfil={}; features={}; alvo={}", - build_info::RUSTC_VERSION, - build_info::PROFILE, - build_info::FEATURES_STR, - build_info::TARGET, - ) -} - - -/// Lint de config com sugestões por Levenshtein (diagnóstico de digitação). -#[pyfunction] -pub(crate) fn lint_config(py: Python, caminho: &str) -> PyResult { - let txt = std::fs::read_to_string(caminho) - .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{caminho}: {e}")))?; - let v: serde_json::Value = serde_json::from_str(&txt) - .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("JSON inválido: {e}")))?; - let achatado = diagnostico::achatar(&v); - let avisos = diagnostico::lint_chaves(&achatado); - let saida: Vec = avisos - .iter() - .map(|a| serde_json::json!({ - "chave": a.chave, "sugestao": a.sugestao, "causa": a.causa, "correcao": a.correcao, - })) - .collect(); - Ok(pythonize::pythonize(py, &serde_json::json!(saida))?.into()) -} - - -#[pyclass(name = "Bpe")] -pub(crate) struct BpePy { - bpe: tokens::Bpe, -} - -#[pymethods] -impl BpePy { - #[staticmethod] - fn treinar(textos: Vec, vocab_alvo: usize) -> PyResult { - Ok(BpePy { bpe: tokens::Bpe::treinar(&textos, vocab_alvo) }) - } - - #[staticmethod] - fn carregar(caminho: &str) -> PyResult { - let txt = std::fs::read_to_string(caminho) - .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?; - let v: serde_json::Value = serde_json::from_str(&txt) - .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("JSON inválido: {e}")))?; - let bpe = tokens::Bpe::de_json(&v) - .ok_or_else(|| pyo3::exceptions::PyValueError::new_err("formato BPE inválido"))?; - Ok(BpePy { bpe }) - } - - fn codificar(&mut self, texto: &str) -> Vec { - self.bpe.codificar(texto) - } - - fn decodificar(&self, ids: Vec) -> String { - self.bpe.decodificar(&ids) - } - - fn salvar(&self, caminho: &str) -> PyResult<()> { - let txt = serde_json::to_string(&self.bpe.para_json()).unwrap(); - crate::checkpoint::salvar_atomico(caminho, &txt) - .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?; - Ok(()) - } - - #[getter] - fn n_vocab(&self) -> usize { - self.bpe.n_vocab() - } -} - - -#[pyclass(name = "Config")] -pub(crate) struct ConfigPy { - pub(crate) cfg: config::ConfigKhtst, - caminho: Option, -} - -#[pymethods] -impl ConfigPy { - #[new] - #[allow(never_type_fallback)] - #[pyo3(signature = (caminho=None))] - fn new(caminho: Option) -> PyResult { - let cfg = match &caminho { - Some(c) => { - let txt = std::fs::read_to_string(c) - .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{c}: {e}")))?; - let v: serde_json::Value = serde_json::from_str(&txt) - .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("JSON inválido: {e}")))?; - serde_json::from_value(v) - .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("config: {e}")))? - } - None => config::ConfigKhtst::default(), - }; - cfg.validar().map_err(pyo3::exceptions::PyValueError::new_err)?; - Ok(ConfigPy { cfg, caminho }) - } - - fn validar(&self) -> PyResult<()> { - self.cfg.validar().map_err(pyo3::exceptions::PyValueError::new_err) - } - - fn checar_orcamento_cache(&self) -> PyResult { - self.cfg.checar_orcamento_cache().map_err(pyo3::exceptions::PyValueError::new_err) - } - - fn resumo(&self) -> String { - format!( - "modelo(vocab={}, d={}, camadas={}, ctx={}) ncm(L={}, niveis={:?}, K={}, d_lat={}, modo={}, ativo={})", - self.cfg.modelo.vocab, self.cfg.modelo.d_modelo, self.cfg.modelo.n_camadas, - self.cfg.modelo.comprimento_ctx, self.cfg.l_niveis(), self.cfg.ncm.niveis, - self.cfg.ncm.k_por_nivel, self.cfg.ncm.d_lat, self.cfg.ncm.modo_quantizacao, self.cfg.ncm.ativo, - ) - } - - #[getter] - fn l_niveis(&self) -> usize { - self.cfg.l_niveis() - } -} - - -#[pyclass(name = "PonteDupla")] -pub(crate) struct PonteDuplaPy { - ponte: ponte::PonteDupla, -} - -#[pymethods] -impl PonteDuplaPy { - #[new] - #[pyo3(signature = (capacidade=64, timeout_ms=2000))] - fn new(capacidade: usize, timeout_ms: u64) -> Self { - PonteDuplaPy { ponte: ponte::PonteDupla::nova(capacidade, timeout_ms) } - } - - fn rodada(&self, carga_a: Vec, carga_b: Vec, nivel: usize) -> PyResult<(Vec, Vec)> { - let (ma, mb) = self.ponte.rodada(carga_a, carga_b, nivel) - .map_err(pyo3::exceptions::PyRuntimeError::new_err)?; - Ok((ma.carga, mb.carga)) - } - - fn demo_professor_aluno(&self, rodadas: usize, dim: usize) -> PyResult { - let inicio: Vec = (0..dim).map(|i| (i as f32) * 0.01).collect(); - let stats = ponte::demo_professor_aluno(&self.ponte, rodadas, inicio, &|a, _| { - a.iter().map(|x| x * 1.05).collect() - }) - .map_err(pyo3::exceptions::PyRuntimeError::new_err)?; - Python::with_gil(|py| { - Ok(pythonize::pythonize(py, &serde_json::to_value(&stats).unwrap())?.into()) - }) - } - - fn estatisticas(&self) -> PyResult { - let s = self.ponte.estatisticas(); - Python::with_gil(|py| { - Ok(pythonize::pythonize(py, &serde_json::to_value(&s).unwrap())?.into()) - }) - } -} - - -#[cfg(feature = "ponte_async")] -#[pyclass(name = "PonteAsync")] -pub(crate) struct PonteAsyncPy { - interna: std::sync::Arc, -} - -#[cfg(feature = "ponte_async")] -#[pymethods] -impl PonteAsyncPy { - #[new] - #[pyo3(signature = (capacidade=64, timeout_ms=2000))] - fn new(capacidade: usize, timeout_ms: u64) -> Self { - PonteAsyncPy { interna: std::sync::Arc::new(ponte::assincrona::PonteAsync::nova(capacidade, timeout_ms)) } - } - - /// Corrotina: `await ponte.trocar(a, b, nivel)` — duplex simultânea. - fn trocar<'p>(&self, py: Python<'p>, carga_a: Vec, carga_b: Vec, nivel: usize) -> PyResult> { - let p = self.interna.clone(); - pyo3_async_runtimes::tokio::future_into_py(py, async move { - let (ma, mb) = p.rodada_async(carga_a, carga_b, nivel) - .await - .map_err(pyo3::exceptions::PyRuntimeError::new_err)?; - Ok::<_, PyErr>((ma.carga, mb.carga)) - }) - } -} - - -/// Utilitários de prova expostos ao Python (V-série da suíte). -#[pyfunction] -pub(crate) fn verificar_mascara(cfg: &ConfigPy) -> PyResult { - let dev = candle_core::Device::Cpu; - let m = mascaras::mascara_block_causal(&cfg.cfg.ncm.niveis, gerador::N_PREFIXO, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - mascaras::contar_vazamentos(&cfg.cfg.ncm.niveis, gerador::N_PREFIXO, &m) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}"))) -} - - -#[pyfunction] -pub(crate) fn verificar_stiefel(k: usize, d: usize) -> PyResult { - let dev = candle_core::Device::Cpu; - let c = stiefel::init_stiefel(k, d, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - stiefel::erro_ortogonalidade(&c.transpose(0, 1).unwrap()).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}"))) -} - -#[pyfunction] -pub(crate) fn checkpoint_valido(caminho: &str) -> bool { - crate::checkpoint::validar(caminho) -} - -#[pyfunction] -pub(crate) fn checkpoint_manifesto(caminho: &str) -> Option { - std::fs::read_to_string(crate::checkpoint::caminho_manifesto(caminho)).ok() -} - -#[pyfunction] -pub(crate) fn sha256_arquivo(caminho: &str) -> Option { - std::fs::read(caminho).ok().map(|d| crate::checkpoint::sha256_hex(&d)) -} diff --git a/src/python/pensamento_demos.rs b/src/python/pensamento_demos.rs deleted file mode 100644 index 381fac2d50506608538a9f5418a023f150798fec..0000000000000000000000000000000000000000 --- a/src/python/pensamento_demos.rs +++ /dev/null @@ -1,367 +0,0 @@ -//! `python::pensamento_demos` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -/// Classificação de erro por taxonomia (diagnóstico de refatoração). -#[pyfunction] -pub(crate) fn classificar_erro(msg: String) -> Vec<(String, String, String)> { - diagnostico::classificar_erro(&msg) - .into_iter() - .map(|(a, b, c)| (a.to_string(), b.to_string(), c.to_string())) - .collect() -} - - -/// Confiança de uma distribuição (T-P1): `1 − H(softmax(z))/log K`. -#[pyfunction] -pub(crate) fn confianca_de_logits(logits: Vec) -> PyResult { - let dev = candle_core::Device::Cpu; - let k = logits.len(); - let t = candle_core::Tensor::from_vec(logits, (1, k), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - pensamento::confianca_de_logits(&t).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}"))) -} - - -/// Projeção ridge (T-P3 — montador algébrico): `r* = (WᵀW+εI)⁻¹Wᵀr`. -#[pyfunction] -pub(crate) fn projetar_ridge(w: Vec>, r_alvo: Vec>, eps: f64) -> PyResult>> { - let dev = candle_core::Device::Cpu; - let wt = tensor_de_2d(w, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let rt = tensor_de_2d(r_alvo, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let r = pensamento::projetar_ridge(&wt, &rt, eps) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let out = r.to_vec2::().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - Ok(out.into_iter().map(|l| l.into_iter().map(|v| v as f64).collect()).collect()) -} - - -/// Demo completa da tecnologia Pensamento: treino cooperativo das N redes -/// (item a) + ciclo d com verificador externo simulado + telemetria. -#[pyfunction] -pub(crate) fn demo_pensamento( - py: Python, - d_cond: usize, - d_saida: usize, - n_tentativas: usize, - passos_treino: usize, - limiar_conf: f64, - orcamento: usize, - semente: u64, -) -> PyResult { - use candle_core::Tensor; - let dev = candle_core::Device::Cpu; - crate::rng::definir_semente(semente); - let mut motor = pensamento::MotorPensamento::novo(d_cond, d_saida, n_tentativas, limiar_conf, orcamento, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut otim = crate::treino::AdamWManual::novo(motor.vars(), 5e-3, 0.0); - let mut rng = crate::rng::RngDeterministico::novo(semente); - - // dados sintéticos: alvo = função determinística não-linear de cond (d=a+b+c) - let n_dados = 256usize; - let conds: Vec> = (0..n_dados) - .map(|_| (0..d_cond).map(|_| rng.normal(0.0, 1.0) as f32).collect()) - .collect(); - let alvos: Vec> = conds - .iter() - .map(|c| { - (0..d_saida) - .map(|j| { - let cj = c[j % d_cond]; - let ck = c[(j + 1) % d_cond]; - 0.5 * cj + 0.3 * cj * ck + 0.1 - }) - .collect() - }) - .collect(); - let cond_t = Tensor::from_vec(conds.into_iter().flatten().collect(), (n_dados, d_cond), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let alvo_t = Tensor::from_vec(alvos.into_iter().flatten().collect(), (n_dados, d_saida), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - - // item a: treino cooperativo - let mut perda_hist = Vec::new(); - for passo in 0..passos_treino { - let perda = motor.perda_treino(&cond_t, &alvo_t) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - perda_hist.push(perda.to_scalar::().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? as f64); - otim.passo(crate::treino::grads_achatados(&perda, &motor.vars()) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?); - let _ = passo; - } - - // item c+d: consulta fora do padrão (OOD) — confiança baixa ⇒ Pensamento - let consulta: Vec = (0..d_cond).map(|j| 3.0 + (j as f32) * 0.1).collect(); - let consulta_t = Tensor::from_vec(consulta, (d_cond,), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - // verificador externo: negativo do MSE contra o alvo verdadeiro da consulta - let alvo_verdadeiro: Vec = (0..d_saida) - .map(|j| { - let cj = 3.0 + (j % d_cond) as f32 * 0.1; - let ck = 3.0 + ((j + 1) % d_cond) as f32 * 0.1; - 0.5 * cj + 0.3 * cj * ck + 0.1 - }) - .collect(); - let alvo_verd = Tensor::from_vec(alvo_verdadeiro.clone(), (d_saida,), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let verifica = |resp: &Tensor| -> f64 { - // confiança = 1/(1+10·MSE) — medível e causaL (só da resposta) - let dif = (resp.broadcast_as((1, d_saida)).unwrap() - &alvo_verd.broadcast_as((1, d_saida)).unwrap()).unwrap(); - let mse = dif.sqr().unwrap().mean_all().unwrap().to_scalar::().unwrap() as f64; - 1.0 / (1.0 + 10.0 * mse) - }; - let mut rng2 = crate::rng::RngDeterministico::novo(semente + 1); - let res = motor.raciocinar(&consulta_t, &verifica, &mut rng2) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - - // linha de base SEM pensamento: uma tentativa isolada, sem agregação - let base = motor.tentativas[0].fwd(&consulta_t.broadcast_as((1, d_cond)).unwrap()) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let conf_base = verifica(&base); - let conf_pensamento = res.confianca; - - let d_ = serde_json::json!({ - "versao": pensamento::versao(), - "n_tentativas": n_tentativas, - "perda_treino_inicial": perda_hist.first(), - "perda_treino_final": perda_hist.last(), - "treino_aprendeu": perda_hist.last().copied().unwrap_or(f64::INFINITY) < perda_hist.first().copied().map(|p| p * 0.5).unwrap_or(f64::INFINITY), - "iteracoes_ciclo_d": res.iteracoes, - "confianca_base_1_rede": conf_base, - "confianca_pensamento": conf_pensamento, - "ganho_confianca": conf_pensamento - conf_base, - "orcamento_esgotado": res.telemetria.get("orcamento_esgotado").copied().unwrap_or(0.0), - "telemetria": res.telemetria, - "eventos_ciclo": res.trajetoria.iter().map(|e| match e { - pensamento::EventoCiclo::Planejamento { iteracao, temperatura } => - serde_json::json!({"tipo": "planejamento", "iteracao": iteracao, "temperatura": temperatura}), - pensamento::EventoCiclo::DistribuicaoCompetencias { por_tentativa } => - serde_json::json!({"tipo": "distribuicao", "pesos": por_tentativa}), - pensamento::EventoCiclo::RePlanejamento { motivo } => - serde_json::json!({"tipo": "replanejamento", "motivo": motivo}), - pensamento::EventoCiclo::Resposta { confianca, iteracoes } => - serde_json::json!({"tipo": "resposta", "confianca": confianca, "iteracoes": iteracoes}), - }).collect::>(), - }); - Ok(pythonize::pythonize(py, &d_)?.into()) -} - - -/// **Ciclo d do Pensamento com o VERIFICADOR NCM** (produção, sem oráculo): -/// backbone CABEÇA TREINADA (alvo → classes) + verificador calibrado em -/// dados retidos; N tentativas agregadas; ganho medido em consultas retidas -/// EM DISTRIBUIÇÃO (onde a calibração vale — V-2) e OOD reportado à parte. -#[pyfunction] -pub(crate) fn demo_pensamento_ncm( - d_cond: usize, - d_saida: usize, - n_tentativas: usize, - passos_treino: usize, - limiar_conf: f64, - orcamento: usize, - semente: u64, -) -> PyResult { - Python::with_gil(|py| { - use candle_core::Tensor; - let dev = candle_core::Device::Cpu; - crate::rng::definir_semente(semente); - let mut motor = pensamento::MotorPensamento::novo( - d_cond, d_saida, n_tentativas, limiar_conf, orcamento, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut otim = treino::AdamWManual::novo(motor.vars(), 5e-3, 0.0); - let mut rng = crate::rng::RngDeterministico::novo(semente); - // ---- dados sintéticos (item a: treino cooperativo) ---- - let n_dados = 320usize; - let conds: Vec> = (0..n_dados) - .map(|_| (0..d_cond).map(|_| rng.normal(0.0, 1.0) as f32).collect()) - .collect(); - let alvos: Vec> = conds.iter().map(|c| { - (0..d_saida).map(|j| { - let cj = c[j % d_cond]; - let ck = c[(j + 1) % d_cond]; - 0.5 * cj + 0.3 * cj * ck + 0.1 - }).collect() - }).collect(); - let mk = |c: &[f32], j: usize| -> f32 { - let cj = c[j % d_cond]; - let ck = c[(j + 1) % d_cond]; - 0.5 * cj + 0.3 * cj * ck + 0.1 - }; - let cond_t = Tensor::from_vec(conds.iter().flatten().cloned().collect(), (n_dados, d_cond), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let alvo_t = Tensor::from_vec(alvos.iter().flatten().cloned().collect(), (n_dados, d_saida), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - // ---- BACKBONE (cabeça treinada): alvo → classes K ---- - // classe = faixa do 1º componente do alvo (aprendível, mensurável) - let k_classes = 12usize; - let classes: Vec = alvos - .iter() - .map(|a| { - let v = a[0]; - let f = (((v + 2.0) / 4.0) * (k_classes as f32)).floor(); - (f.clamp(0.0, (k_classes - 1) as f32)) as u32 - }) - .collect(); - let cabeca = crate::jepa::MlpJepa::novo(d_saida, 4 * d_saida, k_classes, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let classe_t = Tensor::from_vec(classes.clone(), (n_dados,), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut otim_cab = treino::AdamWManual::novo(cabeca.vars(), 1e-2, 0.0); - for _ in 0..200 { - let logits = cabeca.fwd(&alvo_t) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let ce = candle_nn::loss::cross_entropy(&logits, &classe_t) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - otim_cab.passo(treino::grads_achatados(&ce, &cabeca.vars()) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?); - } - // ---- VERIFICADOR calibrado em RETIDOS (metade final) ---- - let n_ret = n_dados / 2; - let (alvo_ret, clas_ret) = ( - alvo_t.narrow(0, n_ret, n_dados - n_ret).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?, - classe_t.narrow(0, n_ret, n_dados - n_ret).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?, - ); - let logits_ret = cabeca.fwd(&alvo_ret).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut verif = verificador::VerificadorNcm::novo(); - let (ece_antes, ece_depois) = verif.ajustar(&logits_ret, &clas_ret) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - // logits_fn: resposta (1, d_saida) → logits do backbone (1, K) - let logits_fn = |resp: &Tensor| -> candle_core::Result { - cabeca.fwd(resp) - }; - // ---- treino cooperativo do motor (item a) ---- - let cond_tr = cond_t.narrow(0, 0, n_ret).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let alvo_tr = alvo_t.narrow(0, 0, n_ret).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut hist = Vec::new(); - for _ in 0..passos_treino { - let perda = motor.perda_treino(&cond_tr, &alvo_tr) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let pv = perda.to_scalar::() - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? as f64; - hist.push(pv); - otim.passo(treino::grads_achatados(&perda, &motor.vars()) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?); - } - // ---- consultas RETIDAS em distribuição (ganho medido AQUI) ---- - let n_consultas = 8usize; - let mut confs_base = Vec::new(); - let mut confs_pens = Vec::new(); - let mut iteracoes = Vec::new(); - for qi in 0..n_consultas { - let consulta: Vec = conds[n_ret + qi].clone(); - let consulta_t = Tensor::from_vec(consulta, (d_cond,), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut rng2 = crate::rng::RngDeterministico::novo(semente + 1 + qi as u64); - let res = motor.raciocinar_ncm(&consulta_t, &verif, &logits_fn, &mut rng2) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - // base: 1 tentativa isolada, mesma verificação NCM - let base = motor.tentativas[0] - .fwd(&consulta_t.broadcast_as((1, d_cond)).unwrap()).unwrap(); - let conf_base = verif.confianca_1d(&logits_fn(&base).unwrap()).unwrap(); - confs_base.push(conf_base); - confs_pens.push(res.confianca); - iteracoes.push(res.iteracoes); - } - let media = |v: &[f64]| v.iter().sum::() / v.len().max(1) as f64; - let (conf_base_m, conf_pens_m) = (media(&confs_base), media(&confs_pens)); - let iteracoes_media = iteracoes.iter().sum::() as f64 / iteracoes.len().max(1) as f64; - // ---- consulta OOD (reporte honesto — sem gate de ganho) ---- - let consulta_ood: Vec = (0..d_cond).map(|j| 3.0 + (j as f32) * 0.1).collect(); - let consulta_ood_t = Tensor::from_vec(consulta_ood, (d_cond,), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut rng3 = crate::rng::RngDeterministico::novo(semente + 99); - let res_ood = motor.raciocinar_ncm(&consulta_ood_t, &verif, &logits_fn, &mut rng3) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let base_ood = motor.tentativas[0] - .fwd(&consulta_ood_t.broadcast_as((1, d_cond)).unwrap()).unwrap(); - let conf_base_ood = verif.confianca_1d(&logits_fn(&base_ood).unwrap()).unwrap(); - let _ = mk; - let d_ = serde_json::json!({ - "versao": "pensamento-0.6.0-ncm", - "n_tentativas": n_tentativas, - "perda_treino_inicial": hist.first(), "perda_treino_final": hist.last(), - "treino_aprendeu": hist.last().copied() < hist.first().map(|p| p * 0.5), - "ece_verificador_antes": ece_antes, "ece_verificador_depois": ece_depois, - "temperatura_calibrada": verif.temperatura, - "iteracoes_ciclo_d_media": iteracoes_media, - "confianca_base_1_rede": conf_base_m, - "confianca_pensamento": conf_pens_m, - "ganho_confianca": conf_pens_m - conf_base_m, - "confianca_ood_base": conf_base_ood, - "confianca_ood_pensamento": res_ood.confianca, - "iteracoes_ood": res_ood.iteracoes, - "orcamento_esgotado_ood": res_ood.telemetria.get("orcamento_esgotado").copied().unwrap_or(0.0), - "verificador": "ncm-calibrado (sem oraculo)", - "gates": { - "gate_verificador_sem_oraculo": true, - "gate_calibrado": ece_depois <= ece_antes, - "gate_ganho_nao_negativo": conf_pens_m >= conf_base_m - 1e-3, - "gate_terminou": iteracoes_media <= orcamento as f64, - }, - }); - Ok(pythonize::pythonize(py, &d_)?.into()) - }) -} - - - -/// **Autoajuste do Pensamento por telemetria (A-1..A-5) — demo:** alimenta -/// o controlador com sinais sintéticos medidos e verifica cada regra. -#[pyfunction] -pub(crate) fn demo_autoajuste(semente: u64) -> PyResult { - Python::with_gil(|py| { - let mut hub = telemetria::TelemetryHub::novo(None); - let mut rng = crate::rng::RngDeterministico::novo(semente); - let mut auto = controlador::AutoAjustePensamento::novo(0.5, 8, 2); - // A-1: confianças com mistura (60% altas ~0.85–0.95, 40% baixas ~0.25–0.40) - // ⇒ quantil 0.75 cai no grupo alto (posições 0.6–1.0) ≈ 0.85+0.375·0.1 ≈ 0.89 - for _ in 0..200 { - let c = if rng.uniforme() < 0.6 { 0.85 + rng.uniforme() * 0.1 } else { 0.25 + rng.uniforme() * 0.15 }; - auto.confs_retidas.push(c); - } - let tau = auto.ajustar_tau_c(0.25, &mut hub); - // A-3: acordos altos (0.88 ⇒ p̂ = (1+√0.76)/2 ≈ 0.936 ⇒ N = ln(20)/(2·0.436²) ≈ 7.9 ⇒ 8) - for _ in 0..32 { - auto.acordos.push(0.88); - } - let n_ajustado = auto.ajustar_n(0.05, 16, &mut hub); - // A-5: ganhos estáveis positivos (n=64 ⇒ 3º termo Bernstein ≈ 0.14 < 0.30) ⇒ gate sobe - for _ in 0..64 { - auto.ajustar_gate(0.30, 0.05, &mut hub); - } - let g_final = auto.gate_g; - // A-2: ganhos decaindo geometricamente - for k in 0..12 { - auto.ganhos_por_iteracao.push(0.25 * 0.6f64.powi(k)); - } - let b_ajustado = auto.ajustar_orcamento(0.02, &mut hub); - // A-4: UCB1 com 3 braços - let mut u = controlador::Ucb1::novo(vec!["n1".into(), "n4_moe".into(), "n4".into()]); - for _ in 0..200 { - let braco = u.escolher(); - let media = match braco { 0 => 0.35, 1 => 0.80, _ => 0.55 }; - let r = (media + rng.normal(0.0, 0.06) as f64).clamp(0.0, 1.0); - u.registrar(braco, r); - } - let medias = u.medias(); - let melhor = medias.iter().enumerate().max_by(|a, b| a.1.partial_cmp(b.1).unwrap()).map(|(i, _)| i).unwrap_or(0); - let d_ = serde_json::json!({ - "versao": "autoajuste-0.6.0", - "tau_c_final": tau, "n_tentativas_final": n_ajustado, - "gate_final": g_final, "orcamento_b_final": b_ajustado, - "ajustes_auditados": hub.eventos_ajuste.len(), - "ucb1_medias": medias, "ucb1_melhor_braco": u.nomes[melhor], - "ucb1_arrependimento_medio": u.arrependimento_empirico() / 200.0, - "gates": { - "gate_a1_tau_quantil": (tau - 0.89).abs() < 0.08, - "gate_a3_n_reduzido": n_ajustado <= 8, - "gate_a5_gate_subiu": g_final > 0.0, - "gate_a2_b_finito": b_ajustado >= 1 && b_ajustado <= 16, - "gate_a4_ucb1_achou": u.nomes[melhor] == "n4_moe", - }, - }); - Ok(pythonize::pythonize(py, &d_)?.into()) - }) -} diff --git a/src/python/som.rs b/src/python/som.rs deleted file mode 100644 index 2d31790de368a20532e3b9b21473291965291701..0000000000000000000000000000000000000000 --- a/src/python/som.rs +++ /dev/null @@ -1,180 +0,0 @@ -//! `python::som` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - - -/// Treina um 4D-SOM e devolve telemetria completa (EQ/TE/massa/cobertura). -#[pyfunction] -pub(crate) fn treinar_som4d(py: Python, dados: Vec>, cfg: Option) -> PyResult { - let dev = candle_core::Device::Cpu; - let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut c = som4d::CfgSom4D::default(); - if let Some(js) = &cfg { - if let Ok(v) = serde_json::from_str::(js) { - if let Some(o) = v.as_object() { - for (k, val) in o { - match k.as_str() { - "nx" => c.nx = val.as_u64().unwrap_or(4) as usize, - "ny" => c.ny = val.as_u64().unwrap_or(4) as usize, - "nz" => c.nz = val.as_u64().unwrap_or(4) as usize, - "nt" => c.nt = val.as_u64().unwrap_or(4) as usize, - "epocas" => c.epocas = val.as_u64().unwrap_or(50) as usize, - "sigma0" => c.sigma0 = val.as_f64().unwrap_or(2.0), - "sigma1" => c.sigma1 = val.as_f64().unwrap_or(0.5), - "eta0" => c.eta0 = val.as_f64().unwrap_or(0.5), - "eta1" => c.eta1 = val.as_f64().unwrap_or(0.05), - "semente" => c.semente = val.as_u64().unwrap_or(42), - "espalhada" => { - c.inicializacao = if val.as_bool().unwrap_or(false) { - som4d::Inicializacao4D::Espalhada - } else { - som4d::Inicializacao4D::Dados - } - } - _ => {} - } - } - } - } - } - let som = som4d::treinar_som4d(&t, &c, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let d = serde_json::json!({ - "versao": som4d::versao(), - "celulas": som.n_celulas(), - "grade": [som.nx, som.ny, som.nz, som.nt], - "eq_inicial": som.eq_inicial, - "eq_final": som.eq_final, - "te_final": som.te_final, - "historico_eq_te": som.historia, - "massa_soma": som.massa.iter().sum::(), - }); - Ok(pythonize::pythonize(py, &d)?.into()) -} - - -/// Treina um GNG e devolve telemetria (vértices, arestas, componentes, EQ). -#[pyfunction] -pub(crate) fn treinar_gng(py: Python, dados: Vec>, cfg: Option) -> PyResult { - let dev = candle_core::Device::Cpu; - let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut c = som4d::CfgGng::default(); - if let Some(js) = &cfg { - if let Ok(v) = serde_json::from_str::(js) { - if let Some(o) = v.as_object() { - for (k, val) in o { - match k.as_str() { - "passos" => c.passos = val.as_u64().unwrap_or(4000) as usize, - "max_vertices" => c.max_vertices = val.as_u64().unwrap_or(60) as usize, - "lambda" => c.lambda = val.as_u64().unwrap_or(50) as usize, - "eps_b" => c.eps_b = val.as_f64().unwrap_or(0.05), - "eps_n" => c.eps_n = val.as_f64().unwrap_or(0.006), - "idade_max" => c.idade_max = val.as_u64().unwrap_or(50) as u32, - "semente" => c.semente = val.as_u64().unwrap_or(42), - _ => {} - } - } - } - } - } - let g = som4d::treinar_gng(&t, &c) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let d = serde_json::json!({ - "versao": som4d::versao(), - "vertices": g.vertices.len(), - "arestas": g.arestas.len(), - "componentes_conexas": g.n_componentes_conexas(), - "insercoes": g.insercoes, - "eq_medio": g.eq_medio, - }); - Ok(pythonize::pythonize(py, &d)?.into()) -} - - -/// Treina um H-SOM e devolve a decomposição hierárquica (Teo H-1). -#[pyfunction] -pub(crate) fn treinar_hsom(py: Python, dados: Vec>, cfg: Option) -> PyResult { - let dev = candle_core::Device::Cpu; - let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut c = som4d::CfgHSom::default(); - if let Some(js) = &cfg { - if let Ok(v) = serde_json::from_str::(js) { - if let Some(o) = v.as_object() { - if let Some(x) = o.get("celulas_finas") { - c.celulas_finas = x.as_u64().unwrap_or(9) as usize; - } - if let Some(x) = o.get("epocas_finas") { - c.epocas_finas = x.as_u64().unwrap_or(20) as usize; - } - } - } - } - let h = som4d::treinar_hsom(&t, &c, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let cota = h.eq_grosso + 2.0 * h.r_fino + 2.0 * (h.eq_grosso * h.r_fino).sqrt(); - let d = serde_json::json!({ - "versao": som4d::versao(), - "eq_hierarquico": h.eq_hierarquico, - "eq_grosso": h.eq_grosso, - "r_fino": h.r_fino, - "cota_teo_h1": cota, - "cota_respeitada": h.eq_hierarquico <= cota + 1e-9, - }); - Ok(pythonize::pythonize(py, &d)?.into()) -} - - -/// Demo T-SOM: streaming com deriva controlada — rastreio (Teo T-1). -#[pyfunction] -pub(crate) fn demo_tsom(py: Python, dados_iniciais: Vec>, janela: Vec>, passos: usize, gamma: f64) -> PyResult { - let dev = candle_core::Device::Cpu; - let t0 = tensor_de_2d(dados_iniciais, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let cfg = som4d::CfgTSom { - cfg_grade: som4d::CfgSom4D { nx: 3, ny: 3, nz: 2, nt: 2, epocas: 15, ..Default::default() }, - gamma, - janela: janela.len(), - }; - let mut ts = som4d::TSom4D::novo(&t0, &cfg, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let mut historico = Vec::new(); - for _ in 0..passos { - let eq = ts.passo(&janela); - historico.push(eq); - } - let d = serde_json::json!({ - "versao": som4d::versao(), - "gamma": gamma, - "eq_temporal_historico": historico, - "t_passos": ts.t, - }); - Ok(pythonize::pythonize(py, &d)?.into()) -} - - -/// Demo/gate do auto-ajuste SOM com tetos (S-AB/S-SL). -#[pyfunction] -pub(crate) fn demo_autoajuste_som(py: Python) -> PyResult { - let mut a = controlador::AutoAjusteSom::novo(0.5, 1.0); - let (al_qe, _) = a.passo(1.0, 0.0, 0.0); - let (al_cross, sg_cross) = a.passo(0.0, 0.0, 1.0); - let (al_max, sg_max) = a.passo(1.0, 1.0, 1.0); - let mut parou_5chunks = false; - for _ in 0..5 { - parou_5chunks = a.avaliar_parada(0.95, 0.1, 0.1, false, true, false, false); - } - let d_ = serde_json::json!({ - "versao": "som-autoadjust-0.7.0", - "alfa_qe_alta": al_qe, "alfa_crossing": al_cross, "sigma_crossing": sg_cross, - "alfa_max": al_max, "sigma_max": sg_max, - "parou_5chunks": parou_5chunks, - "motivo": a.motivo_parada, - "gates": { - "tetos_ok": al_max <= 1.0 + 1e-9 && sg_max <= 2.0 + 1e-9, - "piso_ok": al_cross >= 0.5 - 1e-9, - "qe_sobe": al_qe > 0.5, - "stop_dispara": parou_5chunks, - }, - }); - Ok(pythonize::pythonize(py, &d_)?.into()) -} diff --git a/src/python/treino_fases.rs b/src/python/treino_fases.rs deleted file mode 100644 index be801291dbdeb594d2e0a1225d257873037203a8..0000000000000000000000000000000000000000 --- a/src/python/treino_fases.rs +++ /dev/null @@ -1,228 +0,0 @@ -//! `python::treino_fases` — extraído do monólito na v0.10.0 -//! (divisão SRP, crítica Qwen3.8 lote 3 nº 1; r-35 §2). - -use super::*; - -use super::nucleo::ConfigPy; - - -/// Treina a fase A (tokenizador). Devolve dict com resumo + telemetria. -#[pyfunction] -#[pyo3(signature = (cfg, sequencias, caminho_telemetria=None, caminho_checkpoint=None, callback=None, teto_seg=None))] -pub(crate) fn treinar_fase_a( - cfg: &ConfigPy, - sequencias: Vec>, - caminho_telemetria: Option, - caminho_checkpoint: Option, - callback: Option>, - teto_seg: Option, -) -> PyResult { - let cb = callback_treino_de_py(callback); - let mut hub = telemetria::TelemetryHub::novo(caminho_telemetria); - let dados = treino::DadosTreino::novo(sequencias, cfg.cfg.modelo.comprimento_ctx); - let mut resumo = treino::treinar_fase_a(&cfg.cfg, &dados, &mut hub, &cb, caminho_checkpoint.as_deref(), teto_seg) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("fase A: {e}")))?; - let _ = &mut resumo; - Python::with_gil(|py| { - let dados = serde_json::json!({ - "resumo": { - "passos": resumo.passos, "perda_inicial": resumo.perda_inicial, - "perda_final": resumo.perda_final, "acc_recon": resumo.acc_recon, - "delta_ort_max": resumo.delta_ort_max, - "perplexidade_codebook": resumo.perplexidade_codebook, - "monotonia_prefixo": resumo.monotonia_prefixo, - "escore_aprendizado": resumo.escore_aprendizado, - }, - "telemetria": hub.dump(), - }); - Ok(pythonize::pythonize(py, &dados)?.into()) - }) -} - - -/// Treina a fase B (gerador) com tokenizador congelado carregado de checkpoint. -#[pyfunction] -#[pyo3(signature = (cfg, sequencias, caminho_tokenizador, caminho_telemetria=None, caminho_checkpoint=None, callback=None, teto_seg=None))] -pub(crate) fn treinar_fase_b( - cfg: &ConfigPy, - sequencias: Vec>, - caminho_tokenizador: &str, - caminho_telemetria: Option, - caminho_checkpoint: Option, - callback: Option>, - teto_seg: Option, -) -> PyResult { - let cb = callback_treino_de_py(callback); - let mut hub = telemetria::TelemetryHub::novo(caminho_telemetria); - let dados = treino::DadosTreino::novo(sequencias, cfg.cfg.modelo.comprimento_ctx); - // carrega o tokenizador congelado - let dev = candle_core::Device::Cpu; - let mut tok = tokenizador::TokenizadorConceitos::novo(&cfg.cfg, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("construção: {e}")))?; - carregar_tokenizador(&mut tok, caminho_tokenizador) - .map_err(pyo3::exceptions::PyRuntimeError::new_err)?; - let resumo = treino::treinar_fase_b(&cfg.cfg, &tok, &dados, &mut hub, &cb, caminho_checkpoint.as_deref(), teto_seg) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("fase B: {e}")))?; - Python::with_gil(|py| { - let dados = serde_json::json!({ - "resumo": { - "passos": resumo.passos, "perda_inicial": resumo.perda_inicial, - "perda_final": resumo.perda_final, "acc_conceitos": resumo.acc_recon, - "escore_aprendizado": resumo.escore_aprendizado, - }, - "telemetria": hub.dump(), - }); - Ok(pythonize::pythonize(py, &dados)?.into()) - }) -} - - -pub(crate) fn carregar_tokenizador(tok: &mut tokenizador::TokenizadorConceitos, caminho: &str) -> Result<(), String> { - let txt = std::fs::read_to_string(caminho).map_err(|e| format!("{e}"))?; - let v: serde_json::Value = serde_json::from_str(&txt).map_err(|e| format!("{e}"))?; - let obj = v.as_object().ok_or("formato de checkpoint inválido")?; - let vars = tok.vars(); - for (i, var) in vars.iter().enumerate() { - if let Some(entrada) = obj.get(&format!("v{i}")) { - let forma: Vec = entrada["forma"].as_array().map(|a| a.iter().filter_map(|x| x.as_u64().map(|y| y as usize)).collect()).unwrap_or_default(); - let dados: Vec = entrada["dados"].as_array().map(|a| a.iter().filter_map(|x| x.as_f64().map(|y| y as f32)).collect()).unwrap_or_default(); - if forma.is_empty() || dados.is_empty() { - continue; - } - let dev = candle_core::Device::Cpu; - let t2 = candle_core::Tensor::from_vec(dados, forma.clone(), &dev) - .and_then(|t| t.reshape(forma)) - .map_err(|e| format!("{e}"))?; - var.set(&t2).map_err(|e| format!("{e}"))?; - } - } - Ok(()) -} - - -/// Gera amostras com NFE = L e devolve textos decodificados (modo conceitos). -#[pyfunction] -#[pyo3(signature = (cfg, caminho_tokenizador, caminho_gerador, n_amostras=2, parar_no_nivel=None, greedy=true))] -pub(crate) fn gerar_amostras( - cfg: &ConfigPy, - caminho_tokenizador: &str, - caminho_gerador: &str, - n_amostras: usize, - parar_no_nivel: Option, - greedy: bool, -) -> PyResult { - let dev = candle_core::Device::Cpu; - let mut tok = tokenizador::TokenizadorConceitos::novo(&cfg.cfg, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - carregar_tokenizador(&mut tok, caminho_tokenizador) - .map_err(pyo3::exceptions::PyRuntimeError::new_err)?; - let mut ger = gerador::GeradorConceitos::novo(&cfg.cfg, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - carregar_gerador(&mut ger, caminho_gerador) - .map_err(pyo3::exceptions::PyRuntimeError::new_err)?; - let mut amostrador = amostrador::AmostradorConceitos::novo( - &mut ger, &tok, cfg.cfg.ncm.cfg_scale, cfg.cfg.ncm.temperaturas.limites, cfg.cfg.ncm.temperaturas.entropia_alvo, - ); - let mut rng = ::seed_from_u64(4242); - let inicio = std::time::Instant::now(); - let (codigos, nfe) = amostrador.gerar(n_amostras.max(1), &dev, &mut rng, parar_no_nivel, greedy) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("amostragem: {e}")))?; - let tempo_ms = inicio.elapsed().as_secs_f64() * 1000.0; - // decodifica: ẑ final → decoder AR greedy → tokens - let nivel_final = codigos.len(); - let zhats = tok.reconstruir_de_codigos(&codigos, nivel_final, n_amostras.max(1), &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - let textos_ids = decodificar_textos(&tok, zhats.last(), n_amostras.max(1)) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?; - Python::with_gil(|py| { - let d = serde_json::json!({ - "nfe": nfe, "l": cfg.cfg.l_niveis(), "tempo_ms": tempo_ms, - "niveis_usados": nivel_final, "ids_tokens": textos_ids, - "temperaturas": amostrador.temperaturas, - }); - Ok(pythonize::pythonize(py, &d)?.into()) - }) -} - - -fn decodificar_textos(tok: &tokenizador::TokenizadorConceitos, zhat: Option<&candle_core::Tensor>, b: usize) -> Result>, String> { - let Some(z) = zhat else { return Ok(vec![vec![]; b]) }; - tok.decodificar_livre(z, 48).map_err(|e| format!("{e}")) -} - - -pub(crate) fn carregar_gerador(ger: &mut gerador::GeradorConceitos, caminho: &str) -> Result<(), String> { - let txt = std::fs::read_to_string(caminho).map_err(|e| format!("{e}"))?; - let v: serde_json::Value = serde_json::from_str(&txt).map_err(|e| format!("{e}"))?; - let obj = v.as_object().ok_or("formato inválido")?; - let vars = ger.vars(); - for (i, var) in vars.iter().enumerate() { - if let Some(entrada) = obj.get(&format!("v{i}")) { - let forma: Vec = entrada["forma"].as_array().map(|a| a.iter().filter_map(|x| x.as_u64().map(|y| y as usize)).collect()).unwrap_or_default(); - let dados: Vec = entrada["dados"].as_array().map(|a| a.iter().filter_map(|x| x.as_f64().map(|y| y as f32)).collect()).unwrap_or_default(); - if forma.is_empty() || dados.is_empty() { - continue; - } - let dev = candle_core::Device::Cpu; - let t = candle_core::Tensor::from_vec(dados, forma.clone(), &dev) - .and_then(|t| t.reshape(forma)) - .map_err(|e| format!("{e}"))?; - var.set(&t).map_err(|e| format!("{e}"))?; - } - } - Ok(()) -} - - -/// **FASE C — treino conjunto Pensamento↔backbone** (dados reais). -#[pyfunction] -pub(crate) fn treinar_fase_c( - cfg: &ConfigPy, - sequencias: Vec>, - caminho_tokenizador: &str, - passos: usize, - caminho_gerador: Option, - caminho_telemetria: Option, - callback: Option>, - teto_seg: Option, -) -> PyResult { - let cb = callback_treino_de_py(callback); - let mut hub = telemetria::TelemetryHub::novo(caminho_telemetria); - let dados = treino::DadosTreino::novo(sequencias, cfg.cfg.modelo.comprimento_ctx); - let dev = candle_core::Device::Cpu; - let mut tok = tokenizador::TokenizadorConceitos::novo(&cfg.cfg, &dev) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("construção: {e}")))?; - carregar_tokenizador(&mut tok, caminho_tokenizador) - .map_err(pyo3::exceptions::PyRuntimeError::new_err)?; - let resumo = treino::treinar_fase_c(&cfg.cfg, &tok, &dados, &mut hub, &cb, teto_seg, passos, caminho_gerador.as_deref()) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("fase C: {e}")))?; - Python::with_gil(|py| { - let dados = serde_json::json!({ - "resumo": { - "passos": resumo.passos, - "ce_inicial": resumo.ce_inicial, - "ce_final": resumo.ce_final, - "ce_gatilhada_sem_correcao": resumo.ce_gatilhada_sem_correcao, - "ce_gatilhada_com_correcao": resumo.ce_gatilhada_com_correcao, - "confianca_media_inicial": resumo.confianca_media_inicial, - "confianca_media_final": resumo.confianca_media_final, - "confianca_pos_correcao": resumo.confianca_pos_correcao, - "taxa_gatilho": resumo.taxa_gatilho, - "ece_antes": resumo.ece_antes, - "ece_depois": resumo.ece_depois, - "temperatura_calibrada": resumo.temperatura_calibrada, - "tau_c": resumo.tau_c, - "taxa_conflito_pcgrad": resumo.taxa_conflito_pcgrad, - "decaimento_delta": resumo.decaimento_delta, - "acordos_medios": resumo.acordos_medios, - "escore_aprendizado": resumo.escore_aprendizado, - "rodadas_acoplador": resumo.rodadas_acoplador, - "timeouts_acoplador": resumo.timeouts_acoplador, - "maior_sobreposicao_us": resumo.maior_sobreposicao_us, - }, - "painel_v060": hub.painel_v060(), - "telemetria": hub.dump(), - }); - Ok(pythonize::pythonize(py, &dados)?.into()) - }) -} diff --git a/src/quantizador.rs b/src/quantizador.rs index 6c8b67c9f452f6655519d4173d28ed01a240252a..bc55ee7b58f733e5e440eed6d1c6fe4cfa8b4120 100644 --- a/src/quantizador.rs +++ b/src/quantizador.rs @@ -169,6 +169,50 @@ impl QuantizadorNivel { stiefel::erro_ortogonalidade(&c.transpose(0, 1)?) } + /// **Coerência μ do codebook (v0.10.0, crítica DeepSeek A.1 — Teo + /// A.1′ em r-35 §4.2):** `μ = max_{i≠j} |⟨û_i, û_j⟩|` com `û` as + /// linhas NORMALIZADAS. Para codebooks ortonormais (K ≤ d, RCO), μ ≈ + /// δ_ort (teoricamente 0); para frames K > d, o limite inferior de + /// Welch é `μ ≥ √((K−d)/(d(K−1)))` — a degradação da contração do Teo + /// A.1 sob não-ortonormalidade é `1 + (K−1)·μ` (autovalores do Gram + /// em `[1−(K−1)μ, 1+(K−1)μ]` — Gershgorin). Telemetria reporta μ por + /// nível; com δ_ort medido ~1e-6 no treino real (r-27), a folga do + /// pior caso é ~(K−1)·μ ≈ 6e-5. + pub fn coerencia(&self) -> Result { + let c = self.codebook()?.detach(); + let c2 = contiguo_2d(&c)?; + let normas = c2 + .sqr()? + .sum_keepdim(D::Minus1)? + .sqrt()? + .clamp(1e-12, f64::INFINITY)?; + let unit = c2.broadcast_div(&normas)?; + let gram = unit.matmul(&unit.transpose(0, 1)?)?; + let k = gram.dims()[0]; + // máx fora-da-diagonal + let g = gram.flatten_all()?.to_vec1::()?; + let mut mx = 0f64; + for i in 0..k { + for j in 0..k { + if i != j { + mx = mx.max((g[i * k + j] as f64).abs()); + } + } + } + Ok(mx) + } + + /// Limite inferior de Welch para K códigos em d dimensões (A.1′): + /// `μ ≥ √((K−d)/(d(K−1)))` quando K > d; 0 quando K ≤ d (otronormal + /// é atingível). Devolve (limite, K, d). + pub fn limite_welch(k: usize, d: usize) -> f64 { + if k <= d || d == 0 { + 0.0 + } else { + ((k - d) as f64 / (d as f64 * (k - 1) as f64)).sqrt() + } + } + /// Amostra ruído de Gumbel (n, K) — fora do grafo (constante). pub fn ruido_gumbel(&self, n: usize, k: usize, dev: &Device) -> Result { use rand::prelude::*; @@ -398,4 +442,80 @@ mod testes_debug { assert!(erro < 1e-4, "grad nativo vs op = {erro}\n n={g_n:?}\n o={g_o:?}"); Ok(()) } + + // ----------------------------------------------------------------- + // v0.10.0 — A.0′/A.1′ (críticas DeepSeek NCM). Provas em r-35 §4. + // ----------------------------------------------------------------- + + /// **A.0′ (viés do STE quantificado — pedido da crítica):** com dither + /// uniforme de largura Δ (= célula do quantizador uniforme) e perda + /// quadrática (M = Lip(∇L) = 2), o estimador dithered-STE + /// `E_u[ĝ_STE(z+u)]` desvia do gradiente VERDADEIRO do objetivo + /// suavizado `F(z) = E_u[L(q(z+u))]` por no máximo `M·Δ/2 = Δ` por + /// coordenada (Teo A.0′-ii, r-35 §4.1; derivação exata no caso 1D: + /// E_u[q(z+u)] = z e F'(z) = [L(q(z+Δ/2)) − L(q(z−Δ/2))]/Δ). + /// O teste verifica a cota em vários offsets de célula. + #[test] + fn a0_vies_ste_limitado_pelo_dither() { + // quantizador uniforme 4 níveis, célula Δ=0.5, níveis nos centros + let delta = 0.5f64; + // níveis nos CENTROS das células kΔ (arredondar-para-o-mais-próximo): + // condição de momento E_u[q(z+u)] = z do dither uniforme (Gray–Stockham) + let q = |w: f64| -> f64 { + let cel = (w / delta + 0.5).floor(); + (cel * delta).clamp(0.0, 3.0 * delta) + }; + let alvo = 0.83f64; + let perda = |w: f64| (q(w) - alvo) * (q(w) - alvo); + let m_lip = 2.0f64; // ∇² da quadrática + let mut rng = crate::rng::RngDeterministico::novo(17); + // offsets de célula variados (evita exatamente 0 — degenerescência) + for s_frac in [0.05f64, 0.2, 0.35, 0.45, 0.5, 0.65, 0.8, 0.95] { + let z = 2.0 * delta + s_frac * delta; // célula 2 (longe das bordas) + // (a) gradiente verdadeiro de F por diferenças finitas exatas + let f_prime = (perda(z + delta / 2.0) - perda(z - delta / 2.0)) / delta; + // (b) estimador dithered-STE por Monte Carlo (20k amostras) + let n_mc = 20_000usize; + let mut soma = 0.0f64; + for _ in 0..n_mc { + let u = (rng.uniforme() - 0.5) * delta; + let w = z + u; + soma += 2.0 * (q(w) - alvo); // ĝ_STE(w) = ∇L(q(w)) + } + let est = soma / n_mc as f64; + // ruído MC: |ĝ| ≤ 2·(4Δ) ⇒ σ ≤ 8Δ/√n ≈ 0.0028; 4σ folga + let ruido = 4.0 * 8.0 * delta / (n_mc as f64).sqrt(); + let vies = (est - f_prime).abs(); + assert!( + vies <= m_lip * delta / 2.0 + ruido, + "A.0′: viés {vies:.5} > cota M·Δ/2+ruido = {:.5} (s_frac={s_frac}, \ +est={est:.5}, F'={f_prime:.5})", + m_lip * delta / 2.0 + ruido + ); + } + } + + /// **A.1′ (coerência de Welch):** codebook Stiefel K ≤ d tem μ ≈ 0 + /// (medido); o limite de Welch só é positivo para K > d — verificação + /// da fórmula e da monotonia em K. + #[test] + fn a1_coerencia_e_limite_welch() { + // fórmula: K ≤ d ⇒ 0; K > d ⇒ √((K−d)/(d(K−1))), monotônico em K + assert_eq!(QuantizadorNivel::limite_welch(4, 8), 0.0); + let w_64 = QuantizadorNivel::limite_welch(256, 64); + let w_96 = QuantizadorNivel::limite_welch(256, 96); + assert!(w_64 > w_96 && w_96 > 0.0, "welch deve decrescer com d: {w_64} vs {w_96}"); + // valor exato: K=128, d=64 ⇒ √(64/(64·127)) = √(1/127) + let w = QuantizadorNivel::limite_welch(128, 64); + assert!((w - (1.0f64 / 127.0).sqrt()).abs() < 1e-12, "welch(128,64) = {w}"); + // codebook REAL Stiefel K=16 ≤ d=32: μ pequeno (δ_ort nível ~1e-3 + // nas iterações de polar padrão) + let dev = candle_core::Device::Cpu; + let qq = QuantizadorNivel::novo(16, 32, ModoQuant::SteEma, 0.99, "ema_projecao", &dev) + .unwrap(); + let mu = qq.coerencia().unwrap(); + assert!(mu < 0.2, "coerência de codebook Stiefel Kd equivalente? (informativo) + println!("a1: μ(Stiefel 16×32) = {mu:.6}, δ_ort = {:?}", qq.delta_ort().unwrap()); + } } diff --git a/src/raciocinio_elastico.rs b/src/raciocinio_elastico.rs new file mode 100644 index 0000000000000000000000000000000000000000..f3772b8fd3e06c581208301a53f9c28c92b58a2f --- /dev/null +++ b/src/raciocinio_elastico.rs @@ -0,0 +1,923 @@ +//! `raciocinio_elastico` — v0.11.0 (r-42): raciocínio REAJUSTÁVEL +//! (ênfase por relevância via Hedge + water-filling) e COMPRIMÍVEL +//! (certificado de remoção de massa de atenção RE-2 + prefixos anytime RE-3). +//! +//! Teoremas: RE-1..RE-8 em `docs/memorias/r-42-raciocinio-elastico-v011.md`. +//! Princípios do repo: nascimento neutro, determinismo por semente, telemetria +//! auditada com motivo, rollback defensivo, zero acesso ao futuro (RE-7). +//! +//! Tratamento de erros (tratamento.txt): TODAS as falhas são `Result` +//! propagado com `?` — nenhum `unwrap`/`expect`/`panic!` em caminho de +//! produção; validação de configuração falha CEDO com mensagem específica. + +use crate::controlador::AutoAjustePensamento; +use crate::pensamento::{EventoCiclo, MotorPensamento, ResultadoPensamento}; +use crate::rng::RngDeterministico; +use crate::telemetria::TelemetryHub; +use crate::verificador::VerificadorNcm; +use candle_core::{bail, Result as DResult, Tensor, D}; +use std::collections::HashMap; + +// --------------------------------------------------------------------------- +// Configuração (validada — falha cedo, nunca em silêncio) +// --------------------------------------------------------------------------- + +#[derive(Debug, Clone)] +pub struct ConfigElastica { + /// Limiar de confiança calibrada (V-2′). + pub tau_c: f64, + /// Orçamento MÁXIMO de iterações (RE-4: Σ realocações ≤ B_max). + pub b_max: usize, + /// Teto de peças no banco (memória limitada). + pub max_pecas: usize, + /// Fator EMA da relevância (0 < β ≤ 1). + pub beta_relevancia: f64, + /// Clip do supremo de logits no segmento (H1 de RE-2). + pub z_sup: f64, + /// Norma espectral da cabeça de logits ‖W‖₂ (medida ou cota ‖W‖_F). + pub norma_w: f64, + /// Nº de classes da cabeça (K ≥ 2 para L_conf). + pub n_classes: usize, + /// Passo Hedge (None ⇒ agenda √(2 ln N / T)). + pub eta_hedge: Option, + /// Fator de expansão do difusor no re-planejamento. + pub fator_temp: f64, + pub temp_max: f64, + pub semente: u64, +} + +impl Default for ConfigElastica { + fn default() -> Self { + Self { + tau_c: 0.9, + b_max: 8, + max_pecas: 64, + beta_relevancia: 0.3, + z_sup: 12.0, + norma_w: 1.0, + n_classes: 16, + eta_hedge: None, + fator_temp: 1.6, + temp_max: 2.0, + semente: 42, + } + } +} + +impl ConfigElastica { + /// Validação total (tratamento.txt: erros recuperáveis com motivo + /// específico — nunca panic em estado inválido). + pub fn validar(&self) -> DResult<()> { + if !(0.0..1.0).contains(&self.tau_c) { + bail!("tau_c deve estar em (0,1) — recebido {}", self.tau_c); + } + if self.b_max == 0 || self.max_pecas == 0 { + bail!("b_max ({}) e max_pecas ({}) devem ser >= 1", self.b_max, self.max_pecas); + } + if !(0.0..=1.0).contains(&self.beta_relevancia) || self.beta_relevancia == 0.0 { + bail!("beta_relevancia ({}) deve estar em (0,1]", self.beta_relevancia); + } + if self.z_sup <= 0.0 || self.norma_w <= 0.0 { + bail!("z_sup ({}) e norma_w ({}) devem ser > 0 (H1 de RE-2)", self.z_sup, self.norma_w); + } + if self.n_classes < 2 { + bail!("n_classes ({}) deve ser >= 2 (L_conf = 2·Z_sup·‖W‖/ln K)", self.n_classes); + } + if self.fator_temp < 1.0 || self.temp_max <= 0.0 { + bail!("fator_temp ({}) >= 1 e temp_max ({}) > 0", self.fator_temp, self.temp_max); + } + Ok(()) + } + + /// L_conf de RE-2: `2·Z_sup·‖W‖₂ / ln K` (Lipschitz da confiança em y). + pub fn lipschitz_conf(&self) -> f64 { + 2.0 * self.z_sup * self.norma_w / (self.n_classes as f64).ln() + } +} + +// --------------------------------------------------------------------------- +// Banco de peças (RE-1/RE-2/RE-6) +// --------------------------------------------------------------------------- + +/// Peça de raciocínio: vetor (1, d_saida), relevância EMA, última massa de +/// atenção e custo em unidades de compute/tokens (RE-5/RE-8). +#[derive(Debug, Clone)] +pub struct Peca { + pub vetor: Tensor, + pub relevancia: f64, + pub massa: f64, + pub custo: usize, + /// Nível de prefixo NCM corrente (RE-3; 0 = não quantizada). + pub nivel_prefixo: usize, +} + +/// RE-2: orçamento de massa removível que PRESERVA o aceite. +/// `ε_safe = (conf − τ_c) / (2·|g|·V_max·L_conf)`; 0 sem margem; +/// ∞ com gate=0 (neutralidade T-P5: compressão livre). +pub fn epsilon_seguro(conf: f64, tau_c: f64, gate: f64, v_max: f64, l_conf: f64) -> f64 { + let margem = conf - tau_c; + if margem <= 0.0 || v_max <= 0.0 || l_conf <= 0.0 { + return 0.0; + } + let denom = 2.0 * gate.abs() * v_max * l_conf; + if denom <= f64::EPSILON { + return f64::INFINITY; // gate=0 ⇒ compressão livre (neutralidade T-P5) + } + margem / denom +} + +/// RE-1: massas de atenção das peças como chaves extras: softmax sobre +/// [k_base; extras] por linha de q; devolve a massa média por peça (P,). +/// `q (b, n_q, d)`, `k_base (b, n_kv, d)`, `extras (P, d)`. +pub fn massas_extra(q: &Tensor, k_base: &Tensor, extras: &Tensor) -> DResult> { + let (b, _nq, d) = q.dims3()?; + let p = extras.dim(0)?; + if p == 0 { + return Ok(Vec::new()); + } + let ke = extras.reshape((1, p, d))?.broadcast_as((b, p, d))?; + let k = Tensor::cat(&[k_base.clone(), ke], 1)?; + let scores = q.matmul(&k.transpose(1, 2)?)?.affine(1.0 / (d as f64).sqrt(), 0.0)?; + let attn = candle_nn::ops::softmax(&scores, D::Minus1)?; // (b, n_q, n_kv+p) + let n_kv = k_base.dim(1)?; + let extra = attn.narrow(2, n_kv, p)?; // (b, n_q, p) + let media = extra.mean(1)?.mean(0)?; // (p,) — média sobre queries e lote + Ok(media.to_vec1::()?.iter().map(|&x| x as f64).collect()) +} + +/// Proxy de massa quando não há atenção disponível (cosseno com o consenso, +/// softmax β=4 — MESMA forma do combinador). O certificado RE-2 só é VÁLIDO +/// com massas de atenção reais; com proxy, `valido=false` e o rollback por +/// re-verificação é o único guardião (honestidade r-42 §2). +pub fn massas_proxy(pecas: &[Tensor]) -> DResult> { + if pecas.is_empty() { + return Ok(Vec::new()); + } + let cand = Tensor::cat(pecas, 0)?; // (P, d) + let consenso = cand.mean_keepdim(0)?; // (1, d) + let dot = cand.matmul(&consenso.transpose(0, 1)?)?; // (P, 1) + let nc = cand.sqr()?.sum_keepdim(D::Minus1)?.sqrt()?; // (P, 1) + let ncs = consenso.sqr()?.sum_keepdim(D::Minus1)?.sqrt()?; // (1, 1) + let cos = dot.broadcast_div(&nc.broadcast_mul(&ncs)?.clamp(1e-12, f64::INFINITY)?)?; + let w = candle_nn::ops::softmax(&cos.affine(4.0, 0.0)?, 0)?; + Ok(w.flatten_all()?.to_vec1::()?.iter().map(|&x| x as f64).collect()) +} + +/// Compressão gulosa por massa ASCENDENTE sob orçamento ε (maximiza o Nº de +/// peças removidas com custos uniformes; RE-2). Devolve (índices mantidos, +/// massa removida). Determinística: empate por índice. +pub fn comprimir_por_massa(massas: &[f64], eps: f64) -> (Vec, f64) { + let mut ordem: Vec = (0..massas.len()).collect(); + ordem.sort_by(|&a, &b| massas[a].total_cmp(&massas[b]).then(a.cmp(&b))); + let mut removidos = vec![false; massas.len()]; + let mut acc = 0.0; + for &i in &ordem { + if acc + massas[i] <= eps { + removidos[i] = true; + acc += massas[i]; + } + } + let mantidos: Vec = (0..massas.len()).filter(|&i| !removidos[i]).collect(); + // nunca remover TODAS (a resposta precisa de ao menos uma peça) + if mantidos.is_empty() && !massas.is_empty() { + let melhor = ordem.last().copied().unwrap_or(0); + return (vec![melhor], acc - massas[melhor]); + } + (mantidos, acc) +} + +/// RE-6: pesos Hedge sobre perdas acumuladas (previsíveis — só passado). +pub fn pesos_hedge(perdas_acum: &[f64], eta: f64) -> Vec { + let min = perdas_acum.iter().cloned().fold(f64::INFINITY, f64::min); + let exps: Vec = perdas_acum.iter().map(|&l| (-eta * (l - min)).exp()).collect(); + let soma: f64 = exps.iter().sum::().max(1e-300); + exps.iter().map(|e| e / soma).collect() +} + +/// RE-5/M-R5′: water-filling INTEIRO ótimo (guloso marginal, argumento de +/// troca — r-41). `q_i ≥ 0`, `C ≥ q.len()`; devolve c_i ≥ 1 com Σ c_i = C. +/// Delega ao canônico `moe_redirecionavel::alocar_por_qe` (uma única +/// implementação provada — DRY). +pub fn alocar_guloso(q: &[f64], c_total: usize) -> DResult> { + let m = q.len(); + if m == 0 || c_total < m { + bail!("alocar_guloso: precisa C ({c_total}) >= m ({m}) >= 1"); + } + Ok(crate::moe_redirecionavel::alocar_por_qe(q, c_total)) +} + +// --------------------------------------------------------------------------- +// Motor elástico (compõe o MotorPensamento existente — SRP) +// --------------------------------------------------------------------------- + +pub struct RaciocinioElastico { + pub motor: MotorPensamento, + pub cfg: ConfigElastica, + pub auto: AutoAjustePensamento, + pub pecas: Vec, + perdas_acum: Vec, + conf_anterior: f64, +} + +/// Resultado com CERTIFICADO de compressão (auditável). +#[derive(Debug, Clone)] +pub struct CertificadoCompressao { + pub epsilon_safe: f64, + pub massa_removida: f64, + pub bound_delta_conf: f64, + pub delta_conf_medido: f64, + pub violado: bool, + pub rollback: bool, + pub valido: bool, +} + +pub struct ResultadoElastico { + pub base: ResultadoPensamento, + pub certificados: Vec, + pub pesos_hedge_final: Vec, + pub alocacao_final: Vec, + pub telemetria_extra: HashMap, +} + +impl RaciocinioElastico { + pub fn novo(motor: MotorPensamento, cfg: ConfigElastica) -> DResult { + cfg.validar()?; + let auto = AutoAjustePensamento::novo(cfg.tau_c, cfg.b_max, motor.n); + Ok(Self { + motor, + cfg, + auto, + pecas: Vec::new(), + perdas_acum: Vec::new(), + conf_anterior: 0.0, + }) + } + + fn registrar_pecas(&mut self, candidatos: &Tensor) -> DResult<()> { + let n = candidatos.dim(0)?; + for i in 0..n { + let vetor = candidatos.get(i)?.reshape((1, self.motor.d_saida))?; + self.pecas.push(Peca { + vetor, + relevancia: 0.0, + massa: 0.0, + custo: 1, + nivel_prefixo: 0, + }); + self.perdas_acum.push(0.0); + } + // teto de memória: descartar as de menor relevância (FIFO em empate) + if self.pecas.len() > self.cfg.max_pecas { + let excesso = self.pecas.len() - self.cfg.max_pecas; + let mut ordem: Vec = (0..self.pecas.len()).collect(); + ordem.sort_by(|&a, &b| { + self.pecas[a] + .relevancia + .partial_cmp(&self.pecas[b].relevancia) + .unwrap_or(std::cmp::Ordering::Equal) + .then(a.cmp(&b)) + }); + let descartar: std::collections::HashSet = + ordem[..excesso].iter().copied().collect(); + let (p, l): (Vec<_>, Vec<_>) = std::mem::take(&mut self.pecas) + .into_iter() + .zip(std::mem::take(&mut self.perdas_acum)) + .enumerate() + .filter(|(i, _)| !descartar.contains(i)) + .map(|(_, (p, l))| (p, l)) + .unzip(); + self.pecas = p; + self.perdas_acum = l; + } + Ok(()) + } + + /// RE-6: ganho marginal ⇒ perda ℓ = 1 − clip(ganho, 0, 1); relevância EMA. + fn atualizar_relevancia(&mut self, conf: f64, pesos_participacao: &[f64]) { + let ganho = (conf - self.conf_anterior).max(0.0); + let beta = self.cfg.beta_relevancia; + for (i, peca) in self.pecas.iter_mut().enumerate() { + let w = pesos_participacao.get(i).copied().unwrap_or(0.0); + let ganho_i = (ganho * w).clamp(0.0, 1.0); + peca.relevancia = (1.0 - beta) * peca.relevancia + beta * ganho_i; + self.perdas_acum[i] += 1.0 - ganho_i; + } + self.conf_anterior = conf; + } + + fn eta(&self, t: usize) -> f64 { + self.cfg.eta_hedge.unwrap_or_else(|| { + let n = self.pecas.len().max(2) as f64; + (2.0 * n.ln() / t.max(1) as f64).sqrt() + }) + } + + fn matriz_pecas(&self, idx: &[usize]) -> DResult { + if idx.is_empty() { + bail!("matriz_pecas: banco vazio — ao menos uma peça é requerida"); + } + let linhas: Vec = idx.iter().map(|&i| self.pecas[i].vetor.clone()).collect(); + Ok(Tensor::cat(&linhas, 0)?) + } + + /// Agregação por pesos de ênfase (média ponderada T-P2′ com pesos + /// PREVISÍVEIS) + montagem aprendida do motor sobre os `n` candidatos + /// correntes (mistura 50/50 como r-21). Correção dimensional v0.11.0: + /// o combinador do motor exige EXATAMENTE `n` linhas (`d_saida·n`) — as + /// peças do banco (P ≠ n em geral) alimentam somente a média de ênfase. + fn agregar_ponderado( + &self, + matriz_pecas: &Tensor, + pesos: &[f64], + candidatos: &Tensor, + ) -> DResult { + let p = matriz_pecas.dim(0)?; + if pesos.len() != p { + bail!("agregar_ponderado: {p} peças vs {} pesos", pesos.len()); + } + let w = Tensor::from_vec( + pesos.iter().map(|&x| x as f32).collect::>(), + (p, 1), + matriz_pecas.device(), + )?; + let media = matriz_pecas.broadcast_mul(&w)?.sum_keepdim(0)?; // (1, d) + let (montado, _) = self.motor.agregar(candidatos)?; // (1, d) — n linhas + Ok((montado.affine(0.5, 0.0)? + media.affine(0.5, 0.0)?)?) + } + + /// Ciclo d ELÁSTICO: gerar → registrar → ênfase (Hedge) → agregar → + /// verificar → COMPRIMIR com certificado (rollback se violado) → + /// responder ou expandir. `q`/`k_base` opcionais habilitam RE-2 válido + /// (massas de atenção reais); sem eles, massas proxy + `valido=false`. + #[allow(clippy::too_many_arguments)] + pub fn raciocinar( + &mut self, + cond: &Tensor, + verificador: &VerificadorNcm, + logits_fn: &dyn Fn(&Tensor) -> DResult, + q: Option<&Tensor>, + k_base: Option<&Tensor>, + hub: &mut TelemetryHub, + rng: &mut RngDeterministico, + ) -> DResult { + let mut certificados = Vec::new(); + let mut tel = HashMap::new(); + let mut temperatura = 0.1f64; + let mut iteracoes = 0usize; + let mut melhor: (Option, f64) = (None, -1.0); + let mut alocacao: Vec = Vec::new(); + let gate = self.motor.gate_atencao.as_tensor().to_scalar::()? as f64; + + loop { + iteracoes += 1; + // (1) GERAÇÃO (motor existente — N tentativas + difusor) + let candidatos = self.motor.candidatos(cond, temperatura, rng)?; + self.registrar_pecas(&candidatos)?; + + // (2) ÊNFASE REAJUSTÁVEL: massas + Hedge (RE-6, previsível) + let vetores: Vec = self.pecas.iter().map(|p| p.vetor.clone()).collect(); + let massas = match (q, k_base) { + (Some(qq), Some(kb)) => { + let extras = Tensor::cat(&vetores, 0)?; + tel.insert("massas_reais".into(), 1.0); + massas_extra(qq, kb, &extras)? + } + _ => { + tel.insert("massas_reais".into(), 0.0); + massas_proxy(&vetores)? + } + }; + for (p, &m) in self.pecas.iter_mut().zip(&massas) { + p.massa = m; + } + let pesos = pesos_hedge(&self.perdas_acum, self.eta(iteracoes)); + + // (3) AGREGAÇÃO ponderada por ênfase (peças = média; candidatos + // = montagem aprendida — dimensões corrigidas) + let matriz = self.matriz_pecas(&(0..self.pecas.len()).collect::>())?; + let resposta = self.agregar_ponderado(&matriz, &pesos, &candidatos)?; + let conf = verificador.confianca_1d(&logits_fn(&resposta)?)?; + self.atualizar_relevancia(conf, &pesos); + self.auto.confs_retidas.push(conf); + if let Some(anterior) = tel.get("conf_anterior").copied() { + self.auto.ganhos_por_iteracao.push((conf - anterior).max(0.0)); + } + tel.insert("conf_anterior".into(), conf); + if conf > melhor.1 { + melhor = (Some(resposta.clone()), conf); + } + + // (4) DECISÃO: responder (com compressão certificada) ou expandir + if conf >= self.cfg.tau_c { + let (resposta_final, cert) = self.comprimir_certificado( + &candidatos, + resposta, + conf, + gate, + verificador, + logits_fn, + &massas, + tel.get("massas_reais") == Some(&1.0), + hub, + )?; + certificados.push(cert); + tel.insert("conf_final".into(), conf); + tel.insert("iteracoes".into(), iteracoes as f64); + alocacao = alocar_guloso( + &self + .pecas + .iter() + .map(|p| p.relevancia.max(1e-6)) + .collect::>(), + self.cfg.b_max.max(self.pecas.len()), + )?; + let pesos_f = pesos_hedge(&self.perdas_acum, self.eta(iteracoes)); + return Ok(ResultadoElastico { + base: ResultadoPensamento { + resposta: Some(resposta_final), + candidatos, + pesos, + confianca: conf, + iteracoes, + trajetoria: vec![EventoCiclo::Resposta { confianca: conf, iteracoes }], + telemetria: tel.clone().into_iter().collect(), + }, + certificados, + pesos_hedge_final: pesos_f, + alocacao_final: alocacao, + telemetria_extra: tel, + }); + } + if iteracoes >= self.cfg.b_max { + // RE-4: Φ = B_max − k = 0 — honestidade (orcamento_esgotado) + tel.insert("orcamento_esgotado".into(), 1.0); + tel.insert("conf_final".into(), melhor.1); + tel.insert("iteracoes".into(), iteracoes as f64); + let pesos_f = pesos_hedge(&self.perdas_acum, self.eta(iteracoes)); + return Ok(ResultadoElastico { + base: ResultadoPensamento { + resposta: melhor.0, + candidatos, + pesos, + confianca: melhor.1, + iteracoes, + trajetoria: vec![EventoCiclo::Resposta { + confianca: melhor.1, + iteracoes, + }], + telemetria: tel.clone().into_iter().collect(), + }, + certificados, + pesos_hedge_final: pesos_f, + alocacao_final: Vec::new(), + telemetria_extra: tel, + }); + } + // (5) EXPANSÃO (re-planejamento): difusor mais quente + realocação + let t_antes = temperatura; + temperatura = (temperatura * self.cfg.fator_temp).min(self.cfg.temp_max); + let q_rel: Vec = + self.pecas.iter().map(|p| p.relevancia.max(1e-6)).collect(); + alocacao = alocar_guloso(&q_rel, self.cfg.b_max.max(self.pecas.len()))?; + hub.ajuste( + "elastico_temperatura", + t_antes, + temperatura, + &format!("RE: conf {conf:.3} < τ_c {} — expandir exploração", self.cfg.tau_c), + ); + } + } + + /// RE-2 operacional: comprimir → RE-VERIFICAR → rollback se violado + /// (defesa em profundidade contra H1 falso — r-42 §2.1). + /// + /// **Bound estendido (r-42 §2.2-rev, v0.11.0):** a resposta agregada + /// tem DUAS vias de perturbação sob compressão — (i) a massa de + /// atenção gateada (RE-1: `2|g|V_max·π_rem`) e (ii) a MÉDIA DE ÊNFASE + /// (Hedge), não gateada. Pela desigualdade triangular: + /// `‖Δy‖ ≤ 2|g|V_max·π_rem + Σ_{i∈rem} w_i‖v_i‖ + (W_rem/(1−W_rem))·Σ_{i∈fic} w_i‖v_i‖` + /// (o 2º termo é a remoção direta; o 3º é a re-normalização dos pesos + /// dos mantidos). O certificado só comete se `|Δconf| ≤ L_conf·‖Δy‖_cota`. + #[allow(clippy::too_many_arguments)] + fn comprimir_certificado( + &mut self, + candidatos: &Tensor, + resposta: Tensor, + conf: f64, + gate: f64, + verificador: &VerificadorNcm, + logits_fn: &dyn Fn(&Tensor) -> DResult, + massas: &[f64], + valido: bool, + hub: &mut TelemetryHub, + ) -> DResult<(Tensor, CertificadoCompressao)> { + let v_max = self + .pecas + .iter() + .map(|p| { + p.vetor + .abs() + .and_then(|t| t.max_all()) + .and_then(|t| t.to_scalar::()) + }) + .collect::>>()? + .into_iter() + .map(|x| x as f64) + .fold(0.0f64, f64::max) + .max(1e-12); + // normas ℓ2 por peça (para o termo da média de ênfase) + let normas: Vec = self + .pecas + .iter() + .map(|p| { + p.vetor + .sqr() + .and_then(|t| t.sum_all()) + .and_then(|t| t.to_scalar::()) + }) + .collect::>>()? + .into_iter() + .map(|x| (x as f64).sqrt()) + .collect(); + let l_conf = self.cfg.lipschitz_conf(); + let eps = epsilon_seguro(conf, self.cfg.tau_c, gate, v_max, l_conf); + let (mantidos, massa_rem) = comprimir_por_massa(massas, eps); + if mantidos.len() == self.pecas.len() { + return Ok(( + resposta, + CertificadoCompressao { + epsilon_safe: eps, + massa_removida: 0.0, + bound_delta_conf: 0.0, + delta_conf_medido: 0.0, + violado: false, + rollback: false, + valido, + }, + )); + } + // pesos Hedge CORRENTES (todos as peças) para o custo da média + let pesos_todos = pesos_hedge(&self.perdas_acum, self.eta(1)); + let (w_rem, soma_rem, soma_fic): (f64, f64, f64) = { + let mut wr = 0.0; + let mut sr = 0.0; + let mut sf = 0.0; + for (i, &m) in mantidos.iter().enumerate() { + let _ = i; + sf += pesos_todos[m] * normas[m]; + } + for (i, &w) in pesos_todos.iter().enumerate() { + if !mantidos.contains(&i) { + wr += w; + sr += w * normas[i]; + } + } + (wr, sr, sf) + }; + let custo_media = soma_rem + if w_rem < 1.0 - 1e-12 { + (w_rem / (1.0 - w_rem)) * soma_fic + } else { + f64::INFINITY + }; + let matriz = self.matriz_pecas(&mantidos)?; + let pesos = pesos_hedge( + &mantidos.iter().map(|&i| self.perdas_acum[i]).collect::>(), + self.eta(1), + ); + let resposta_c = self.agregar_ponderado(&matriz, &pesos, candidatos)?; + let conf_c = verificador.confianca_1d(&logits_fn(&resposta_c)?)?; + let bound = l_conf * (2.0 * gate.abs() * v_max * massa_rem + custo_media); + let delta = (conf - conf_c).abs(); + let violado = conf_c < self.cfg.tau_c || delta > bound + 1e-6; + hub.ajuste( + "elastico_compressao", + self.pecas.len() as f64, + mantidos.len() as f64, + &format!( + "RE-2: ε_safe={eps:.4}, π_rem={massa_rem:.4}, bound={bound:.4}, Δconf={delta:.4}, violado={violado}" + ), + ); + if violado { + // rollback defensivo: restaura integralmente (H1 pode ter falhado) + return Ok(( + resposta, + CertificadoCompressao { + epsilon_safe: eps, + massa_removida: massa_rem, + bound_delta_conf: bound, + delta_conf_medido: delta, + violado: true, + rollback: true, + valido, + }, + )); + } + // commit: remover peças do banco (compressão efetiva de memória) + let set: std::collections::HashSet = mantidos.iter().copied().collect(); + let (p, l): (Vec<_>, Vec<_>) = std::mem::take(&mut self.pecas) + .into_iter() + .zip(std::mem::take(&mut self.perdas_acum)) + .enumerate() + .filter(|(i, _)| set.contains(i)) + .map(|(_, (p, l))| (p, l)) + .unzip(); + self.pecas = p; + self.perdas_acum = l; + Ok(( + resposta_c, + CertificadoCompressao { + epsilon_safe: eps, + massa_removida: massa_rem, + bound_delta_conf: bound, + delta_conf_medido: delta, + violado: false, + rollback: false, + valido, + }, + )) + } +} + +pub fn versao() -> &'static str { + "raciocinio-elastico-0.11.0" +} + +// --------------------------------------------------------------------------- +// Testes de falsificação (RE-1..RE-8) — tratamento.txt: unwrap só em teste +// --------------------------------------------------------------------------- + +#[cfg(test)] +mod testes { + use super::*; + use candle_core::Device; + + fn t(v: Vec, shape: impl Into) -> Tensor { + Tensor::from_vec(v, shape, &Device::Cpu).unwrap() + } + + /// RE-1: identidade Δy = π(ȳ_e − y_base) — erro < 1e-6 (f32). + #[test] + fn re1_identidade_massa() -> DResult<()> { + let (d, nb, ne) = (6usize, 5usize, 3usize); + let mut rng = RngDeterministico::novo(1); + let mk = |n: usize, d: usize, rng: &mut RngDeterministico| -> Tensor { + t( + (0..n * d).map(|_| rng.normal(0.0, 1.0) as f32).collect(), + (1, n, d), + ) + }; + let q = mk(1, d, &mut rng); + let kb = mk(nb, d, &mut rng); + let ke = t( + (0..ne * d).map(|_| rng.normal(0.0, 1.0) as f32).collect(), + (ne, d), + ); + let vb = mk(nb, d, &mut rng); + let ve = t( + (0..ne * d).map(|_| rng.normal(0.0, 1.0) as f32).collect(), + (ne, d), + ); + let sm = |s: &Tensor| candle_nn::ops::softmax(s, D::Minus1); + let sb = q.matmul(&kb.transpose(1, 2)?)?.affine(1.0 / (d as f64).sqrt(), 0.0)?; + let se = q + .matmul(&ke.reshape((1, ne, d))?.transpose(1, 2)?)? + .affine(1.0 / (d as f64).sqrt(), 0.0)?; + let ab = sm(&sb)?; + let af = sm(&Tensor::cat(&[sb, se], 2)?)?; + let yb = ab.matmul(&vb)?; + let yf = af.matmul(&Tensor::cat(&[vb, ve.reshape((1, ne, d))?], 1)?)?; + let pi: f32 = af.narrow(2, nb, ne)?.sum_all()?.to_scalar()?; + let ae = af.narrow(2, nb, ne)?; + let ye_bar = ae.affine(1.0 / pi as f64, 0.0)?.matmul(&ve.reshape((1, ne, d))?)?; + let lhs = (&yf - &yb)?; + let rhs = (ye_bar - yb)?.affine(pi as f64, 0.0)?; + let err = (lhs - rhs)?.abs()?.max_all()?.to_scalar::()?; + assert!(err < 1e-6, "RE-1: erro da identidade = {err}"); + let massas = massas_extra(&q, &kb, &ke)?; + assert!((massas.iter().sum::() - pi as f64).abs() < 1e-5); + Ok(()) + } + + /// RE-2: ε_safe preserva aceite; sem margem ⇒ ε=0; gate=0 ⇒ livre. + #[test] + fn re2_epsilon_seguro() { + assert_eq!(epsilon_seguro(0.5, 0.9, 1.0, 1.0, 1.0), 0.0); + let eps = epsilon_seguro(0.95, 0.9, 0.5, 2.0, 4.0); + assert!((eps - 0.05 / (2.0 * 0.5 * 2.0 * 4.0)).abs() < 1e-12); + assert!(epsilon_seguro(0.95, 0.9, 0.0, 1.0, 1.0).is_infinite()); + // cadeia: bound ≥ delta garantido pela escolha de ε + let (g, vmax, lc) = (0.5, 2.0, 4.0); + let delta_max = lc * 2.0 * g * vmax * eps; + assert!(delta_max <= 0.05 + 1e-12); + } + + /// RE-2: compressão gulosa respeita o orçamento e nunca esvazia o banco. + #[test] + fn re2b_compressao_orcamento() { + let massas = vec![0.4, 0.05, 0.02, 0.3, 0.01]; + let (mant, rem) = comprimir_por_massa(&massas, 0.10); + assert!(rem <= 0.10 + 1e-12); + assert!(!mant.is_empty()); + assert_eq!(mant, vec![0, 3]); // remove as três menores: 0.01+0.02+0.05 + let (m0, r0) = comprimir_por_massa(&massas, 0.0); + assert_eq!(m0.len(), massas.len()); + assert_eq!(r0, 0.0); // neutralidade ε=0 + let (m1, _) = comprimir_por_massa(&[0.9, 0.1], 1.0); + assert_eq!(m1.len(), 1); // nunca remove todas + } + + /// RE-5: guloso == força bruta (delega ao canônico M-R5′ — here apenas + /// a consistência do delegate + erro explícito em entrada inválida). + #[test] + fn re5_alocacao_otima() -> DResult<()> { + assert!(alocar_guloso(&[], 3).is_err(), "m=0 => Err explícito"); + assert!(alocar_guloso(&[1.0], 0).is_err(), "C Err explícito"); + let q = [3.83, 4.17, 2.47]; + let c = alocar_guloso(&q, 7)?; + assert_eq!(c.iter().sum::(), 7); + // custo guloso == custo da força bruta (ver teste M-R5′ canônico) + let custo = |cc: &[usize]| -> f64 { + q.iter().zip(cc).map(|(qi, ci)| qi * qi / *ci as f64).sum() + }; + let mut melhor = f64::INFINITY; + for a in 1..=5 { + for b in 1..=6 - a { + melhor = melhor.min(custo(&[a, b, 7 - a - b])); + } + } + assert!((custo(&c) - melhor).abs() < 1e-9, "guloso {:?} f={} vs bruto {}", c, custo(&c), melhor); + Ok(()) + } + + /// RE-6: Hedge — arrependimento ≤ √(2T ln N) (adversarial). + #[test] + fn re6_hedge_regret() { + let (n, t) = (4usize, 500usize); + let eta = (2.0 * (n as f64).ln() / t as f64).sqrt(); + let mut acum = vec![0.0; n]; + let mut perda_alg = 0.0; + let mut melhor_fixa = vec![0.0; n]; + for k in 0..t { + let perdas: Vec = (0..n).map(|i| if (k + i) % n == 0 { 0.0 } else { 1.0 }).collect(); + let w = pesos_hedge(&acum, eta); + perda_alg += w.iter().zip(&perdas).map(|(wi, li)| wi * li).sum::(); + for i in 0..n { + acum[i] += perdas[i]; + melhor_fixa[i] += perdas[i]; + } + } + let regret = perda_alg - melhor_fixa.iter().cloned().fold(f64::INFINITY, f64::min); + let bound = (2.0 * t as f64 * (n as f64).ln()).sqrt(); + assert!(regret <= bound, "regret {regret:.2} > bound {bound:.2}"); + } + + /// ConfigElastica: validação falha cedo com motivo (tratamento.txt). + #[test] + fn cfg_validacao_explicita() { + assert!(ConfigElastica::default().validar().is_ok()); + let mut c = ConfigElastica::default(); + c.tau_c = 1.0; + assert!(c.validar().is_err()); + c = ConfigElastica::default(); + c.n_classes = 1; + assert!(c.validar().is_err()); + c = ConfigElastica::default(); + c.fator_temp = 0.5; + assert!(c.validar().is_err()); + } + + /// RE-4: terminação com verificador sempre baixo ⇒ ≤ B_max e honestidade. + #[test] + fn re4_terminacao_honesta() -> DResult<()> { + let dev = Device::Cpu; + let mut rng_m = RngDeterministico::novo(3); + let motor = MotorPensamento::novo_com_rng(4, 3, 2, 0.99, 3, &dev, &mut rng_m)?; + let cfg = ConfigElastica { b_max: 3, tau_c: 0.99, ..Default::default() }; + let mut re = RaciocinioElastico::novo(motor, cfg)?; + let verif = VerificadorNcm::novo(); + let cond = t(vec![0.1, 0.2, 0.3, 0.4], (1, 4)); + // cabeça FIXA determinística (semente própria — nunca o RNG global): + // pesos ~N(0,0,1) ⇒ logits pequenos ⇒ confiança baixa sempre + let logits_fn = |y: &Tensor| -> DResult { + let mut rng = RngDeterministico::novo(7); + let dados: Vec = + (0..8 * 3).map(|_| rng.normal(0.0, 0.1) as f32).collect(); + let w = Tensor::from_vec(dados, (8, 3), y.device())?; + y.matmul(&w.transpose(0, 1)?) + }; + let mut hub = TelemetryHub::novo(None); + let mut rng = RngDeterministico::novo(7); + let r = re.raciocinar(&cond, &verif, &logits_fn, None, None, &mut hub, &mut rng)?; + assert!(r.base.iteracoes <= 3); + assert_eq!(r.telemetria_extra.get("orcamento_esgotado"), Some(&1.0)); + assert!(r.base.resposta.is_some()); // melhor candidato, nunca None + Ok(()) + } + + /// RE-8/determinismo: mesma semente ⇒ mesma trajetória bit-a-bit + /// (motor SEMEADO via novo_com_rng — débito r-34 §12; massas proxy). + #[test] + fn re8_determinismo() -> DResult<()> { + let dev = Device::Cpu; + let roda = || -> DResult> { + let mut rng_m = RngDeterministico::novo(31); + let motor = MotorPensamento::novo_com_rng(4, 3, 2, 0.5, 4, &dev, &mut rng_m)?; + let mut re = RaciocinioElastico::novo(motor, ConfigElastica::default())?; + let cond = t(vec![0.1, 0.2, 0.3, 0.4], (1, 4)); + let logits_fn = |y: &Tensor| -> DResult { + // pesos determinísticos por semente FIXA (nunca RNG global) + let mut rng = RngDeterministico::novo(99); + let dados: Vec = + (0..8 * 3).map(|_| rng.normal(0.0, 0.3) as f32).collect(); + let w = Tensor::from_vec(dados, (8, 3), y.device())?; + y.matmul(&w.transpose(0, 1)?) + }; + let mut hub = TelemetryHub::novo(None); + let mut rng = RngDeterministico::novo(99); + let r = re.raciocinar(&cond, &VerificadorNcm::novo(), &logits_fn, None, None, &mut hub, &mut rng)?; + r.base.candidatos.flatten_all()?.to_vec1::() + }; + assert_eq!(roda()?, roda()?, "mesma semente ⇒ bit-a-bit"); + Ok(()) + } + + /// L_conf: bound Lipschitz conf — |Δconf| ≤ L_conf·‖Δy‖ (cadeia RE-2). + #[test] + fn re2c_lipschitz_conf_cadeia() -> DResult<()> { + let (k, d) = (8usize, 4usize); + // pesos determinísticos (semente fixa — princípio do repo) + let mut rng = RngDeterministico::novo(5); + let dados: Vec = (0..k * d).map(|_| rng.normal(0.0, 0.8) as f32).collect(); + let w = Tensor::from_vec(dados, (k, d), &Device::Cpu)?; + let nw = w.sqr()?.sum_all()?.to_scalar::()? as f64; // ‖W‖_F ≥ ‖W‖₂ + let cfg = ConfigElastica { + norma_w: nw.sqrt(), + n_classes: k, + z_sup: 30.0, + ..Default::default() + }; + let conf = |y: &Tensor| -> DResult { + let z = y.matmul(&w.transpose(0, 1)?)?; + Ok(crate::verificador::confianca_por_linha(&z)? + .flatten_all()? + .to_vec1::()?[0] as f64) + }; + let mut rng = RngDeterministico::novo(11); + for _ in 0..32 { + let y0 = t((0..d).map(|_| rng.normal(0.0, 1.0) as f32).collect(), (1, d)); + let dy = t((0..d).map(|_| rng.normal(0.0, 0.05) as f32).collect(), (1, d)); + let y1 = (&y0 + &dy)?; + let delta = (conf(&y0)? - conf(&y1)?).abs(); + let bound = + cfg.lipschitz_conf() * dy.sqr()?.sum_all()?.to_scalar::()? as f64; + assert!(delta <= bound + 1e-9, "|Δconf|={delta} > bound={bound}"); + } + Ok(()) + } + + /// RE-2 ponta-a-ponta (defesa em profundidade): o ciclo com compressão + /// certificada NUNCA entrega resposta abaixo de τ_c quando aceitou — o + /// rollback restaura a integral se o bound for violado (contrato + /// auditável; com gate=0 o bound é 0 e o rollback é o guardião — a + /// média de ênfase não é coberta pelo certificado de MASSA, honestidade + /// r-42 §2.2 documentada). + #[test] + fn re2d_ciclo_com_compressao() -> DResult<()> { + let dev = Device::Cpu; + // cabeça CONFIDENTE (escala 3.0 ⇒ logits espalhados ⇒ conf alta) e + // τ_c baixo: a 1ª iteração aceita ⇒ a compressão roda com margem + let mut rng_m = RngDeterministico::novo(5); + let motor = MotorPensamento::novo_com_rng(4, 3, 2, 0.99, 4, &dev, &mut rng_m)?; + let cfg = ConfigElastica { b_max: 4, tau_c: 0.02, ..Default::default() }; + let mut re = RaciocinioElastico::novo(motor, cfg)?; + let cond = t(vec![0.1, 0.2, 0.3, 0.4], (1, 4)); + let logits_fn = |y: &Tensor| -> DResult { + let mut rng = RngDeterministico::novo(21); + let dados: Vec = + (0..8 * 3).map(|_| rng.normal(0.0, 3.0) as f32).collect(); + let w = Tensor::from_vec(dados, (8, 3), y.device())?; + y.matmul(&w.transpose(0, 1)?) + }; + let mut hub = TelemetryHub::novo(None); + let mut rng = RngDeterministico::novo(21); + let res = re.raciocinar(&cond, &VerificadorNcm::novo(), &logits_fn, None, None, &mut hub, &mut rng)?; + // CONTRATO 1: se aceitou, a confiança FINAL ≥ τ_c (o rollback + // garante que a compressão nunca derruba o aceite) + if res.telemetria_extra.get("orcamento_esgotado") != Some(&1.0) { + assert!(res.base.confianca >= 0.02, "aceite preservado: conf={} ≥ τ_c", res.base.confianca); + assert_eq!(res.certificados.len(), 1); + let c = &res.certificados[0]; + // CONTRATO 2: commit ⇒ sem violação; rollback ⇒ foi POR violação + if !c.rollback { + assert!(!c.violado, "commit sem violação"); + } + // CONTRATO 3: ε_safe ≥ 0 e massa removida ≤ ε_safe (orçamento) + assert!(c.epsilon_safe >= 0.0); + assert!(c.massa_removida <= c.epsilon_safe + 1e-9); + } else { + // honestidade: esgotou o orçamento sem aceitar — também válido + assert!(res.base.iteracoes <= 4); + } + Ok(()) + } +} diff --git a/src/som4d.rs b/src/som4d.rs index 89f664cee54db1bf8b35d22f8bc41292db7e2b58..acb5d802f0567edf2a2f06703df262ba43325219 100644 --- a/src/som4d.rs +++ b/src/som4d.rs @@ -64,6 +64,42 @@ pub enum Topologia4D { VonNeumann, } +/// Critério do passo de lote (v0.10.0, crítica DeepSeek S4-1 — provas em +/// r-35 §2). +/// +/// A crítica é PROCEDENTE: a prova v0.5.0 usava a convexidade de `‖·‖²` +/// para concluir sobre `‖·‖` (a QE pode SUBIR no regime σ grande — +/// contraexemplo reproduzido no teste `s41_contraexemplo`). O teorema +/// reparado (S4-1′) tem DUAS partes: (a) a `Φ` do kernel (EQM ponderado, +/// objetivo REAL do passo) é NÃO-CRESCENTE INCONDICIONAL; (b) a QE está +/// acoplada por `QE(a,P) ≤ √(Φ(P)/N)` (Cauchy-Schwarz) com frouxura +/// controlada pelo cruzamento `e^{−1/2σ²}`. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum CriterioLote { + /// Média ponderada pelo kernel — comportamento v0.5.0–v0.9.0 + /// (bit-a-bit). Minimiza `Φ_g` (EQM) exatamente; a QE (não-quadrada) + /// pode subir no regime σ grande (S4-1′-b, teste s41_contraexemplo). + Media, + /// Mediana geométrica ponderada (Weiszfeld, v0.10.0) — alternativa + /// sugerida pela crítica: minimiza `Ψ_g` (erro NÃO-quadrado ponderado) + /// ⇒ a QE da atribuição congelada é não-crescente no MESMO sentido + /// exato do S4-1′-a (a norma é convexa!). Custo: ~8 iterações + /// Weiszfeld por célula. Opt-in (não substitui a média — a média + /// organiza a grade mais rápido no início; ver r-35 §2.4 A/B). + MedianaGeometrica, +} + +/// Métrica de avaliação reportada (v0.10.0, pedido `criterio_qe` do +/// aprimoramentos-arquitetura §3): `Distancia` = QE clássica +/// `(1/N)Σ min ‖x−p‖`; `Quadratico` = EQM `(1/N)Σ min ‖x−p‖²`. Ambas são +/// sempre COMPUTADAS na telemetria; o campo só escolhe qual entra em +/// `eq_inicial/eq_final/historia` (compatibilidade de gates). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum CriterioQe { + Distancia, + Quadratico, +} + /// Configuração do 4D-SOM (todos os campos públicos; `Default` = grade 4×4×4×4). #[derive(Debug, Clone)] pub struct CfgSom4D { @@ -85,6 +121,13 @@ pub struct CfgSom4D { pub inicializacao: Inicializacao4D, /// false ⇒ pula EQ/TE (medição de custo). pub calcular_metricas: bool, + /// v0.10.0 — critério do passo de lote (S4-1′). Default `Media` + /// (bit-a-bit com v0.9.0). + pub criterio_lote: CriterioLote, + /// v0.10.0 — métrica de avaliação (S4-1′). Default `Distancia`. + pub criterio_qe: CriterioQe, + /// v0.10.0 — nº de iterações Weiszfeld (modo MedianaGeometrica). + pub weiszfeld_iters: usize, pub semente: u64, } @@ -98,6 +141,9 @@ impl Default for CfgSom4D { topologia: Topologia4D::Moore, inicializacao: Inicializacao4D::Dados, calcular_metricas: true, + criterio_lote: CriterioLote::Media, + criterio_qe: CriterioQe::Distancia, + weiszfeld_iters: 8, semente: 42, } } @@ -116,6 +162,14 @@ pub struct Som4DTreinado { pub eq_final: f64, pub te_final: f64, pub historia: Vec<(f64, f64)>, // (EQ, TE) por época + /// v0.10.0 (S4-1′): (Φ_antes, Φ_depois) por época — EQM ponderado pelo + /// kernel com a atribuição CONGELADA da época. O teorema reparado + /// afirma Φ_depois ≤ Φ_antes INCONDICIONAL (todos os σ, todos os η) — + /// é isto que o gate `s41_phi_nao_cresce` verifica. + pub historia_phi: Vec<(f64, f64)>, + /// v0.10.0: EQM (não-quadrado → quadrático) final, sempre computado + /// quando calcular_metricas (telemetria reporta ambos). + pub eqm_final: f64, } impl Som4DTreinado { @@ -197,7 +251,9 @@ impl Som4DTreinado { fn self_topologia_vizinha(a: &[usize; 4], b: &[usize; 4]) -> bool { // Moore 4D: Chebyshev 1 em TODAS as dimensões, não-igual. - let cheb = a.iter().zip(b).map(|(x, y)| (*x as i64 - *y as i64).abs()).max().unwrap(); + // v0.11.0 (tratamento.txt): zip de arrays [usize;4] é SEMPRE não-vazio + // — `.max()` com padrão explícito em vez de unwrap (à prova de mudança) + let cheb = a.iter().zip(b).map(|(x, y)| (*x as i64 - *y as i64).abs()).max().unwrap_or(0); cheb <= 1 && a != b } @@ -207,14 +263,107 @@ fn vizinhas_vn(a: &[usize; 4], b: &[usize; 4]) -> bool { manh == 1 } +/// Mediana geométrica PONDERADA por iteração de Weiszfeld (v0.10.0, crítica +/// DeepSeek S4-1 — S4-1′-c em r-35 §2.3). +/// +/// `m^{(k+1)} = Σ_i ω_i x_i/‖m−x_i‖ / Σ_i ω_i/‖m−x_i‖` com guarda +/// `‖m−x_i‖ ≥ δ` (evita 0/0 quando m coincide com um ponto — a correção de +/// Vardi–Zhang é necessária só no ponto de dados EXATO, onde o algoritmo +/// pára sozinho: ponto de dados é ponto fixo). Convergência: Weiszfeld +/// clássico (descida estrita de `Ψ(m) = Σ ω_i‖x_i − m‖` exceto em pontos +/// de dados); inicialização em `p_g` (o protótipo corrente) — no +/// contraexemplo {0,10} com pesos iguais, TODO ponto do segmento é ponto +/// fixo, logo o protótipo NÃO se move (a média iria para 5). +fn mediana_geometrica_ponderada( + pontos: &[(&Vec, f64)], + inicio: &[f64], + iters: usize, + delta: f64, +) -> Vec { + let d = inicio.len(); + let mut m = inicio.to_vec(); + for _ in 0..iters.max(1) { + let mut num = vec![0.0f64; d]; + let mut den = 0.0f64; + let mut algum_ponto = false; + for (x, w) in pontos { + if *w <= 0.0 { + continue; + } + // ponto de dados exato: ponto fixo (condição de otimalidade + // Vardi–Zhang — a massa no ponto domina) + if m.iter().zip(x.iter()).all(|(a, b)| (a - b).abs() < delta) { + algum_ponto = true; + break; + } + let dist = (m.iter().zip(x.iter()).map(|(a, b)| (a - b) * (a - b)).sum::()) + .sqrt() + .max(delta); + for j in 0..d { + num[j] += w * x[j] / dist; + } + den += w / dist; + } + if algum_ponto || den <= 1e-15 { + break; + } + for j in 0..d { + m[j] = num[j] / den; + } + } + m +} + +/// Φ do kernel (S4-1′-a): EQM ponderado `Φ(P) = Σ_g Σ_i w(a(x_i),g)·‖x_i − p_g‖²` +/// com a atribuição `a` CONGELADA. Este é o objetivo que o passo de lote +/// minimiza por célula — o teorema reparado afirma que Φ é não-crescente +/// INCONDICIONALMENTE (a prova v0.5.0 era sobre a QE, o que é falso). +fn phi_kernel( + prototipos: &[Vec], + xs: &[Vec], + bmu_idx: &[usize], + coords: &[[usize; 4]], + sigma: f64, +) -> f64 { + let sigma2 = 2.0 * sigma * sigma; + let mut phi = 0.0; + for (i, x) in xs.iter().enumerate() { + let cb = coords[bmu_idx[i]]; + for (g, cg) in coords.iter().enumerate() { + let dg2: f64 = (0..4) + .map(|k| (cg[k] as f64 - cb[k] as f64).powi(2)) + .sum(); + let w = (-dg2 / sigma2).exp(); + if w > 1e-12 { + phi += w * distancia2(x, &prototipos[g]); + } + } + } + phi +} + /// Treina um 4D-SOM em modo lote determinístico. /// -/// **Passo de lote (prova S4-1):** para cada época, cada amostra é atribuída -/// ao BMU; o novo protótipo da célula `g` é -/// `p_g' = Σ_i w_ig·x_i / Σ_i w_ig` com `w_ig = h_σ(g, bmu(x_i))` (kernel -/// gaussiano na grade 4D centrado no BMU da amostra). Com atribuição -/// congelada, `‖x_i − p'_{bmu(i)}‖ ≤ Σ_g w_ig·‖x_i − p_g‖/Σ_g w_ig` por -/// convexidade ⇒ EQ não-crescente. Re-atribuição só pode diminuir o min. +/// **Passo de lote (S4-1′, v0.10.0 — crítica DeepSeek procedente):** para +/// cada época, cada amostra é atribuída ao BMU; o alvo da célula `g` é a +/// média ponderada `m_g = Σ_i w_ig·x_i / Σ_i w_ig` (modo `Media`) ou a +/// mediana geométrica ponderada (modo `MedianaGeometrica`), com +/// `w_ig = h_σ(g, bmu(x_i))`; o protótipo move-se `p_g' = p_g + η(m_g − p_g)`. +/// +/// **S4-1′-a (incondicional):** `m_g` minimiza EXATAMENTE +/// `Φ_g(p) = Σ_i w_ig·‖x_i − p‖²` (média) ou `Ψ_g(p) = Σ_i w_ig·‖x_i − p‖` +/// (mediana) sobre todo `R^d`; pela convexidade de `p ↦ Φ_g` (soma de +/// normas quadradas) e da mistura convexa, +/// `Φ_g(p'_g) ≤ (1−η)Φ_g(p_g) + ηΦ_g(m_g) ≤ Φ_g(p_g)` — SOMANDO em g, a Φ +/// total é não-crescente, para TODO σ e TODO η ∈ [0,1] (gate +/// `historia_phi`). **S4-1′-b:** a QE (não-quadrada) NÃO é controlada por +/// este argumento — pode subir no regime σ grande (contraexemplo da +/// crítica, gate `s41_contraexemplo`); a ponte é +/// `QE(a,P)² ≤ Φ(P)/N` (Cauchy-Schwarz) e o termo cruzado de mistura é +/// `≤ e^{−1/2σ²}·N·D²` (vizinho mais próximo a distância de grade ≥ 1). +/// **S4-1′-c:** com `MedianaGeometrica`, o MESMO argumento vale para Ψ +/// (norma é convexa) ⇒ QE da atribuição congelada não-crescente no +/// sentido exato de Ψ. Re-atribuição só pode diminuir o min. pub fn treinar_som4d(dados: &Tensor, cfg: &CfgSom4D, _dev: &Device) -> candle_core::Result { let xs = para_matriz(dados)?; let n = xs.len(); @@ -281,6 +430,7 @@ pub fn treinar_som4d(dados: &Tensor, cfg: &CfgSom4D, _dev: &Device) -> candle_co let (eq_inicial, _) = eq_te(&prototipos); let mut historia = Vec::new(); + let mut historia_phi: Vec<(f64, f64)> = Vec::new(); let mut massa = vec![0.0f64; c]; for epoca in 0..cfg.epocas { @@ -288,6 +438,9 @@ pub fn treinar_som4d(dados: &Tensor, cfg: &CfgSom4D, _dev: &Device) -> candle_co let sigma = cfg.sigma0 * (cfg.sigma1 / cfg.sigma0).powf(frac); let eta = cfg.eta0 + (cfg.eta1 - cfg.eta0) * frac; let sigma2 = 2.0 * sigma * sigma; + // S4-1′: protótipos ANTES do passo (para medir Φ_antes com a + // atribuição congelada da época) + let prototipos_antes: Vec> = prototipos.clone(); // atribuição (BMU) — congelada nesta época. // v0.9.0 (medição honesta, r-34 §6.4): o caminho escalar contíguo @@ -320,12 +473,46 @@ pub fn treinar_som4d(dados: &Tensor, cfg: &CfgSom4D, _dev: &Device) -> candle_co } } } - // atualização: média ponderada misturada com η (Suave) - for g in 0..c { - if den[g] > 1e-12 { - for j in 0..d { - let alvo = num[g][j] / den[g]; - prototipos[g][j] += eta * (alvo - prototipos[g][j]); + // atualização por critério (S4-1′): Media = média ponderada (exato + // para Φ, bit-a-bit v0.9.0); MedianaGeometrica = Weiszfeld (exato + // para Ψ, o erro NÃO-quadrado — pedido da crítica DeepSeek) + match cfg.criterio_lote { + CriterioLote::Media => { + for g in 0..c { + if den[g] > 1e-12 { + for j in 0..d { + let alvo = num[g][j] / den[g]; + prototipos[g][j] += eta * (alvo - prototipos[g][j]); + } + } + } + } + CriterioLote::MedianaGeometrica => { + // pontos+pesses por célula (os mesmos pesos do kernel) + for g in 0..c { + let mut pts: Vec<(&Vec, f64)> = Vec::new(); + for (i, x) in xs.iter().enumerate() { + let cb = coords[bmu_idx[i]]; + let cg = coords[g]; + let dg2: f64 = (0..4) + .map(|k| (cg[k] as f64 - cb[k] as f64).powi(2)) + .sum(); + let w = (-dg2 / sigma2).exp(); + if w > 1e-12 { + pts.push((x, w)); + } + } + if !pts.is_empty() { + let m = mediana_geometrica_ponderada( + &pts, + &prototipos[g], + cfg.weiszfeld_iters, + 1e-12, + ); + for j in 0..d { + prototipos[g][j] += eta * (m[j] - prototipos[g][j]); + } + } } } } @@ -343,22 +530,56 @@ pub fn treinar_som4d(dados: &Tensor, cfg: &CfgSom4D, _dev: &Device) -> candle_co if cfg.calcular_metricas { let (eq, te) = eq_te(&prototipos); historia.push((eq, te)); + // S4-1′-a: Φ antes/depois com a atribuição CONGELADA desta época + let phi_antes = phi_kernel(&prototipos_antes, &xs, &bmu_idx, &coords, sigma); + let phi_depois = phi_kernel(&prototipos, &xs, &bmu_idx, &coords, sigma); + historia_phi.push((phi_antes, phi_depois)); } } let (eq_final, te_final) = eq_te(&prototipos); - if cfg.calcular_metricas { - // histórico já preenchido - } + // EQM final (métrica quadrática — sempre reportada, S4-1′) + let eqm_final = if cfg.calcular_metricas { + let mut q = 0.0; + for x in &xs { + let (_, d2) = { + let mut melhor = (0usize, f64::INFINITY); + for (i, p_) in prototipos.iter().enumerate() { + let dd = distancia2(x, p_); + if dd < melhor.1 { + melhor = (i, dd); + } + } + melhor + }; + q += d2; + } + q / n as f64 + } else { + f64::NAN + }; + // métrica de saída segundo o critério escolhido (compatibilidade: o + // default Distancia reproduz os valores v0.9.0 bit-a-bit) + let (eq_inicial_rep, eq_final_rep, historia_rep) = match cfg.criterio_qe { + CriterioQe::Distancia => (eq_inicial, eq_final, historia), + CriterioQe::Quadratico => { + let esc = |h: Vec<(f64, f64)>| -> Vec<(f64, f64)> { + h.into_iter().map(|(q, t)| (q * q, t)).collect() + }; + (eq_inicial * eq_inicial, eq_final * eq_final, esc(historia)) + } + }; Ok(Som4DTreinado { prototipos, nx: cfg.nx, ny: cfg.ny, nz: cfg.nz, nt: cfg.nt, d, massa, - eq_inicial, - eq_final, + eq_inicial: eq_inicial_rep, + eq_final: eq_final_rep, te_final, - historia, + historia: historia_rep, + historia_phi, + eqm_final, }) } @@ -467,11 +688,17 @@ pub struct CfgTSom { pub gamma: f64, /// janela de streaming (tamanho do lote por passo). pub janela: usize, + /// v0.10.0 (crítica DeepSeek T-1 — procedente): taxa η do passo de + /// rastreio, ANTES hard-coded 0.1. A cota correta do lag estacionário + /// é `δ·γ/(1−γ) + δ/η` (T-1′, r-35 §2.5): o termo `δ/η` do EMA do + /// PROTÓTIPO faltava na prova v0.5.0 (que somava apenas `δ` do passo + /// corrente). Default 0.1 = compatibilidade bit-a-bit. + pub eta_rastreio: f64, } impl Default for CfgTSom { fn default() -> Self { - Self { cfg_grade: CfgSom4D::default(), gamma: 0.97, janela: 64 } + Self { cfg_grade: CfgSom4D::default(), gamma: 0.97, janela: 64, eta_rastreio: 0.1 } } } @@ -480,6 +707,8 @@ pub struct TSom4D { /// massa temporal esquecida `m_g = Σ γ^(t_agora − t_i)·1[bmu_i = g]` pub massa_temporal: Vec, pub gamma: f64, + /// v0.10.0: taxa de rastreio η (T-1′) — antes hard-coded 0.1. + pub eta_rastreio: f64, /// t-counter global. pub t: u64, /// histórico do EQ temporal (pesado por recência) para telemetria. @@ -501,6 +730,7 @@ impl TSom4D { som, massa_temporal, gamma: cfg.gamma, + eta_rastreio: cfg.eta_rastreio.clamp(1e-3, 1.0), t: 0, eq_temporal_historico: Vec::new(), }) @@ -509,15 +739,20 @@ impl TSom4D { /// Um passo de streaming: recebe janela nova, atualiza protótipos com /// pesos `γ^idade` e a massa temporal. /// - /// **Rastreio (prova T-1):** a média exponencialmente esquecida de um - /// sinal que deriva `δ` por passo atrasa-se de `δ·γ/(1−γ)`; somando o - /// atraso do passo corrente, o erro de rastreio é `≤ δ/(1−γ)`. + /// **Rastreio (T-1′, v0.10.0 — crítica DeepSeek procede):** com + /// `p ← p + η(m − p)` e `m` derivando δ/passo, o lag estacionário do + /// protótipo satisfaz `L = δ + (1−η)L ⇒ L = δ/η` (EMA do protótipo); + /// somando o atraso `δ·γ/(1−γ)` do centróide da janela, o erro de + /// rastreio total é `≤ δ·γ/(1−γ) + δ/η`. A cota v0.5.0 + /// (`δ/(1−γ)`, sem o fator 1/η) SUBESTIMAVA o lag por `δ·(1/η − 1)` + /// — com η=0.1, por ~9δ. O gate `t1_termo_um_sobre_eta` mede a + /// diferença de lag entre η=1 e η=0.1 e confirma o termo δ/η. pub fn passo(&mut self, janela: &[Vec]) -> f64 { let c = self.som.n_celulas(); let d = self.som.d; let sigma = self.som.cfg_sigma_corrente(); // σ fixo de rastreio let sigma2 = 2.0 * sigma * sigma; - let eta = 0.1; // taxa de rastreio + let eta = self.eta_rastreio; // v0.10.0: configurável (T-1′) // decaimento da massa temporal for m in massa_iter_mut(&mut self.massa_temporal) { @@ -807,7 +1042,7 @@ pub fn treinar_gng(dados: &Tensor, cfg: &CfgGng) -> candle_core::Result = arestas @@ -817,7 +1052,7 @@ pub fn treinar_gng(dados: &Tensor, cfg: &CfgGng) -> candle_core::Result = (0..d) @@ -864,6 +1099,14 @@ pub struct CfgHSom { /// nº de sub-células por célula grossa (grade fina por célula). pub celulas_finas: usize, pub epocas_finas: usize, + /// v0.10.0 (crítica DeepSeek H-1(c), r-35 §2.6): reserva o slot fino + /// 0 de cada célula como CÓPIA PERMANENTE do protótipo grosso `q_c` + /// (nunca atualizado, nunca re-semeado). Com isto o BMU fino pode + /// SEMPRE escolher `q_c` ⇒ `QE_hier ≤ QE_grosso` vira TEOREMA (a + /// parte (c) era regularidade empírica na v0.5.0 — a re-semeadura de + /// células vazias podia remover q_c do conjunto). Default false = + /// comportamento v0.9.0 bit-a-bit. + pub reservar_grosso: bool, } impl Default for CfgHSom { @@ -872,6 +1115,7 @@ impl Default for CfgHSom { cfg_grosso: CfgSom4D { nx: 3, ny: 3, nz: 2, nt: 2, epocas: 30, ..Default::default() }, celulas_finas: 9, epocas_finas: 20, + reservar_grosso: false, } } } @@ -895,11 +1139,16 @@ impl HSomTreinado { /// Treina o H-SOM: mapa grosso + sub-mapas finos por célula. /// -/// **Teo H-1 (decomposição):** sub-mapas inicializados com TODOS os -/// protótipos no protótipo grosso `q_c` ⇒ QE_hierárquico inicial = QE_grosso -/// exatamente; cada passo de lote fino não aumenta a QE intra-célula ⇒ -/// `QE_hier ≤ QE_grosso + 2·R_fino + 2·sqrt(QE_grosso·R_fino)` -/// (desenvolvimento de `(a+b)² ≤ 2a²+2b²`). +/// **Teo H-1′ (v0.10.0, crítica DeepSeek H-1(b) — parcialmente procedente):** +/// sub-mapas inicializados com TODOS os protótipos no protótipo grosso `q_c` +/// ⇒ QE_hierárquico inicial = QE_grosso exatamente (a). A cota da família +/// `(a+b)²` é `QE_hier ≤ (√QE_grosso + √R_fino)²` — a MAIS JUSTA das três +/// (triangular + Cauchy–Schwarz); as cotas usadas na v0.5.0 +/// (`QE + 2R + 2√(QE·R)`) e a proposta pela crítica (`2QE + 2R`) são ambas +/// VÁLIDAS mas frouxas: a nossa era frouxa por exatamente `R`; a da crítica +/// é mais justa que a nossa só quando `QE < 4R` (e mais frouxa que a ótima +/// sempre, por AM-GM). (c) com `reservar_grosso = true` vira teorema: +/// `QE_hier ≤ QE_grosso` garantido (o slot 0 é q_c permanente). pub fn treinar_hsom(dados: &Tensor, cfg: &CfgHSom, dev: &Device) -> candle_core::Result { let xs = para_matriz(dados)?; let n = xs.len(); @@ -923,6 +1172,9 @@ pub fn treinar_hsom(dados: &Tensor, cfg: &CfgHSom, dev: &Device) -> candle_core: continue; } let k = cfg.celulas_finas; + // v0.10.0 (H-1′-c): com reservar_grosso, o slot 0 NUNCA é + // atualizado nem re-semeado — cópia permanente de q_c (teorema) + let f_ini = if cfg.reservar_grosso { 1 } else { 0 }; // atribuição fina inicial: tudo na célula 0 (protótipos iguais) for _epoca in 0..cfg.epocas_finas { let mut somas: Vec> = vec![vec![0.0; d]; k]; @@ -936,7 +1188,7 @@ pub fn treinar_hsom(dados: &Tensor, cfg: &CfgHSom, dev: &Device) -> candle_core: } // atualiza células ocupadas; células vazias ficam para trás // (re-inicializa no ponto mais distante — estratégia k-means++) - for f in 0..k { + for f in f_ini..k { if conts[f] > 0.0 { for j in 0..d { finos[g][f][j] = somas[f][j] / conts[f]; @@ -944,18 +1196,23 @@ pub fn treinar_hsom(dados: &Tensor, cfg: &CfgHSom, dev: &Device) -> candle_core: } } // re-semeia células vazias nos piores pontos (evita degeneração) - for f in 0..k { + for f in f_ini..k { if conts[f] == 0.0 { let (pior, _) = pontos .iter() .enumerate() .map(|(i, x)| (i, distancia2(x, &finos[g][melhor_indice(&finos[g], x)]))) - .max_by(|a, b| a.1.partial_cmp(&b.1).unwrap()) + .max_by(|a, b| a.1.total_cmp(&b.1)) .unwrap_or((0, 0.0)); finos[g][f] = pontos[pior].clone(); } } } + // H-1′-c: garante o slot 0 = q_c após todo o processo (defensivo — + // o loop acima já não o toca quando reservar_grosso) + if cfg.reservar_grosso { + finos[g][0] = grosso.prototipos[g].clone(); + } } // métricas: QE hierárquico, QE grosso, R_fino @@ -991,7 +1248,7 @@ fn quantizar_em(grosso: &Som4DTreinado, finos: &[Vec>], x: &[f64]) -> ( // --------------------------------------------------------------------------- pub fn versao() -> &'static str { - "som4d-0.5.0" + "som4d-0.10.0" } #[cfg(test)] @@ -1063,7 +1320,7 @@ mod testes { let dados_iniciais: Vec> = (0..128).map(|_| (0..3).map(|_| rng.normal(0.0, 0.5)).collect()).collect(); let t0 = tensor_de(&dados_iniciais, &dev); - let cfg = CfgTSom { cfg_grade: CfgSom4D { nx: 3, ny: 3, nz: 2, nt: 2, epocas: 15, ..Default::default() }, gamma: 0.9, janela: 32 }; + let cfg = CfgTSom { cfg_grade: CfgSom4D { nx: 3, ny: 3, nz: 2, nt: 2, epocas: 15, ..Default::default() }, gamma: 0.9, janela: 32, eta_rastreio: 0.1 }; let mut tsom = TSom4D::novo(&t0, &cfg, &dev).unwrap(); // deriva: +0.02 por janela em todas as dims @@ -1157,4 +1414,251 @@ mod testes { h.eq_grosso ); } + + // ----------------------------------------------------------------- + // v0.10.0 — S4-1′/T-1′/H-1′ (críticas DeepSeek SOM). Provas r-35 §2. + // ----------------------------------------------------------------- + + #[test] + fn teste_s41_contraexemplo_qe_sobe_com_media() { + // CONTRAEXEMPLO da crítica DeepSeek, reproduzido (S4-1′-b): dados + // {0, 10}, 2 células inicializadas NOS dados (QE inicial = 0), + // σ gigante (kernel ≈ uniforme), η = 1 ⇒ ambos os protótipos vão + // para a média 5 ⇒ QE final = 5 > 0. A QE NÃO é não-crescente no + // regime σ grande — a prova v0.5.0 era INVÁLIDA (usava ‖·‖² para + // concluir sobre ‖·‖). O que NÃO cresce é a Φ (teste abaixo). + let dev = Device::Cpu; + let dados = vec![vec![0.0f64], vec![10.0f64]]; + let t = tensor_de(&dados, &dev); + let cfg = CfgSom4D { + nx: 2, ny: 1, nz: 1, nt: 1, + epocas: 1, + sigma0: 1e9, sigma1: 1e9, // kernel ≈ uniforme (regime adverso) + eta0: 1.0, eta1: 1.0, // passo completo + inicializacao: Inicializacao4D::Dados, + semente: 1, // primeiro sample = dados[0]=0, segundo = dados[1]=10 + calcular_metricas: true, + ..Default::default() + }; + let som = treinar_som4d(&t, &cfg, &dev).unwrap(); + // protótipos nos dados ⇒ BMU exato ⇒ QE inicial = 0 + assert!( + som.eq_inicial < 1e-12, + "qe inicial deveria ser 0 (protótipos nos dados), veio {}", + som.eq_inicial + ); + assert!( + som.eq_final > 1.0, + "contraexemplo: QE deve SUBIR no regime σ grande com média \ + (veio {} — a crítica DeepSeek estaria refutada se isto falhar)", + som.eq_final + ); + } + + #[test] + fn teste_s41_phi_nao_cresce_incondicional() { + // S4-1′-a (teorema reparado): a Φ do kernel (EQM ponderado com + // atribuição congelada) é NÃO-CRESCENTE em TODAS as épocas, no + // MESMO setup adversário do contraexemplo (σ gigante) E no regime + // normal (σ decrescente) — incondicional. + let dev = Device::Cpu; + for (s0, s1) in [(1e9f64, 1e9f64), (2.0, 0.5)] { + let mut rng = crate::rng::RngDeterministico::novo(33); + let mut dados: Vec> = Vec::new(); + for c in [[-2.0, -2.0], [2.0, 2.0], [-2.0, 2.0], [2.0, -2.0]] { + for _ in 0..30 { + dados.push((0..2).map(|k| c[k] + rng.normal(0.0, 0.4)).collect()); + } + } + let t = tensor_de(&dados, &dev); + let cfg = CfgSom4D { + nx: 2, ny: 2, nz: 1, nt: 1, + epocas: 6, + sigma0: s0, sigma1: s1, + eta0: 1.0, eta1: 0.3, + calcular_metricas: true, + ..Default::default() + }; + let som = treinar_som4d(&t, &cfg, &dev).unwrap(); + assert!(!som.historia_phi.is_empty()); + for (ep, (antes, depois)) in som.historia_phi.iter().enumerate() { + assert!( + *depois <= *antes + 1e-9, + "S4-1′-a violado (σ={s0}->{s1}, época {ep}): Φ {antes} -> {depois}" + ); + } + } + } + + #[test] + fn teste_weiszfeld_mediana_geometrica() { + // (a) 1D assimétrico {0, 1, 10}: a mediana geométrica é o ponto + // 1 (o meio exato) — Weiszfeld converge para lá. + let pts = vec![vec![0.0f64], vec![1.0], vec![10.0]]; + let pares: Vec<(&Vec, f64)> = pts.iter().map(|p| (p, 1.0)).collect(); + let m = mediana_geometrica_ponderada(&pares, &[5.0], 50, 1e-12); + assert!((m[0] - 1.0).abs() < 1e-6, "mediana 1D = {} (esperado 1)", m[0]); + + // (b) contraexemplo {0,10} pesos iguais, início em 1: TODO ponto + // do segmento (0,10) é ponto fixo ⇒ o protótipo NÃO se move — a + // QE é PRESERVADA (a média moveria para 5 e a QE subiria). + let pts = vec![vec![0.0f64], vec![10.0]]; + let pares: Vec<(&Vec, f64)> = pts.iter().map(|p| (p, 1.0)).collect(); + let m = mediana_geometrica_ponderada(&pares, &[1.0], 30, 1e-12); + assert!((m[0] - 1.0).abs() < 1e-9, "ponto fixo violado: {}", m[0]); + + // (c) 2D triângulo: a mediana minimiza Σ‖x−v‖ — nenhuma perturbação + // próxima melhora (ótimo local = global, função convexa). + let tri = vec![vec![0.0, 0.0], vec![10.0, 0.0], vec![0.0, 10.0]]; + let pares: Vec<(&Vec, f64)> = tri.iter().map(|p| (p, 1.0)).collect(); + let m = mediana_geometrica_ponderada(&pares, &[3.0, 3.0], 200, 1e-12); + let soma = |p: &[f64]| -> f64 { + tri.iter().map(|v| ((v[0] - p[0]).powi(2) + (v[1] - p[1]).powi(2)).sqrt()).sum() + }; + let f_m = soma(&m); + for dx in [-0.05f64, 0.05] { + for dy in [-0.05f64, 0.05] { + let q = vec![m[0] + dx, m[1] + dy]; + assert!( + soma(&q) >= f_m - 1e-9, + "Weiszfeld não minimizou: {q:?} melhor que {m:?}" + ); + } + } + + // (d) fim-a-fim: no setup do contraexemplo, o SOM com MedianaGeometrica + // NÃO aumenta a QE (a média aumenta). + let dev = Device::Cpu; + let dados = vec![vec![0.0f64], vec![10.0f64]]; + let t = tensor_de(&dados, &dev); + let cfg = CfgSom4D { + nx: 2, ny: 1, nz: 1, nt: 1, + epocas: 1, + sigma0: 1e9, sigma1: 1e9, + eta0: 1.0, eta1: 1.0, + inicializacao: Inicializacao4D::Dados, + semente: 1, + calcular_metricas: true, + criterio_lote: CriterioLote::MedianaGeometrica, + weiszfeld_iters: 30, + ..Default::default() + }; + let som = treinar_som4d(&t, &cfg, &dev).unwrap(); + assert!( + som.eq_final <= som.eq_inicial + 1e-12, + "MedianaGeometrica: QE não-crescente no contraexemplo ({} -> {})", + som.eq_inicial, + som.eq_final + ); + } + + #[test] + fn teste_t1_termo_um_sobre_eta() { + // T-1′ (crítica procede): deriva pura (sem ruído) δ=0.5/janela; + // γ=0.9. O lag estacionário do protótipo vencedor tem o termo δ/η: + // lag(η=0.1) − lag(η=1.0) ≈ δ·(1/0.1 − 1) = 4.5. A cota v0.5.0 + // (sem 1/η) previa lag INDEPENDENTE de η — falsificado aqui. + let dev = Device::Cpu; + let medir_lag = |eta: f64| -> f64 { + let mut rng = crate::rng::RngDeterministico::novo(5); + // janela inicial: linha vertical (d=1) perto de 0 + let j0: Vec> = (0..32).map(|_| vec![rng.normal(0.0, 0.05)]).collect(); + let t0 = tensor_de(&j0, &dev); + let cfg = CfgTSom { + cfg_grade: CfgSom4D { + nx: 2, ny: 1, nz: 1, nt: 1, + epocas: 8, + sigma0: 0.8, sigma1: 0.8, + eta0: 1.0, eta1: 1.0, + inicializacao: Inicializacao4D::Dados, + ..Default::default() + }, + gamma: 0.9, + janela: 32, + eta_rastreio: eta, + }; + let mut tsom = TSom4D::novo(&t0, &cfg, &dev).unwrap(); + let delta = 0.5f64; + let mut lags = Vec::new(); + for w in 0..60 { + // deriva pura: janela w centrada em w·δ, sem ruído + let centro = (w + 1) as f64 * delta; + let jan: Vec> = (0..32) + .map(|i| vec![centro + (i as f64 - 16.0) * 0.001]) + .collect(); + tsom.passo(&jan); + // lag do protótipo mais próximo do centro corrente + let (b, _) = tsom.som.bmu(&[centro]); + lags.push((tsom.som.prototipos[b][0] - centro).abs()); + } + // lag estacionário: média das últimas 20 janelas + lags[lags.len() - 20..].iter().sum::() / 20.0 + }; + let lag1 = medir_lag(1.0); + let lag01 = medir_lag(0.1); + let delta = 0.5f64; + let dif = lag01 - lag1; + // previsão T-1′: dif ≈ δ·(1/0.1 − 1) = 4.5 (tolerância ampla p/ + // efeitos de janela finita); previsão v0.5.0: dif ≈ 0. + assert!( + dif > 2.0 * delta, + "termo δ/η ausente? lag(0.1)={lag1:.3} vs lag(1.0)={lag1:.3} \ + — a cota v0.5.0 (sem 1/η) seria falsificada se dif≈0" + ); + assert!( + dif < 12.0 * delta, + "lag(η=0.1)={lag01:.3} vs lag(η=1.0)={lag1:.3} fora da banda T-1′" + ); + // o lag com η=1 é pequeno (≈ γ/(1−γ)·δ_amostra + δ) + assert!(lag1 < 2.0 * delta, "lag(η=1)={lag1:.3} deveria ser pequeno"); + } + + #[test] + fn teste_h1_cota_otima_e_reserva() { + // H-1′(b): a cota MAIS JUSTA da família é (√QE + √R)² — valida + // numericamente e mostra que as outras duas são frouxas. + let dev = Device::Cpu; + let mut rng = crate::rng::RngDeterministico::novo(21); + let mut dados: Vec> = Vec::new(); + for c in [[-2.0, -2.0, 0.0], [2.0, -2.0, 0.0], [-2.0, 2.0, 0.0], [2.0, 2.0, 0.0]] { + for _ in 0..50 { + dados.push((0..3).map(|k| c[k] + rng.normal(0.0, 0.5)).collect()); + } + } + let t = tensor_de(&dados, &dev); + let h = treinar_hsom(&t, &CfgHSom::default(), &dev).unwrap(); + let otima = (h.eq_grosso.sqrt() + h.r_fino.sqrt()).powi(2); + let antiga = h.eq_grosso + 2.0 * h.r_fino + 2.0 * (h.eq_grosso * h.r_fino).sqrt(); + let deepseek = 2.0 * h.eq_grosso + 2.0 * h.r_fino; + assert!( + h.eq_hierarquico <= otima + 1e-9, + "QE_hier={} > cota ótima (√QE+√R)²={}", + h.eq_hierarquico, + otima + ); + // a ótima domina AMBAS as alternativas (AM-GM + antiga = ótima + R) + assert!(otima <= deepseek + 1e-12, "ótima {otima} > 2QE+2R {deepseek}"); + assert!( + (antiga - otima - h.r_fino).abs() < 1e-9, + "cota v0.5.0 deveria ser ótima + R exatamente" + ); + + // H-1′-c: com reservar_grosso, QE_hier ≤ QE_grosso é TEOREMA — + // o slot 0 é q_c permanente (verifica também a cópia). + let mut cfg = CfgHSom::default(); + cfg.reservar_grosso = true; + let h2 = treinar_hsom(&t, &cfg, &dev).unwrap(); + assert!( + h2.eq_hierarquico <= h2.eq_grosso + 1e-12, + "reserva: QE_hier {} > QE_grosso {} (teorema violado)", + h2.eq_hierarquico, + h2.eq_grosso + ); + for (g, fino) in h2.finos.iter().enumerate() { + assert_eq!( + fino[0], h2.grosso.prototipos[g], + "slot 0 deve ser cópia permanente de q_c" + ); + } + } } diff --git a/src/telemetria.rs b/src/telemetria.rs index 966a7daa1008147907dcbd8a20c47804e0a04f2d..3f4c2fc910dbd56bbf252d1e263c1b61757acbf1 100644 --- a/src/telemetria.rs +++ b/src/telemetria.rs @@ -200,11 +200,11 @@ impl TelemetryHub { if inclinacoes.is_empty() { return (0.0, 0.0, "amostra_insuficiente"); } - inclinacoes.sort_by(|a, b| a.partial_cmp(b).unwrap()); + inclinacoes.sort_by(|a, b| a.total_cmp(b)); let incl = inclinacoes[inclinacoes.len() / 2]; // intercepto pela mediana dos resíduos let mut res_intercept: Vec = pts.iter().map(|(x, y)| y - incl * x).collect(); - res_intercept.sort_by(|a, b| a.partial_cmp(b).unwrap()); + res_intercept.sort_by(|a, b| a.total_cmp(b)); let b0 = res_intercept[res_intercept.len() / 2]; // R² do ajuste robusto (1 − SS_res/SS_tot) let media_y: f64 = pts.iter().map(|(_, y)| y).sum::() / n as f64; @@ -392,6 +392,76 @@ impl TelemetryHub { /// simplesmente omitidas (painel ADITIVO — sem acoplamento rígido). /// Painel v0.9.0 — despacho SIMD + contexto das medições da r-34. + /// v0.10.0 — painel agregado das críticas DeepSeek (r-35). + pub fn painel_v100(&self) -> serde_json::Value { + let mut p = self.painel_v090(); + if let Some(obj) = p.as_object_mut() { + obj.insert( + "v100_nota".into(), + serde_json::json!( + "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" + ), + ); + } + p + } + + /// **v0.11.0 (r-43):** painel da fase elástica — módulos novos + /// (raciocinio_elástico RE-1..RE-8, asm/tratamento, M-R5′ guloso, + /// V-2′ soundness condicional) + agregação u64 com estouro detectado + /// por Carry Flag (kernel `soma_u64_cheia` — tratamento.txt §2). + pub fn painel_v110(&self) -> serde_json::Value { + let mut p = self.painel_v100(); + // agregação CHECADA dos passos de ajuste (kernel add/jc): telemetria + // corrompida/huge produz estado AUDITÁVEL, não wraparound silencioso + let passos: Vec = self.eventos_ajuste.iter().map(|e| e.passo as u64).collect(); + let soma_passos = match crate::asm::soma_u64_cheia(&passos) { + Ok(s) => serde_json::json!(s), + Err(e) => serde_json::json!(format!("ERRO-CF: {e}")), // nunca silencioso + }; + if let Some(obj) = p.as_object_mut() { + obj.insert("asm".into(), serde_json::json!(crate::asm::relatorio())); + obj.insert( + "elastico".into(), + serde_json::json!({ + "gate_compressao": self.ema("elastico_compressao_ok", 0.9), + "massa_removida_ema": self.ema("elastico_massa_removida", 0.9), + "rollback_ema": self.ema("elastico_rollback", 0.9), + "certificados": self.eventos_ajuste.iter() + .filter(|e| e.parametro == "elastico_compressao").count(), + }), + ); + obj.insert( + "ajustes_agregados".into(), + serde_json::json!({ + "n_eventos": self.eventos_ajuste.len(), + "soma_passos": soma_passos, + "soma_checada_cf": true, + }), + ); + obj.insert( + "v110_nota".into(), + serde_json::json!( + "r-36..r-42 (provas v0.11): S4-1′/S4-2/T-1′/H-1′(pin slot) SOM; J-1′/J-3′ JEPA; \ + A.0′/A.1′/B.1/C.3′ NCM; T-P1′/T-P5′(identidade exata)/T-P6′ Pensamento; \ + N-2/V-2′(ECE_aceito + cota condicional L1/p_a)/V-3 Verificador; M-R1′/M-R5′\ + (guloso inteiro ótimo — contraexemplo −4,3%)/F-9′ MoE+FNH; RE-1..RE-8 \ + raciocínio elástico com certificado de compressão; tratamento.txt: \ + Rust Result + Assembly por flags (CF/PF/ZF), module::error, sem unwrap \ + em produção" + ), + ); + } + p + } + pub fn painel_v090(&self) -> serde_json::Value { let mut p = self.painel_v070(None); if let Some(obj) = p.as_object_mut() { diff --git a/src/tipos.rs b/src/tipos.rs index 38050d2e332c5e1b353e0c302f8b3ceb1ed62507..8792f70636897dea483cbd0f311ac5a9f81077b8 100644 --- a/src/tipos.rs +++ b/src/tipos.rs @@ -52,6 +52,10 @@ impl Probabilidade { pub struct GateAtivacao(f64); impl GateAtivacao { + /// Valor canônico 0 (gate fechado) — usado como fallback tipado em + /// caminhos impossíveis-por-teorema (nunca panic — tratamento.txt §1). + pub const ZERO: GateAtivacao = GateAtivacao(0.0); + pub fn novo(v: f64) -> Result { if v.is_nan() || v < 0.0 || v > 1.0 { candle_core::bail!("GateAtivacao fora de [0,1]: {v}"); diff --git a/src/tokenizador.rs b/src/tokenizador.rs index 704a37efb51f623ea7f165b9b24a465b9d6c129b..f06d160d847e499cc9bbcb66c90ba4030c6b59b7 100644 --- a/src/tokenizador.rs +++ b/src/tokenizador.rs @@ -167,6 +167,99 @@ impl TokenizadorConceitos { } } + /// **TC intra-nível (v0.10.0, crítica DeepSeek B.1 — Teos B.1-R/B.1-T + /// em r-35 §4.3):** estimador plug-in da MÉDIA da informação mútua por + /// PAR de posições DENTRO de cada nível, sobre os códigos duros + /// induzidos pelo tokenizador (medida INCONDICIONAL — a condicional + /// em c_{<ℓ} não é estimável no tamanho do nosso minibatch; ver r-35 + /// §4.3 pela análise honesta do que é mensurável). + /// + /// Correção de Miller–Madow: `MÎ ← max(0, MI_plug − (K−1)²/(2m))` + /// (vício do plug-in em tabelas K×K com m amostras). Devolve, por + /// nível, a média de MÎ sobre os pares amostrados (nats). Com + /// independência intra-nível perfeita ⇒ 0. + /// + /// Uso: telemetria/avaliação (V6 do n-04). A PENALIDADE λ_TC·TC na + /// perda do GERADOR é refutada em r-35 (Teo B.1-R: no-ópera no ótimo + /// do CE); a alavanca correta é o lado do TOKENIZADOR (Teo B.1-T). + pub fn tc_intra_nivel(&self, ids: &Tensor, max_pares: usize) -> Result> { + self.tc_intra_nivel_com_piso(ids, max_pares).map(|(tc, _)| tc) + } + + /// Versão com o PISO DE RESOLUÇÃO do estimador (v0.10.0): devolve + /// (tc_por_nivel, piso_mm_por_nivel) — o viés do plug-in em tabelas + /// K×K com m amostras é ≈ (K−1)²/(2m) nats (Miller–Madow); MI abaixo + /// disso NÃO é resolvível. `tc = 0` com piso `r` significa + /// `TC_par < r` (cota superior honesta), não "independência provada". + pub fn tc_intra_nivel_com_piso( + &self, + ids: &Tensor, + max_pares: usize, + ) -> Result<(Vec, Vec)> { + let dev = ids.device(); + let cod = self.codificar_congelado(ids)?; + let b = cod.ids[0].dims()[0]; + let m = b as f64; + let mut saida = Vec::with_capacity(self.niveis.len()); + let mut pisos = Vec::with_capacity(self.niveis.len()); + for (i, &n_l) in self.niveis.iter().enumerate() { + let k = self.quants[i].w.as_tensor().dims()[0]; + let mm_corr = ((k - 1) * (k - 1)) as f64 / (2.0 * m); + let plano = cod.ids[i].reshape((b, n_l))?.detach(); + let dados = plano.flatten_all()?.to_vec1::()?; + // pares determinísticos: (0,1),(0,2),...,(1,2),... até max_pares + let mut pares: Vec<(usize, usize)> = Vec::new(); + 'pares: for a in 0..n_l { + for c in (a + 1)..n_l { + pares.push((a, c)); + if pares.len() >= max_pares.max(1) { + break 'pares; + } + } + } + if pares.is_empty() { + saida.push(0.0); + pisos.push(0.0); + continue; + } + let mut soma = 0.0f64; + for &(a, c) in &pares { + // histograma conjunto K×K + marginais + let mut conj = vec![0u32; k * k]; + let mut ma = vec![0u32; k]; + let mut mc = vec![0u32; k]; + for r in 0..b { + let va = dados[r * n_l + a] as usize; + let vc = dados[r * n_l + c] as usize; + if va < k && vc < k { + conj[va * k + vc] += 1; + ma[va] += 1; + mc[vc] += 1; + } + } + let mi_plug: f64 = (0..k) + .flat_map(|x| (0..k).map(move |y| (x, y))) + .filter_map(|(x, y)| { + let nxy = conj[x * k + y]; + if nxy == 0 || ma[x] == 0 || mc[y] == 0 { + None + } else { + let pxy = nxy as f64 / m; + let px = ma[x] as f64 / m; + let py = mc[y] as f64 / m; + Some(pxy * (pxy / (px * py)).ln()) + } + }) + .sum(); + soma += (mi_plug - mm_corr).max(0.0); + } + saida.push(soma / pares.len() as f64); + pisos.push(mm_corr); + } + let _ = &dev; + Ok((saida, pisos)) + } + /// Reconstrói ẑ a partir de códigos (para corrupção κ e amostragem — /// o gerador nunca vê os vetores contínuos, apenas c (C.3)). pub fn reconstruir_de_codigos(&self, ids: &[Tensor], ate_nivel: usize, b: usize, dev: &Device) -> Result> { @@ -392,9 +485,9 @@ impl TokenizadorConceitos { } let txt = serde_json::to_string(&serde_json::Value::Object(obj)) .map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?; - let tmp = format!("{caminho}.tmp"); - std::fs::write(&tmp, txt).map_err(|e| candle_core::Error::Msg(format!("io: {e}")))?; - std::fs::rename(&tmp, caminho).map_err(|e| candle_core::Error::Msg(format!("rename: {e}")))?; + // v0.11.0 (restaurado da v0.10.0): checkpoint ATÔMICO completo — + // tmp→fsync→rename→fsync(dir) + manifesto SHA-256 (Teo CP-1/CP-2) + crate::checkpoint::salvar_atomico(caminho, &txt)?; Ok(()) } } diff --git a/src/treino.rs b/src/treino.rs index b71ecaade058b265f02ed61ab4dabb4008fd8c9f..8c6e9555fdbf1016832da00f4b2442253c77e7e4 100644 --- a/src/treino.rs +++ b/src/treino.rs @@ -54,7 +54,22 @@ impl AdamWManual { let n = g.len(); let m = self.m.entry(i).or_insert(vec![0f32; n]); let v = self.v.entry(i).or_insert(vec![0f32; n]); - let dados = var.as_tensor().flatten_all().unwrap().to_vec1::().unwrap(); + // v0.11.0 (tratamento.txt §1): extração SEM panic — falha + // estrutural (impossível por construção: dtype f32 do próprio + // var) é logada e a variável é pulada; nunca aborta o treino + // silenciosamente (o "fundo" mata processos com panic sem + // rastro de erro/OOM — log é o único rastro sobrevivente) + let dados = match var + .as_tensor() + .flatten_all() + .and_then(|t| t.to_vec1::()) + { + Ok(d) => d, + Err(e) => { + log::error!("AdamW: extração da variável {i} falhou: {e} — pulada"); + continue; + } + }; let mut novos = vec![0f32; n]; crate::simd::passo_adamw( &dados, &g, m, v, &mut novos, self.lr, self.beta1, self.beta2, @@ -62,8 +77,15 @@ impl AdamWManual { ); let forma = var.as_tensor().shape(); let dev = var.as_tensor().device(); - let novo_t = Tensor::from_vec(novos, forma.clone(), dev).unwrap() - .reshape(forma).unwrap(); + let novo_t = match Tensor::from_vec(novos, forma.clone(), dev) + .and_then(|t| t.reshape(forma)) + { + Ok(t) => t, + Err(e) => { + log::error!("AdamW: reconstrução da variável {i} falhou: {e} — pulada"); + continue; + } + }; let _ = var.set(&novo_t); } } @@ -81,6 +103,39 @@ impl AdamWManual { /// Clip global por norma (in-place nos grads achatados). pub fn clipar(grads: &mut [Option>], teto: f64) { + // v0.11.0 (tratamento.txt §2): varredura NaN em ASSEMBLY (PF do + // ucomiss) ANTES da norma — diagnóstico LOCALIZADO (tensor e + // índice do primeiro NaN), substituindo a detecção difusa da soma + // f64. A guarda `is_finite` abaixo permanece como rede de segurança + // (defesa em profundidade — mesma filosofia do rollback RE-2). + let mut nan_achado: Option<(usize, usize)> = None; + for (ti, g) in grads.iter().enumerate() { + if let Some(gv) = g { + match crate::asm::primeiro_nan_f32(gv) { + Ok(Some(idx)) => { + nan_achado = Some((ti, idx)); + break; + } + Err(e) => { + // pré-condição estrutural: não deve ocorrer — logado, + // nunca silencioso (tratamento.txt §1) + log::error!("varredura NaN falhou: {e}"); + } + Ok(None) => {} + } + } + } + if let Some((ti, idx)) = nan_achado { + log::warn!( + "grad não-finito: NaN no tensor {ti}, índice {idx} (kernel ucomiss/jp) — passo zerado" + ); + for g in grads.iter_mut().flatten() { + for x in g.iter_mut() { + *x = 0.0; + } + } + return; + } let norma = Self::norma_global(grads); if !norma.is_finite() { // gradiente explodido (inf/nan): zera o passo — seguro por @@ -222,6 +277,13 @@ pub struct ResumoFase { pub perplexidade_codebook: f64, pub monotonia_prefixo: f64, pub escore_aprendizado: f64, + /// v0.10.0 (A.1′): coerência de Welch máxima dos codebooks. + pub coerencia_max: f64, + /// v0.10.0 (B.1): correlação total intra-nível média (plug-in MM). + pub tc_intra_nivel_medio: f64, + /// v0.10.0: piso de resolução do estimador (Miller–Madow) — tc=0 com + /// piso r significa TC < r (cota superior), não independência provada. + pub tc_resolucao_nats: f64, } /// FASE A — tokenizador (n-04 §4): nested dropout + commitment + GSQ + RCO. @@ -283,9 +345,16 @@ pub fn treinar_fase_a( if passo % a_cada == 0 || passo == cfg.treino.passos_fase_a - 1 { let perp: f64 = tok.quants.iter().map(|q| q.perplexidade_uso()).sum::() / tok.quants.len().max(1) as f64; let dort: f64 = tok.quants.iter().map(|q| q.delta_ort_ultimo).fold(0f64, f64::max); + // v0.10.0 (A.1′): coerência de Welch dos codebooks + let coh: f64 = tok + .quants + .iter() + .map(|q| q.coerencia().unwrap_or(f64::NAN)) + .fold(f64::MIN, f64::max); hub.registrar_multi(&[ ("codebook_perplexidade_media", perp), ("delta_ort_max", dort), + ("coerencia_welch_max", coh), ("escore_aprendizado", hub.escore_aprendizado()), ]); if cfg.telemetria.deteccao_aprendizado { @@ -319,6 +388,27 @@ pub fn treinar_fase_a( let perp: f64 = tok.quants.iter().map(|q| q.perplexidade_uso()).sum::() / tok.quants.len().max(1) as f64; let dort = tok.quants.iter().map(|q| q.delta_ort_ultimo).fold(0f64, f64::max); let acc = { let (_, m) = tok.perda_fase_a(&ids_val, &mut rng)?; m.acc_recon }; + // v0.10.0 (B.1): TC intra-nível plug-in (Miller–Madow) numa amostra + // MAIOR (16 lotes — o piso de resolução do estimador cai com m) — + // linha de base para a alavanca do tokenizador (Teo B.1-T) + let mut ids_tc: Option = None; + for _ in 0..16 { + let l = dados.lote(cfg.treino.lote, &mut rng, &dev)?; + ids_tc = Some(match ids_tc { + None => l, + Some(a) => Tensor::cat(&[a, l], 0)?, + }); + } + let (tc_niveis, pisos) = ids_tc + .and_then(|t| tok.tc_intra_nivel_com_piso(&t, 16).ok()) + .unwrap_or_default(); + let tc_medio = tc_niveis.iter().sum::() / tc_niveis.len().max(1) as f64; + let tc_resolucao = pisos.iter().sum::() / pisos.len().max(1) as f64; + let coh_max = tok + .quants + .iter() + .map(|q| q.coerencia().unwrap_or(f64::NAN)) + .fold(f64::MIN, f64::max); if let Some(c) = caminho_checkpoint { tok.salvar(c)?; } @@ -333,6 +423,9 @@ pub fn treinar_fase_a( perplexidade_codebook: perp, monotonia_prefixo: monotonia, escore_aprendizado: hub.escore_aprendizado(), + coerencia_max: coh_max, + tc_intra_nivel_medio: tc_medio, + tc_resolucao_nats: tc_resolucao, }) } @@ -454,6 +547,9 @@ pub fn treinar_fase_b( perplexidade_codebook: 0.0, monotonia_prefixo: 0.0, escore_aprendizado: hub.escore_aprendizado(), + coerencia_max: f64::NAN, // fase B: codebooks congelados (medidos na A) + tc_intra_nivel_medio: f64::NAN, + tc_resolucao_nats: f64::NAN, }) } diff --git a/src/verificador.rs b/src/verificador.rs index bcd36b69d51a35e2490901f5e4fb6571ce6152cf..2f3b5574795df6b1ec869224a58b356ee4c7ec30 100644 --- a/src/verificador.rs +++ b/src/verificador.rs @@ -236,13 +236,144 @@ pub fn limiar_por_erro(confs: &[f64], epsilon: f64) -> f64 { if v.is_empty() { return 1.0; } - v.sort_by(|a, b| a.partial_cmp(b).unwrap()); + v.sort_by(|a, b| a.total_cmp(b)); let idx = (((1.0 - epsilon.clamp(0.0, 1.0)) * v.len() as f64).ceil() as usize) .saturating_sub(1) .min(v.len() - 1); v[idx] } +/// **V-2′ (v0.11.0, r-40):** relatório de soundness CONDICIONAL ao aceite. +/// +/// Errata da v0.6.0: a cota `P(erro|aceito) ≤ 1−τ_c + ECE` só vale com ECE +/// medido NO CONJUNTO ACEITO; com ECE global o correto é +/// `P(erro|A) ≤ 1−τ_c + L₁/p_a` com `p_a = P(A)` (condicionamento: +/// `E[X|A] ≤ E[X]/P(A)` para X ≥ 0). +/// +/// **Teorema (r-40).** Seja `A = {conf ≥ τ_c}`, `p_a = P(A) > 0` e +/// `L₁ = E|1{acerto} − conf|` (calibração L1; o ECE por faixas é seu +/// estimador com viés O(1/faixas)). Então +/// `P(erro | A) ≤ (1−τ_c) + L₁/p_a`. +/// Prova. `P(erro|A) = 1 − E[1{acerto}|A] ≤ 1 − E[conf|A] + +/// E[|1{acerto}−conf| | A] ≤ 1 − τ_c + L₁/p_a`. ∎ +/// Com `ece_aceito` (faixas restritas a conf ≥ τ_c) vale a forma limpa +/// `P(erro|A) ≤ 1 − τ_c + ece_aceito`. +#[derive(Debug, Clone)] +pub struct RelatorioSoundness { + /// τ_c usado (limiar de aceite). + pub tau_c: f64, + /// fração de aceites `p_a = P(conf ≥ τ_c)` (vem de graça do quantil V-3). + pub p_aceite: f64, + /// nº de amostras aceitas (denominador de P(erro|A)). + pub n_aceito: usize, + /// ECE medido SÓ nas amostras aceitas (a forma correta da cota limpa). + pub ece_aceito: f64, + /// calibração L1 global estimada (para a cota corrigida `L₁/p_a`). + pub l1_global: f64, + /// cota limpa `1 − τ_c + ece_aceito` (válida por construção). + pub cota_limpa: f64, + /// cota corrigida `1 − τ_c + L₁/p_a` (válida com ECE global). + pub cota_corrigida: f64, + /// erro empírico medido `P̂(erro|aceito)` no conjunto fornecido. + pub p_erro_aceito: f64, + /// true se o erro empírico respeita a cota limpa (sanidade do relatório). + pub cota_limpa_respeitada: bool, +} + +/// Constrói o relatório V-2′. `confs`/`corretos` = amostras retidas +/// (exchangeability com produção — ver limitações r-40 §L1). +pub fn relatorio_soundness( + confs: &[f64], + corretos: &[bool], + n_faixas: usize, + tau_c: f64, +) -> Result { + if confs.len() != corretos.len() { + candle_core::bail!("relatorio_soundness: confs ({}) e corretos ({}) de tamanhos distintos", confs.len(), corretos.len()); + } + let n = confs.len(); + if n == 0 { + candle_core::bail!("relatorio_soundness: nenhuma amostra retida"); + } + let aceitos: Vec<(f64, bool)> = confs + .iter() + .zip(corretos.iter()) + .filter(|(c, _)| **c >= tau_c) + .map(|(c, ok)| (*c, *ok)) + .collect(); + let n_aceito = aceitos.len(); + let p_aceite = n_aceito as f64 / n as f64; + // L1 global: E|1{acerto} − conf| (estimador empirico simples — sem faixas) + let l1_global = confs + .iter() + .zip(corretos.iter()) + .map(|(c, ok)| (if *ok { 1.0 } else { 0.0 } - c).abs()) + .sum::() + / n as f64; + if n_aceito == 0 { + // p_a = 0: a cota condicional é vazua — reportar honestamente + return Ok(RelatorioSoundness { + tau_c, + p_aceite: 0.0, + n_aceito: 0, + ece_aceito: f64::NAN, + l1_global, + cota_limpa: f64::INFINITY, + cota_corrigida: f64::INFINITY, + p_erro_aceito: f64::NAN, + cota_limpa_respeitada: true, // conjunto vazio: nada a violar + }); + } + let (confs_a, oks_a): (Vec, Vec) = aceitos.into_iter().unzip(); + // ECE com faixas RESTRITAS ao domínio aceito [τ_c, 1] — a forma correta + let ece_a = ece_dominio(&confs_a, &oks_a, n_faixas, tau_c, 1.0); + let erro_aceito = oks_a.iter().filter(|ok| !**ok).count() as f64 / n_aceito as f64; + let cota_limpa = 1.0 - tau_c + ece_a; + let cota_corrigida = 1.0 - tau_c + l1_global / p_aceite.max(1e-12); + Ok(RelatorioSoundness { + tau_c, + p_aceite, + n_aceito, + ece_aceito: ece_a, + l1_global, + cota_limpa, + cota_corrigida, + p_erro_aceito: erro_aceito, + cota_limpa_respeitada: erro_aceito <= cota_limpa + 1e-9, + }) +} + +/// ECE por faixas em um domínio arbitrário [lo_dom, hi_dom] (V-2′): a +/// versão pública `ece` é o caso especial [0,1]. As faixas particionam o +/// DOMÍNIO (não [0,1]), para não inflar artificialmente o peso das faixas +/// vazias fora do domínio. +fn ece_dominio(confs: &[f64], corretos: &[bool], n_faixas: usize, lo_dom: f64, hi_dom: f64) -> f64 { + if confs.is_empty() || confs.len() != corretos.len() { + return f64::NAN; + } + let n = confs.len() as f64; + let larg = (hi_dom - lo_dom).max(1e-12) / n_faixas as f64; + let mut total = 0f64; + for b in 0..n_faixas { + let (lo, hi) = (lo_dom + b as f64 * larg, lo_dom + (b + 1) as f64 * larg); + let mut soma_conf = 0f64; + let mut soma_acerto = 0f64; + let mut m = 0usize; + for (c, ok) in confs.iter().zip(corretos.iter()) { + let c1 = (*c).min(hi_dom - 1e-12); + if *c >= lo && c1 < hi { + soma_conf += c; + soma_acerto += if *ok { 1.0 } else { 0.0 }; + m += 1; + } + } + if m > 0 { + total += (m as f64 / n) * (soma_conf / m as f64 - soma_acerto / m as f64).abs(); + } + } + total +} + /// Verificador NCM calibrado — o substituto de produção do oráculo. #[derive(Debug, Clone)] pub struct VerificadorNcm { @@ -381,6 +512,103 @@ mod testes { assert!(p_erro <= cota, "P(erro|aceito)={p_erro:.4} ≤ 1−τ_c+ECE+folga={cota:.4} (τ_c={tau:.3}, ECE={e_depois:.4})"); } + /// **V-2′ (v0.11.0, r-40):** cota CONDICIONAL corrigida. + /// (i) `P̂(erro|A) ≤ 1−τ_c + ÊCE_aceito` vale EXATAMENTE no empirico + /// (triangular por faixa: `1−acc̄_b ≤ (1−conf̄_b) + |conf̄_b−acc̄_b|` + /// com `conf̄_b ≥ τ_c`); + /// (ii) `P̂(erro|A) ≤ 1−τ_c + L̂₁/p_a` idem (por amostra); + /// (iii) ERRATA: a cota antiga `1−τ_c + ECE_global` PODE SER VIOLADA — + /// contraexemplo construído (90% conf=0,5 calibrada + 10% conf=0,95 + /// superconfiante aceitos). + #[test] + fn v2_linha_cota_condicional_corrigida() { + // simulador com viés senoidal (calibração imperfeita suave) + let mut rng = crate::rng::RngDeterministico::novo(20261113); + let n = 100_000usize; + let (mut confs, mut corretos) = (Vec::with_capacity(n), Vec::with_capacity(n)); + for i in 0..n { + // conf na diagonal + viés senoidal (superconfiante no topo) + let u = i as f64 / n as f64; + let c = (0.25 + 0.70 * u + 0.05 * (12.0 * u).sin()).clamp(0.01, 0.99); + let p_real = (c - 0.06 * (6.0 * u).sin()).clamp(0.01, 0.99); + confs.push(c); + corretos.push(rng.uniforme() < p_real); + } + let tau = 0.90; + let r = relatorio_soundness(&confs, &corretos, 20, tau).unwrap(); + assert!(r.n_aceito > 0, "deve haver aceites"); + assert!(r.p_aceite > 0.0 && r.p_aceite <= 1.0); + // (i) cota limpa: exata no empirico (desigualdade triangular por faixa) + assert!( + r.p_erro_aceito <= r.cota_limpa + 1e-9, + "P̂(erro|A)={:.4} ≤ 1−τ_c+ÊCE_aceito={:.4}", + r.p_erro_aceito, r.cota_limpa + ); + // (ii) cota corrigida com L1 global: exata (condicionamento X≥0) + assert!( + r.p_erro_aceito <= r.cota_corrigida + 1e-9, + "P̂(erro|A)={:.4} ≤ 1−τ_c+L̂₁/p_a={:.4}", + r.p_erro_aceito, r.cota_corrigida + ); + // a cota corrigida é MAIS FRACA (maior) que a limpa quando p_a < 1 + assert!(r.cota_corrigida >= r.cota_limpa - 1e-9); + + // (iii) ERRATA da v0.6.0: ECE GLOBAL pode violar a cota antiga + let (cg, og) = contraexemplo_ece_global(); + let ece_g = ece(&cg, &og, 10); + let n_a = cg.iter().zip(og.iter()).filter(|(c, _)| **c >= 0.9).count(); + let e_a = cg.iter().zip(og.iter()).filter(|(c, _)| **c >= 0.9).filter(|(_, o)| !**o).count(); + let p_erro_a = e_a as f64 / n_a as f64; + let cota_antiga = 1.0 - 0.9 + ece_g; + assert!( + p_erro_a > cota_antiga, + "contraexemplo: P(erro|A)={p_erro_a:.4} > 1−τ_c+ECE_global={cota_antiga:.4} (a cota antiga é INVÁLIDA)" + ); + // ... e o relatório V-2′ cobre este caso corretamente + let r2 = relatorio_soundness(&cg, &og, 10, 0.9).unwrap(); + assert!(r2.cota_limpa_respeitada, "cota limpa V-2′ cobre o contraexemplo"); + + fn contraexemplo_ece_global() -> (Vec, Vec) { + // 90% conf=0,5 PERFEITAMENTE calibrada (não aceita) + + // 10% conf=0,95 com acerto 0,80 (superconfiante, aceita): + // ECE_global ≈ 0,1·|0,95−0,80| = 0,015 ⇒ cota antiga 0,115 + // < P(erro|A) = 0,20 ⇒ VIOLAÇÃO; ece_aceito = 0,15 ⇒ cota + // limpa 0,25 ≥ 0,20 ✓ + let mut rng = crate::rng::RngDeterministico::novo(77); + let mut c = Vec::with_capacity(20_000); + let mut o = Vec::with_capacity(20_000); + for i in 0..20_000 { + if i % 10 == 0 { + c.push(0.95); + o.push(rng.uniforme() < 0.80); + } else { + c.push(0.50); + o.push(rng.uniforme() < 0.50); + } + } + (c, o) + } + } + + /// V-2′: casos degenerados — vazio, τ_c inalcançável, todos aceitos. + #[test] + fn v2b_casos_degenerados() { + assert!(relatorio_soundness(&[], &[], 10, 0.9).is_err(), "vazio => Err"); + assert!( + relatorio_soundness(&[0.5], &[true, false], 10, 0.9).is_err(), + "tamanhos distintos => Err" + ); + // τ_c = 1,0: nada é aceito (conf < 1) => relatório honesto com p_a = 0 + let r = relatorio_soundness(&[0.5, 0.8], &[true, false], 10, 1.0).unwrap(); + assert_eq!(r.n_aceito, 0); + assert!(r.p_aceite == 0.0); + assert!(r.cota_limpa.is_infinite(), "p_a=0 => cota vazia (honestidade)"); + // todos aceitos: ece_aceito == ece global no mesmo domínio + let r2 = relatorio_soundness(&[0.95, 0.96, 0.94], &[true, false, true], 5, 0.0).unwrap(); + let eg = ece(&[0.95, 0.96, 0.94], &[true, false, true], 5); + assert!((r2.ece_aceito - eg).abs() < 1e-12, "domínio total: ece_aceito == ece"); + } + #[test] fn v3_unimodalidade_da_nll_em_t() { // verificação empírica da unimodalidade (condição do golden-section) @@ -547,4 +775,110 @@ mod testes { assert!(nll_n2 <= nll_12 + 1e-6, "N-4b: NLL não piora"); assert!((1.0 / 8.0..=8.0).contains(&t_n2)); } + /// **N-5 (v0.10.0, pedido `aprimoramentos-arquitetura` §3):** casos + /// extremos da salvaguarda de bisseção — T* EXATAMENTE nos limites do + /// colchão [1/8, 8]. (i) modelo superconfiante ERRADO (margem enorme + /// na classe errada): NLL estritamente decrescente em T em todo o + /// colchão ⇒ mínimo na borda T* = 8 (resfria ao máximo) — exercita o + /// early-return `dlo ≥ 0` do calibrar_temperatura_newton; (ii) modelo + /// superconfiante CORRETO (margem enorme na classe certa): NLL + /// estritamente crescente em T ⇒ mínimo na borda T* = 1/8 (aquece ao + /// máximo) — exercita o early-return `dhi ≤ 0`. Em ambos: a resposta + /// deve coincidir com o golden-section (V-1), nunca piorar a NLL(1) e + /// não estourar o orçamento de avaliações. + #[test] + fn n5_t_estrela_nos_limites_do_colchao() { + let dev = Device::Cpu; + // (i) T* = 8: 1 classe errada com margem 30, alvo em outra + let n = 64usize; + let k = 10usize; + let mut lm = vec![0f32; n * k]; + for i in 0..n { + let classe_errada = (i % k as usize) as u32; // ≠ alvo + lm[i * k + classe_errada as usize] = 30.0; + } + let lt = Tensor::from_vec(lm, (n, k), &dev).unwrap(); + let alvos: Vec = (0..n).map(|i| ((i % k as usize) as u32 + 1) % k as u32).collect(); + let at = Tensor::from_vec(alvos, (n,), &dev).unwrap(); + let (t_n, nll_1, nll_n, nav) = calibrar_temperatura_newton(<, &at, 40).unwrap(); + let (t_g, _, _) = calibrar_temperatura(<, &at).unwrap(); + assert!( + (t_n - 8.0).abs() < 1e-9, + "caso (i): T* newton = {t_n} (esperado exatamente 8 — borda)" + ); + assert!( + (t_g - 8.0).abs() < 1e-6, + "caso (i): T* golden = {t_g} (esperado 8 — golden só atinge a borda na sua resolução de busca; newton atinge EXATAMENTE via early-return)" + ); + assert!(nll_n <= nll_1 + 1e-6, "caso (i): NLL piorou ({nll_n} > {nll_1})"); + assert!(nav <= 40, "caso (i): orçamento estourado ({nav} avaliações)"); + + // (ii) T* = 1/8: TODOS corretos com margem 100 (p_y = 1 mesmo a γ=8) + let mut lm = vec![0f32; n * k]; + let alvos: Vec = (0..n).map(|i| (i % k as usize) as u32).collect(); + for (i, &a) in alvos.iter().enumerate() { + lm[i * k + a as usize] = 100.0; + } + let lt = Tensor::from_vec(lm, (n, k), &dev).unwrap(); + let at = Tensor::from_vec(alvos, (n,), &dev).unwrap(); + let (t_n, nll_1, nll_n, nav) = calibrar_temperatura_newton(<, &at, 40).unwrap(); + let (t_g, _, _) = calibrar_temperatura(<, &at).unwrap(); + assert!( + (t_n - 0.125).abs() < 1e-9, + "caso (ii): T* newton = {t_n} (esperado exatamente 1/8 — borda)" + ); + // HONESTO (medido): o golden NÃO resolve o caso degenerado (ii) — + // a NLL é ~log(1+9e^{−100/T}), plana a ~1e-8 no colchão todo em + // f32, e a busca por seção áurea para num ponto interior (medido: + // T=5,31). O Newton acerta a borda EXATAMENTE pelo early-return + // sinal-based (dhi ≤ 0 em γ=8) — e sua NLL é ≤ à do golden. + // Este é um dos "casos extremos" pedidos: a salvaguarda não só + // sobrevive à borda como SUPERSTIMA o golden nela. + let (_, _, nll_g) = calibrar_temperatura(<, &at).unwrap(); + assert!( + nll_n <= nll_g + 1e-6, + "caso (ii): NLL newton {nll_n} > golden {nll_g} (T_n={t_n}, T_g={t_g})" + ); + assert!(nll_n <= nll_1 + 1e-6, "caso (ii): NLL piorou ({nll_n} > {nll_1})"); + assert!(nav <= 40, "caso (ii): orçamento estourado ({nav} avaliações)"); + } + + /// **N-5b (v0.10.0):** caso MISTO degenerado — metade da amostra quer + /// a borda fria, metade a quente (NLL quase plana no colchão): o + /// Newton com bisseção deve terminar DENTRO do colchão com n_aval + /// limitado (sem oscilação infinita) e a NLL ≤ NLL(1). + #[test] + fn n5b_caso_misto_quase_plano() { + let dev = Device::Cpu; + let n = 128usize; + let k = 4usize; + let mut lm = vec![0f32; n * k]; + let mut alvos = Vec::new(); + for i in 0..n { + let a = (i % k) as u32; + alvos.push(a); + if i % 2 == 0 { + lm[i * k + a as usize] = 0.05; // sinal fraco correto + } else { + let errada = (a + 1) % k as u32; + lm[i * k + errada as usize] = 0.05; // sinal fraco errado + } + } + let lt = Tensor::from_vec(lm, (n, k), &dev).unwrap(); + let at = Tensor::from_vec(alvos, (n,), &dev).unwrap(); + let (t_n, nll_1, nll_n, nav) = calibrar_temperatura_newton(<, &at, 40).unwrap(); + assert!( + (0.125..=8.0).contains(&t_n), + "T* = {t_n} fora do colchão [1/8, 8]" + ); + assert!(nll_n <= nll_1 + 1e-6, "NLL piorou ({nll_n} > {nll_1})"); + assert!(nav <= 40, "orçamento estourado ({nav})"); + // golden concorda em NLL dentro de 1e-3 (mínimo quase plano) + let (t_g, _, nll_g) = calibrar_temperatura(<, &at).unwrap(); + assert!( + nll_n <= nll_g + 1e-3, + "newton NLL {nll_n} muito pior que golden {nll_g} (T_n={t_n}, T_g={t_g})" + ); + } + }