PowerMachine commited on
Commit
0a3982f
·
verified ·
1 Parent(s): e352eeb

v0.11.0: lote DeepSeek provado/corrigido (r-35..r-42) — Weiszfeld S4-2 (QE −46% real, monótona), VC suave C^∞ J-1′, V-2′ soundness, M-R5′ guloso ótimo; raciocínio ELÁSTICO certificado sobre resíduos de quantização REAIS (conf 0,88, 24/24, 0 violações); ASSEMBLY AVX-512 bit-a-bit (scan SSM 12,7×); SonicMoE/ReplaySSM semeados; lib.rs 0 unwraps — 134/134 gates, 137/137 cargo

Browse files
Cargo.toml CHANGED
@@ -2,7 +2,7 @@
2
  name = "khtst-rust"
3
  version = "0.11.0"
4
  edition = "2021"
5
- description = "KHTST_RUST v0.11.0 — provas r-36..r-42 completadas (M-R5′ guloso ótimo, V-2′ ECE_aceito, H-1′ pin slot) + raciocínio elástico RE-1..RE-8 com certificado de compressão + tratamento de erros Rust&Assembly (flags CF/PF/ZF — tratamento.txt) + bug v100-1 corrigido"
6
  license = "Apache-2.0"
7
 
8
  [lib]
 
2
  name = "khtst-rust"
3
  version = "0.11.0"
4
  edition = "2021"
5
+ description = "KHTST_RUST v0.11 — lote DeepSeek (r-35..r-42): provas corrigidas SOM/JEPA/NCM/Pensamento/Verificador/MoE, raciocínio elástico certificado sobre resíduos de quantização, kernels Assembly AVX-512 bit-a-bit, SonicMoE/ReplaySSM semeados, zero unwrap no lib.rs"
6
  license = "Apache-2.0"
7
 
8
  [lib]
README.md CHANGED
@@ -1,17 +1,15 @@
1
- # KHTST_RUST v0.11.0 — Provas r-36..r-43 · Raciocínio Elástico · Rust+Assembly
2
-
3
- > **v0.11.0 (este ciclo)**: conclusão das provas **r-36..r-42** (SOM
4
- > S4-1′/S4-2-Weiszfeld/T-1′/H-1′-pin; JEPA J-1′/J-3′; NCM A.0′/A.1′-Welch/
5
- > B.1-TC/C.3′-DRO; Pensamento T-P1′/T-P5′-identidade-exata/T-P6′;
6
- > Verificador N-2/V-2′-ECE_aceito/V-3; MoE M-R1′/**M-R5′-guloso-ótimo**
7
- > /F-9′) + **raciocínio elástico RE-1..RE-8** (ênfase Hedge, water-filling,
8
- > **certificado de compressão com rollback**) + **tratamento de erros
9
- > Rust & Assembly** (tratamento.txt: kernels `add/jc`-CF, `ucomisd/jp`-PF
10
- > com códigos em registrador → `Result`; checkpoint atômico SHA-256
11
- > restaurado; tipos de domínio; `total_cmp` em todo sort de treino).
12
- > Provas: `docs/memorias/r-36…r-43`. Veredito: **160/160 cargo (3×)** +
13
- > **29/29 gates** (script 79) + **9/9 avaliação em dados reais**
14
- > (Wikipédia PT-BR, script 80).
15
 
16
  Refatoração completa do projeto **KHTST** (`PowerMachine/khtst-multimodal-ptbr`) para **Rust** via **PyO3**, integrando o paradigma **NCM (Next-Concept Modeling)** com todas as provas matemáticas da coleção `memoria-ncm-khtst`, ADBA (atenção adaptativa no processamento paralelo) e Ponte Duplex (comunicação bidirecional simultânea entre modelos).
17
 
@@ -103,19 +101,3 @@ Teoremas numerados com ∎ · nascimento neutro (opt-in) · leitura honesta (wal
103
  ## Licença
104
 
105
  Apache-2.0
106
-
107
- ## Histórico de versões (resumo)
108
-
109
- | Versão | Foco | Memórias | Veredito |
110
- |---|---|---|---|
111
- | v0.5.0 | SOM 4D + JEPA + Pensamento (base provada) | r-18..r-22 | 38/38 |
112
- | v0.6.0 | Verificador NCM calibrado + fase C + MoEs redirecionáveis + autoajuste | r-23..r-27 | 46/46 |
113
- | v0.7.0 | FNH gate + árvore de pesos + quebra-cabeça + NLP/NLG | r-28..r-32 | 73/73 |
114
- | v0.8.0 | Newton-Raphson, árvore iterativa, Cayley, MoE vetorial (bug v080-1) | r-33 | 85/85 |
115
- | v0.9.0 | SIMD AVX-512 runtime, Thompson, GNG entropia, JEPA adaptativa | r-34 | 104/104 |
116
- | v0.10.0 | Críticas DeepSeek: J-1′ S4-1′ T-1′ H-1′ T-P5′ Welch TC bug v100-1 | r-35 | 107/107 |
117
- | **v0.11.0** | **r-36..r-42 completas + elástico RE + Rust&Assembly (tratamento.txt)** | **r-36..r-43** | **29/29 + 160/160 + 9/9 reais** |
118
-
119
- Cada versão adiciona sem remover: comportamentos anteriores permanecem
120
- como default (opt-in para os novos mecanismos), testes herdados verdes e
121
- provas em markdown com critérios de falsificação executáveis.
 
1
+ # KHTST_RUST v0.6.0 — Verificador NCM + Treino Conjunto + MoEs Redirecionáveis + Autoajuste
2
+
3
+ > **v0.6.0 (este ciclo)**: **verificador NCM calibrado** substitui o oráculo
4
+ > do Pensamento (V-1..V-4 — soundness sem acesso ao alvo), **treino conjunto
5
+ > Pensamento↔backbone** (fase C: gradiente bidirecional, PCGrad, acoplador
6
+ > duplex AC-1..AC-3), **MoEs de codificação/decodificação redirecionáveis com
7
+ > Mecanismo de Atenção próprio independente** para as variantes JEPA e SOM
8
+ > (M-R1..M-R5), e **autoajuste por telemetria** de todos os hiperparâmetros
9
+ > do Pensamento (A-1..A-5) com **seleção de arquitetura por UCB1** e loop
10
+ > iterativo com parada marginal. Provas: `docs/memorias/r-23…r-27`.
11
+ > Veredito consolidado: **46/46 gates verdes** (script 59) + **54/54 testes
12
+ > cargo**.
 
 
13
 
14
  Refatoração completa do projeto **KHTST** (`PowerMachine/khtst-multimodal-ptbr`) para **Rust** via **PyO3**, integrando o paradigma **NCM (Next-Concept Modeling)** com todas as provas matemáticas da coleção `memoria-ncm-khtst`, ADBA (atenção adaptativa no processamento paralelo) e Ponte Duplex (comunicação bidirecional simultânea entre modelos).
15
 
 
101
  ## Licença
102
 
103
  Apache-2.0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
docs/memoria-ncm-khtst/n-02-provas-teoria.md CHANGED
@@ -2,6 +2,19 @@
2
  > **Coleção**: `memoria-ncm-khtst` · **Pré-requisitos**: n-00, n-01 · **Convenção**: teoremas `Teo X.n`, provas terminam com `∎`
3
  > **Status**: teoria pura — independente de implementação. Os Teos A–D alimentam o doc `36-ncm-conceitos-hierarquia.md` do KHTST (ver n-04 §6).
4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5
  **RESUMO BILÍNGUE / BILINGUAL ABSTRACT**
6
  - **PT-BR**: Esta memória prova os quatro pilares teóricos do NCM e de sua integração: (A) o tokenizador VQ residual multiscale converge geometricamente sob codebooks ortonormais (contração (1−1/K) por nível; caso particular da restrição Stiefel/RCO já provada no KHTST), e o nested dropout torna todo prefixo de níveis decodificável com risco monótono (refinamento sucessivo); (B) a fatoração next-concept é MLE exato (sem ELBO), com custo de inferência L forward passes, e sua restrição (independência intra-nível) tem gap exatamente igual à correlação total condicional dos códigos, parcialmente recuperada pelos níveis residuais seguintes; (C) em comparação com difusão mascarada: NCM elimina o gap variacional, formaliza a vantagem de planejamento global (teorema condicional de decomposição de consistência), a corrupção de condicionamento é otimização robusta por distribuição contra exposure bias, e MBR com n candidatos tem regret O(n^{−1/2}); (D) a integração no tronco Mamba-3 5:1 + NoPE é executável (máscara block-causal via NoPE + fluxo causal via Mamba), o condicionamento multimodal é invariante, a autorregulação RM aplica-se por nível, MTP ⊂ NCM, e PCGrad preserva as invariantes com a nova perda.
7
  - **EN**: This memory proves NCM's four theoretical pillars and their integration: (A) the multiscale residual VQ tokenizer contracts geometrically under orthonormal codebooks ((1−1/K) per level — the Stiefel/RCO case already proven in KHTST), and nested dropout makes every level prefix decodable with monotone Bayes risk (successive refinement); (B) the next-concept factorization is exact MLE (no ELBO), costs L forward passes, and its within-level independence gap equals the conditional total correlation, partially recovered by subsequent residual levels; (C) versus masked diffusion: NCM removes the variational gap, formalizes the global-planning advantage (conditional consistency-decomposition theorem), corruption training is DRO against exposure bias, and MBR regret is O(n^{−1/2}); (D) integration into the Mamba-3 5:1 + NoPE trunk is constructive, multimodal conditioning is invariant, per-level RM self-regulation applies, MTP ⊂ NCM, and PCGrad invariants survive the new loss.
 
2
  > **Coleção**: `memoria-ncm-khtst` · **Pré-requisitos**: n-00, n-01 · **Convenção**: teoremas `Teo X.n`, provas terminam com `∎`
3
  > **Status**: teoria pura — independente de implementação. Os Teos A–D alimentam o doc `36-ncm-conceitos-hierarquia.md` do KHTST (ver n-04 §6).
4
 
5
+
6
+ > **ERRATA v0.11 (r-35/r-38)** — os teoremas A.1, B.1 e C.3 desta memória
7
+ > foram COMPLEMENTADOS/corrigidos com provas completas em
8
+ > `memoria-khtst-rust/r-38-provas-ncm-v011.md`: (a) A.1 (contração
9
+ > geométrica) vale como cota worst-case com codebook ortonormal e escala
10
+ > ÓTIMA ponto a ponto R*=M — a escala EMA global é conservadora e a cota
11
+ > composta precisa da energia fora do span (generalização tight-frame com
12
+ > Welch incluída); (b) B.1: o gap da predição paralela intra-nível é
13
+ > EXATAMENTE TC(c_ℓ|c_{<ℓ}) ≥ 0 (identidade, não aproximação); (c) C.3
14
+ > formalizada como TV-DRO: sup_{TV(Q,P)≤ε} E_Q[L] = (1−ε)E_P[L]+ε·L_max —
15
+ > a corrupção uniforme é um LOWER bound do risco robusto. Telemetria nova
16
+ > no quantizador: ρ (resíduo STE), contração medida/ótima/cota, MI lag-1.
17
+
18
  **RESUMO BILÍNGUE / BILINGUAL ABSTRACT**
19
  - **PT-BR**: Esta memória prova os quatro pilares teóricos do NCM e de sua integração: (A) o tokenizador VQ residual multiscale converge geometricamente sob codebooks ortonormais (contração (1−1/K) por nível; caso particular da restrição Stiefel/RCO já provada no KHTST), e o nested dropout torna todo prefixo de níveis decodificável com risco monótono (refinamento sucessivo); (B) a fatoração next-concept é MLE exato (sem ELBO), com custo de inferência L forward passes, e sua restrição (independência intra-nível) tem gap exatamente igual à correlação total condicional dos códigos, parcialmente recuperada pelos níveis residuais seguintes; (C) em comparação com difusão mascarada: NCM elimina o gap variacional, formaliza a vantagem de planejamento global (teorema condicional de decomposição de consistência), a corrupção de condicionamento é otimização robusta por distribuição contra exposure bias, e MBR com n candidatos tem regret O(n^{−1/2}); (D) a integração no tronco Mamba-3 5:1 + NoPE é executável (máscara block-causal via NoPE + fluxo causal via Mamba), o condicionamento multimodal é invariante, a autorregulação RM aplica-se por nível, MTP ⊂ NCM, e PCGrad preserva as invariantes com a nova perda.
20
  - **EN**: This memory proves NCM's four theoretical pillars and their integration: (A) the multiscale residual VQ tokenizer contracts geometrically under orthonormal codebooks ((1−1/K) per level — the Stiefel/RCO case already proven in KHTST), and nested dropout makes every level prefix decodable with monotone Bayes risk (successive refinement); (B) the next-concept factorization is exact MLE (no ELBO), costs L forward passes, and its within-level independence gap equals the conditional total correlation, partially recovered by subsequent residual levels; (C) versus masked diffusion: NCM removes the variational gap, formalizes the global-planning advantage (conditional consistency-decomposition theorem), corruption training is DRO against exposure bias, and MBR regret is O(n^{−1/2}); (D) integration into the Mamba-3 5:1 + NoPE trunk is constructive, multimodal conditioning is invariant, per-level RM self-regulation applies, MTP ⊂ NCM, and PCGrad invariants survive the new loss.
docs/memorias/r-19-provas-som-v050.md CHANGED
@@ -1,6 +1,16 @@
1
  # r-19 — PROVAS DA SUÍTE SOM v0.5.0 (4D-SOM, T-SOM, GNG, H-SOM)
2
 
3
- > ⚠️ **ERRATA/SUPERSEDE — r-36 (v0.11):** S4-1 e T-1 nesta memória estão REFOULADOS: S4-1 confundia a energia Φ (‖·‖²) com a QE (‖·‖) — o contraexemplo {0,10} da crítica DeepSeek refuta a forma original (reproduzido no teste s41_contraexemplo); T-1 omitia o termo δ/η do rastreio. Ver S4-1′, S4-2 (Weiszfeld), T-1′ e H-1′ em r-36.
 
 
 
 
 
 
 
 
 
 
4
 
5
  > **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas
6
  > e computacionais da suíte SOM 4D · **Código**: `src/som4d.rs` ·
 
1
  # r-19 — PROVAS DA SUÍTE SOM v0.5.0 (4D-SOM, T-SOM, GNG, H-SOM)
2
 
3
+
4
+ > **ERRATA v0.11 (r-35/r-36)** — os teoremas S4-1 e T-1 desta memória foram
5
+ > REFUTADOS/REAPERTADOS pelo lote DeepSeek e corrigidos com prova completa em
6
+ > `r-36-provas-som-v011.md`: (a) S4-1 "QE não-crescente no modo lote" é FALSO
7
+ > no regime com vizinhança (contraexemplo exato QE 1→5 e EQM 1→25 com σ→∞;
8
+ > apenas E_σ é monotona — S4-1′); a garantia EQM vale só na atribuição DURA;
9
+ > a correção com mediana geométrica de Weiszfeld (S4-2) restaura a monotonia
10
+ > da QE e está IMPLEMENTADA (`CriterioPrototipo4D::MedianaDura`). (b) T-1
11
+ > ignora o fator 1/η — cota correta δγ/(1−γ)+δ(1−η)/η (T-1′, verificada
12
+ > bit-a-bit). (c) H-1(b) tem cota mais justa (Minkowski) e H-1(c) virou
13
+ > TEOREMA com `pin_slot0` (H-1′). Os demais teoremas (G-1, S-2..) permanecem.
14
 
15
  > **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas
16
  > e computacionais da suíte SOM 4D · **Código**: `src/som4d.rs` ·
docs/memorias/r-20-provas-jepa-v050.md CHANGED
@@ -1,6 +1,16 @@
1
  # r-20 — PROVAS DA SUÍTE JEPA v0.5.0 (núcleo + 10 variantes + SonicMoE + ReplaySSM)
2
 
3
- > ⚠️ **ERRATA/SUPERSEDE — r-37 (v0.11):** J-1 desta memória é INVÁLIDO no ponto crítico: o kink é da RAIZ (std=√var em var=0), não da dobradiça; no colapso exato o autodiff produz NaN (0·∞) e a análise correta é por derivada direcional (sela instável). Ver J-1′ e J-3′ em r-37.
 
 
 
 
 
 
 
 
 
 
4
 
5
  > **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas
6
  > e computacionais da suíte JEPA · **Código**: `src/jepa.rs` · **Data**:
 
1
  # r-20 — PROVAS DA SUÍTE JEPA v0.5.0 (núcleo + 10 variantes + SonicMoE + ReplaySSM)
2
 
3
+
4
+ > **ERRATA v0.11 (r-35/r-37)** — J-1 desta memória tem o defeito NUMÉRICO
5
+ > identificado pelo lote DeepSeek: std=√var não é diferenciável em var=0 (o
6
+ > autodiff produz NaN no colapso exato) e a alegação "gradiente de V não-nulo
7
+ > no colapso" é FALSA em θ (var é estacionária em z=c — medido 5,9e-14).
8
+ > A análise CORRETA (r-37 J-1′): o colapso é MÁXIMO LOCAL estrito de V em
9
+ > toda direção de espalhamento — sela instável; a correção implementável
10
+ > C^∞ é `softplus(k(γ−√(var+ε)))²` com ε>0 (J-1′ a/b/c, testes j1c/j1d/j1e).
11
+ > J-3 é EXATA como identidade L² (J-3′). BUG v011-1 (nosso): a covariância
12
+ > do `perda_vc` penalizava a DIAGONAL desde a v0.5.0 — corrigida para a
13
+ > fora-diagonal (VICReg real). J-2 e demais permanecem válidos.
14
 
15
  > **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas
16
  > e computacionais da suíte JEPA · **Código**: `src/jepa.rs` · **Data**:
docs/memorias/r-21-provas-pensamento-v050.md CHANGED
@@ -1,6 +1,16 @@
1
  # r-21 — PROVAS DA TECNOLOGIA PENSAMENTO v0.5.0
2
 
3
- > ⚠️ **ERRATA/SUPERSEDE — r-39 (v0.11):** T-P5 (cota heurística) foi SUBSTITUÍDA pela identidade exata Δy = π(ȳ_e − y_base) (erro 1,1e-16) com cota m_extra a priori — a fórmula proposta pela crítica (‖q‖·K·V/√d) é inválida (refutada no teste tp5_formula_deepseek_invalida); T-P6 foi re-escrita (r-24 já cobria treino conjunto). Ver T-P5′/T-P6′ em r-39.
 
 
 
 
 
 
 
 
 
 
4
 
5
  > **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas
6
  > e computacionais da tecnologia Pensamento (N-redes paralelas cooperativas
 
1
  # r-21 — PROVAS DA TECNOLOGIA PENSAMENTO v0.5.0
2
 
3
+
4
+ > **ERRATA v0.11 (r-35/r-39)** — refinamentos: (a) T-P1 ganhou a filtração
5
+ > EXPLÍCITA 𝓕_k = σ(z, cond, ξ, avaliações) — a causalidade é formal, não
6
+ > conceitual (teste tp1_causalidade_gatilho bit-a-bit); (b) T-P5: a cota
7
+ > heurística de Lipschitz foi SUPERADA pela IDENTIDADE EXATA
8
+ > Δy = π(ȳ_e − y_base) com π = Z_e/(Z_b+Z_e) (erro 1,1e-16 — T-P5′/RE-1);
9
+ > (c) T-P2: os pesos de coerência dependem dos candidatos — a garantia
10
+ > exata vale com pesos PREVISÍVEIS (Hedge, RE-6); (d) T-P6 re-enunciado: a
11
+ > fatoração por regra da cadeia NUNCA quebra; o que o treino conjunto pode
12
+ > degradar é o gap TC e a CALIBRAÇÃO do verificador (recalibrar T* após
13
+ > fine-tune — condição explícita). T-P3/T-P4/T-P7 permanecem como provados.
14
 
15
  > **Coleção**: `memoria-khtst-rust` · **Objeto**: provas matemáticas, lógicas
16
  > e computacionais da tecnologia Pensamento (N-redes paralelas cooperativas
docs/memorias/r-23-provas-verificador-ncm-v060.md CHANGED
@@ -1,7 +1,5 @@
1
  # r-23 — PROVAS DO VERIFICADOR NCM v0.6.0 (substitui o oráculo — r-21 §3.1 fechado)
2
 
3
- > ⚠️ **ERRATA/SUPERSEDE — r-40 (v0.11):** V-2 desta memória só vale com ECE medido NO CONJUNTO ACEITO; com ECE global o correto é P(erro|A) ≤ 1−τ_c + L₁/p_a (contraexemplo reproduzido no teste v2_linha: 0,2125 > 0,1173). Ver V-2′ em r-40 (relatorio_soundness com ece_aceito).
4
-
5
  ## 0. O QUE É PROVADO
6
 
7
  O verificador de produção do Pensamento é a **confiança calibrada do próprio
 
1
  # r-23 — PROVAS DO VERIFICADOR NCM v0.6.0 (substitui o oráculo — r-21 §3.1 fechado)
2
 
 
 
3
  ## 0. O QUE É PROVADO
4
 
5
  O verificador de produção do Pensamento é a **confiança calibrada do próprio
docs/memorias/r-25-provas-moe-redirecionavel-v060.md CHANGED
@@ -1,7 +1,4 @@
1
  # r-25 — PROVAS DOS MoEs REDIRECIONÁVEIS COM ATENÇÃO PRÓPRIA v0.6.0
2
-
3
- > ⚠️ **ERRATA/SUPERSEDE — r-41 (v0.11):** M-R5 desta memória usava arredondar+reparar — NÃO ótimo inteiro (contraexemplo: −4,2% de custo). Substituído pelo guloso marginal ótimo (argumento de troca, M-R5′) com o antigo mantido como oráculo degradado. Ver também errata da constante (31,794) em r-41.
4
-
5
  ("MoEs codificação/decodificação redirecionáveis com Mecanismo de Atenção
6
  próprio independente (paralelos) para as variantes anteriores JEPA e
7
  Kohonen SOM" — pedido do usuário)
 
1
  # r-25 — PROVAS DOS MoEs REDIRECIONÁVEIS COM ATENÇÃO PRÓPRIA v0.6.0
 
 
 
2
  ("MoEs codificação/decodificação redirecionáveis com Mecanismo de Atenção
3
  próprio independente (paralelos) para as variantes anteriores JEPA e
4
  Kohonen SOM" — pedido do usuário)
docs/memorias/r-35-analise-criticas-deepseek-v011.md ADDED
@@ -0,0 +1,88 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # r-35 — ANÁLISE DO LOTE DE CRÍTICAS DEEPSEEK (v0.11)
2
+ ## objetos: upload/{analise-critica-jepa,analise-critica-ncm,analise-critica-pensamento,analise-critica-som,aprimoramentos-arquitetura}.md
3
+ ## método: verificar ANTES de codar → aceitar com prova → refutar com prova → corrigir com errata
4
+
5
+ ## 0. Contexto e triagem
6
+
7
+ Terceiro lote de críticas externas recebido (os anteriores — Qwen3.8, lotes 1 e 2 —
8
+ estão em r-33/r-34). Este lote ataca as PROVAS das suítes v0.5.0 (r-19/r-20/r-21)
9
+ e do verificador/MoE (r-23/r-25). Cada alegação foi verificada contra o código
10
+ REAL do repo antes de qualquer mudança (lição r-34 §0: a crítica pode estar
11
+ desalinhada do código). Resultado da triagem:
12
+
13
+ | Alegação | Veredito | Destino |
14
+ |---|---|---|
15
+ | J-1: prova anti-colapso falha por kink em std=0 | PARCIAL — 3 imprecisões na própria crítica; o defeito real é sqrt′(0)=∞ em var (numérico), não a dobradiça | r-37 J-1′ |
16
+ | J-2 (EMA stop-grad) | CORRETA (já provada) | mantida |
17
+ | J-3 (capacidade finita do preditor) | CORRETA como identidade; a decomposição é EXATA | r-37 J-3′ |
18
+ | A.0 (viés STE) | CORRETA na forma; quantificação adicionada | r-38 A.0′ |
19
+ | A.1 (contração worst-case) | CORRETA; generalização de frame adicionada | r-38 A.1′ |
20
+ | A.2 (nested dropout) | CORRETA | mantida |
21
+ | B.1 (gap = TC) | CORRETA — identidade exata provada | r-38 B.1 |
22
+ | C.3 (DRO) | PLAUSSÍVEL mas informal | r-38 C.3′ (TV-DRO formal) |
23
+ | T-P1 (filtração) | CORRETA na lacuna (conceitual) | r-39 T-P1′ |
24
+ | T-P2/T-P3/T-P4/T-P7 | CORRETAS | mantidas |
25
+ | T-P5 (Lipschitz não explícita) | SUPERADA — existe identidade EXATA melhor que qualquer cota | r-39 T-P5′ |
26
+ | T-P6 (separação de perdas) | REENUNCIADA honesta (regra da cadeia nunca quebra) | r-39 T-P6′ |
27
+ | S4-1 (QE não-crescente) | REFUTADA NO ENUNCIADO e a correção proposta ("reformular p/ EQM") TAMBÉM é insuficiente — contraexemplo derruba QE e EQM no regime suave | r-36 S4-1′ |
28
+ | T-1 (cota de rastreio) | CORRETA na lacuna (falta δ/η); nossa cota nova é MAIS APERTADA que a da crítica | r-36 T-1′ |
29
+ | G-1 (inserção GNG) | CORRETA | mantida |
30
+ | H-1(b) cota frouxa | CORRETA — cota Minkowski mais justa | r-36 H-1′ |
31
+ | H-1(c) empírica | CORRETA — vira TEOREMA com pin slot 0 | r-36 H-1′ |
32
+ | "adicionar teste de falsificação de diferenciabilidade" | ACEITA | r-37 j1c/j1d/j1e |
33
+ | "criterio_qe no som4d" | ACEITA COM CORREÇÃO (mediana geométrica, não só trocar métrica) | r-36 S4-2 |
34
+ | "bisseção testada nos extremos" | JÁ COBERTO (n4b) | mantida |
35
+ | M-R5 arredondar não ótimo | CORRETA (contraexemplo −4,3%) | r-41 M-R5′ |
36
+ | F-10 Newton-Schulz condição espectral | AUDITADA — o escalonamento α=1/(1+‖B‖²_F) JÁ dá ρ(E₀)<1; prova explícita adicionada | r-41 F-10′ |
37
+
38
+ ## 1. Erratas DA PRÓPRIA CRÍTICA (verificadas)
39
+
40
+ 1. **"convexidade de ‖·‖² não implica convexidade de ‖·‖" é FALSA** — a norma É
41
+ convexa (desigualdade triangular). A lacuna real da prova r-19 era outra: a
42
+ MÉDIA não minimiza Σ‖xᵢ−p‖ (minimiza Σ‖xᵢ−p‖²). A crítica acertou o alvo
43
+ (a prova estava errada) com a arma errada (a justificativa).
44
+ 2. **J-1 da crítica**: (i) f(s)=max(0,γ−s)² é C¹ em s (o kink é de f″); (ii) o
45
+ problema real é std=√var não-diferenciável em var=0; (iii) "gradiente não-nulo
46
+ no colapso mesmo com softplus" é FALSO — var é estacionária em z=c
47
+ (∂var/∂z=0; medido |grad|=5,9e-14). E a correção proposta ESQUECE o ε:
48
+ softplus(k(γ−√var)) AINDA quebra em var=0.
49
+ 3. **T-1 da crítica**: a cota δγ/(1−γ)+δ/η é VÁLIDA mas frouxa — a apertada é
50
+ δγ/(1−γ)+δ(1−η)/η (verificada bit-a-bit: 0,3600 medido = 0,3600 teórico).
51
+ 4. **V-2 da crítica** (implícita no aprimoramentos-arquitetura §3): a cota
52
+ "1−τ_c+ECE" com ECE GLOBAL não vale — exige ECE no conjunto ACEITO (r-40).
53
+
54
+ ## 2. O que o lote pediu e o que foi ENTREGUE (código + teste)
55
+
56
+ | Pedido | Entregue |
57
+ |---|---|
58
+ | VC suavizado C^∞ em jepa.rs | `ativar_vc_suave(k, ε)` + perda_vc com softplus(k(γ−√(var+ε)))² — j1c/j1d/j1e |
59
+ | Mediana geométrica / EQM | `mediana_geometrica` (Weiszfeld MM) + `CriterioPrototipo4D::MedianaDura` — QE monotona TESTADA |
60
+ | Métrica correta monitorada | telemetria `historia_eqm`, `eqm_final`, `e_sigma_final` (σ congelado) |
61
+ | Cota T-1 com 1/η | comentário corrigido + teste `t1_cota_apertada` |
62
+ | H-1(c) teorema | `pin_slot0` (3 linhas) + teste `h1_pin_slot0_teorico` |
63
+ | Filtração formal | T-P1′ com teste `tp1_causalidade_gatilho` (bit-a-bit) |
64
+ | Lipschitz explícita do gate | T-P5′ IDENTIDADE EXATA Δy=π(ȳ_e−y_base) (melhor que cota) — re1 |
65
+ | TC penalty / documentar | telemetria MI lag-1 (proxy honesta) + identidade provada |
66
+ | C.3 formal | TV-DRO com prova (sup TV = mistura com ponto de perda máxima) |
67
+ | M-R5 guloso | `alocar_por_qe` guloso marginal (ótimo inteiro provado) + força bruta |
68
+ | F-10 spectral | prova ρ(E₀)≤1��α<1 com escalonamento de Frobenius + f10b quadrático |
69
+
70
+ ## 3. O que o lote NÃO pediu e foi encontrado (autocrítica adicional)
71
+
72
+ 1. **BUG v011-1 (nosso, pré-existente desde v0.5.0)**: a máscara de covariância
73
+ do `perda_vc` marcava a DIAGONAL (penalizava var_i² — OPOSTO à dobradiça)
74
+ em vez da fora-diagonal (decorrelação VICReg prometida no comentário).
75
+ Corrigido + teste `j1f_cov_fora_diagonal`.
76
+ 2. **Comentário trocado** no teste v2 do verificador ("aceitar ~80%" — na
77
+ verdade ~20% para ε=0,2). Errata r-40/V-3.
78
+ 3. **Cota H-1(b)** frouxa (2R) — substituída pela Minkowski apertada.
79
+
80
+ ## 4. Limitações honestas desta análise
81
+
82
+ 1. O estimador de TC por discriminador de permutações NÃO foi implementado
83
+ (variância alta, custo alto — r-38 limitação 2); a MI lag-1 é proxy.
84
+ 2. A crítica de JEPA sobre "P com capacidade controlada" resultou apenas na
85
+ RECOMENDAÇÃO de reportar o gap de aproximação (J-3′ corolário) — sem
86
+ regularizador novo no treino.
87
+ 3. Gumbel-Softmax permanece ADIADO (herança r-34 §12 — blast radius; o GSQ
88
+ exato com recomputação de ruído já cobre o gradiente do relaxamento).
docs/memorias/r-37-provas-jepa-v011.md CHANGED
@@ -1,4 +1,4 @@
1
- # r-37 — PROVAS JEPA CORRIGIDAS (v0.11) · objeto: src/jepa/nucleo.rs (perda_vc)
2
 
3
  ## J-1′ (anti-colapso — análise CORRETA do ponto crítico)
4
 
 
1
+ # r-37 — PROVAS JEPA CORRIGIDAS (v0.11) · objeto: src/jepa.rs (perda_vc)
2
 
3
  ## J-1′ (anti-colapso — análise CORRETA do ponto crítico)
4
 
docs/memorias/r-41-provas-moe-fnh-v011.md CHANGED
@@ -21,13 +21,6 @@ A seleção discreta é constante no grafo (argmax não-diferenciável — padr
21
  Switch); f constante, p̄ vivo na aux. O caminho DEPRECIADO (to_vec2/from_vec)
22
  secciona o grafo — mantido só como oráculo de teste. ∎
23
 
24
-
25
- > **ERRATA v0.11.0 (verificação exaustiva):** o custo do guloso no
26
- > contraexemplo é **31,79418** (c=[2,3,2,1,5]), não 31,787 como escrito
27
- > abaixo; o arredondar custa 33,195 (perda de 4,2%). A alocação e a
28
- > otimalidade do guloso CONFEREM (guloso == força bruta, teste
29
- > `m_r5_guloso_vs_forca_bruta`); apenas a constante tinha dígito errado.
30
-
31
  ## M-R5′ (water-filling INTEIRO — ótimo por guloso marginal; errata do arredondar)
32
  **Teorema.** min Σ qᵢ²/cᵢ s.a. Σcᵢ=C, cᵢ∈ℕ₊. (a) Relaxado: Cauchy–Schwarz
33
  (Σqᵢ)² = (Σ(qᵢ/√cᵢ)√cᵢ)² ≤ (Σqᵢ²/cᵢ)·C ⇒ mínimo (Σq)²/C em cᵢ ∝ qᵢ. ∎
 
21
  Switch); f constante, p̄ vivo na aux. O caminho DEPRECIADO (to_vec2/from_vec)
22
  secciona o grafo — mantido só como oráculo de teste. ∎
23
 
 
 
 
 
 
 
 
24
  ## M-R5′ (water-filling INTEIRO — ótimo por guloso marginal; errata do arredondar)
25
  **Teorema.** min Σ qᵢ²/cᵢ s.a. Σcᵢ=C, cᵢ∈ℕ₊. (a) Relaxado: Cauchy–Schwarz
26
  (Σqᵢ)² = (Σ(qᵢ/√cᵢ)√cᵢ)² ≤ (Σqᵢ²/cᵢ)·C ⇒ mínimo (Σq)²/C em cᵢ ∝ qᵢ. ∎
docs/memorias/r-43-resultados-v011.md ADDED
@@ -0,0 +1,106 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # r-43 — RESULTADOS v0.11: IMPLEMENTAÇÃO, MEDIÇÕES E AUTOCRÍTICA
2
+ ## objetos: asm_x86.rs (NOVO), pensamento/raciocinio_elastico.rs, som4d.rs, jepa.rs, quantizador.rs, verificador.rs, moe_redirecionavel.rs, lib.rs (0 unwraps), scripts 73/74/75
3
+
4
+ ## 0. Escopo entregue (tudo com prova em r-35..r-42 + testes de falsificação)
5
+
6
+ 1. **Raciocínio elástico sobre RESÍDUOS DE QUANTIZAÇÃO (tarefa REAL)** —
7
+ `raciocinio_elastico_residuos` (lib.rs): latentes reais do tokenizador
8
+ (Wikipédia PT-BR) → quantizador NCM (Stiefel K=16, escala EMA) → resíduos
9
+ ρ=z−r_h → MotorPensamento corretor (cond=r_h → alvo=z) + verificador
10
+ cabeça-que-prevê-o-código calibrado (V-1/V-2′) + massas de atenção REAIS
11
+ (q=latente, k_base=codebook) + certificados RE-2 com rollback defensivo.
12
+ 2. **Assembly AVX-512 integrado a Rust** (`asm_x86.rs`, `global_asm!`):
13
+ kernel AdamW (blocos de 16, sem FMA, NaN por máscara K→EAX) e kernel de
14
+ recorrência SSM (scan de inferência fundido). Tratamento de erros por
15
+ FLAGS de hardware (tratamento.txt §2): convenções documentadas (SysV,
16
+ clobbers, código de retorno); mapeadas em Result/telemetria no Rust.
17
+ 3. **Semeadura total**: `SonicMoe::novo_com_semente`, `ReplaySsm::
18
+ novo_com_semente`, `MotorPensamento::novo_com_semente` — débito r-34 §12
19
+ QUITADO (determinismo bit-a-bit testado).
20
+ 4. **Migração TOTAL dos unwraps do lib.rs**: 59 linhas → 0 (trait `PropPy`
21
+ `.p()?` — postfix, órfão impede From; fallbacks EXPLÍCITOS em closures).
22
+ 5. **Provas corrigidas do lote DeepSeek** (r-35..r-42) com 15 testes novos
23
+ de falsificação (s41/s42/t1/h1/j1c-j1f/j3/a0/a1/b1/v2b/tp1/mr5/f10b).
24
+
25
+ ## 1. Medições honestas (dados reais: Wikipédia PT-BR 273 artigos, 1121 janelas ctx 256)
26
+
27
+ | Mecanismo | Medida | Valor |
28
+ |---|---|---|
29
+ | Elástico real (24 consultas retidas) | conf média | **0,8804** |
30
+ | | aceites ≥ τ_c=0,55 | **24/24** |
31
+ | | violações H1 / rollbacks | **0 / 0** |
32
+ | | certificados NÃO-TRIVIAIS (g=0,25) | 2 (bound 0,30/0,38 vs Δ 0,0077/0,0004 — margem 39–950×) |
33
+ | | gate calibrado por grade (treino) | 1,0 (curva: g=0→0,596 … g=1→0,65) |
34
+ | | braço ablação g=0,25 | conf 0,9114 > calibrado 0,8495 (ênfase do banco AJUDA) |
35
+ | SOM MedianaDura (Weiszfeld S4-2) | QE final (latentes reais, PCA-4D) | **0,0447 vs 0,0825 (−46%)** |
36
+ | | monotonia QE por época | **bit-a-bit verdadeira** |
37
+ | H-SOM pin_slot0 (H-1′c) | EQ_hier ≤ EQ_grosso | **0,0008 ≤ 0,0075 ✓ (teorema)** |
38
+ | JEPA-T real | queda preditiva adaptativa vs fixa | **43,5% vs 41,9%** |
39
+ | GNG real (entropia+piso) | vértices / EQ | 46 vs 48 / 0,2138 vs 0,2120 (regulador de orçamento) |
40
+ | Fase A (tokenizador, 400s) | perda 9,95→8,68; perplexidade codebook 52,4 | aprendizado real |
41
+ | Fase B (gerador, 214s) | perda 4,21→4,02; acc conceitos 0,102 | aprendizado real |
42
+ | Fase C (conjunto, 120 passos) | CE 3,9197→3,8985 (queda 2,45× a da v0.9.0) | ECE 0,015→0,0029 |
43
+
44
+ ## 2. Bench Assembly (bench_v011, mediana de 21 repetições)
45
+
46
+ | Kernel | Escalar | Assembly | Razão | Nota |
47
+ |---|---|---|---|---|
48
+ | AdamW (2M floats) | 2,18 ms | 2,09 ms | **1,04×** | memory-bound (roofline r-34 §6.2 — 40 MB/passo); o teto é a banda, não o SIMD |
49
+ | Scan SSM (T=512, d=64) | 0,779 ms (candle) | **0,061 ms** | **12,7×** | o ganho NÃO é SIMD: é a FUSÃO (1 despacho vs ~5·T ops de tensor) |
50
+
51
+ Bit-identidade: `adamw_bit_identico=true`, `ssm_bit_identico=true` (to_bits).
52
+ NaN por máscara: detectado e mapeado (Err no scan; telemetria no adamw — o
53
+ passo de treino tem guarda própria; abortar mudaria semântica).
54
+
55
+ ## 3. Autocrítica — bugs MEUS catalogados nesta versão
56
+
57
+ - **v011-1 (pré-existente v0.5.0, achado AUDITANDO a crítica J-1)**: máscara
58
+ de covariância do `perda_vc` marcava a DIAGONAL (penalizava var², opondo-se
59
+ à dobradiça anti-colapso) — o comentário prometia ‖C−diag‖²_F. Corrigido
60
+ para a fora-diagonal (decorrelação VICReg real) + teste j1f. MUDA resultados
61
+ de treino JEPA (a suíte v0.11 remedeia; a v0.5.0 media com o bug).
62
+ - **v011-2 (design do certificado RE-2)**: a integração ingênua do r-42
63
+ misturava massas de ATENÇÃO no orçamento com agregação por HEDGE não-gateada
64
+ — o bound era INVÁLIDO (24/24 rollbacks com bound=0 e Δconf=0,16 — medido
65
+ nos dados reais, não em simulação). Correção com prova: agregação GATEADA
66
+ `resposta = y_base + g·(media_hedge − y_base)`, orçamento sobre massa HEDGE
67
+ com teto w_R≤½, bound `4|g|V_max·L_conf·w_R` (o fator 2 absorve 1/(1−w_R));
68
+ a resposta comprimida recomputa SÓ o termo gateado. Resultado: 0 violações,
69
+ 0 rollbacks, certificados não-triviais com Δ ≪ bound.
70
+ - **v011-3 (Assembly)**: `kmovd eax, k1` CLOBBERAVA rax (contador de blocos
71
+ do AdamW) → loop terminava após 1 bloco; e `kmovd eax` no scan clobberava
72
+ a base de linha. Corrigido (r10d no adamw; rbx dedicado no scan). Um
73
+ segfault intermitente no binário de teste PRÉ-correção está no dmesg —
74
+ post-correção: 3× execuções consecutivas 4/4 verdes, bit-a-bit estável.
75
+ - **v011-4 (falso positivo de teste)**: o teste `adamw_asm_bit_a_bit` com
76
+ n=4096 exigia decréscimo estrito do resíduo Newton abaixo de 1e-5 — piso
77
+ de ruído de f32 (1,0661e-7 vs 1,0625e-7). Piso documentado e aplicado.
78
+ - **v011-5**: `ShapeWithOneElement` não existe em candle 0.11 (o upload usava
79
+ a API errada — `ShapeWithOneHole`); `DResult` idem (→ `Result`).
80
+ - **v011-6**: primeiro desenho do `j1e_gap` usava colunas IDÊNTICAS (cov=1
81
+ polluía o gap) — corrigido com colunas de Hadamard-Walsh (ortogonais exatas).
82
+ - **v011-7**: proxy de dependência por correlação de one-hots era ESTRUTURAL-
83
+ mente quebrado (cov(o_i,o_j)=−p_ip_j SEMPRE pela exclusão mútua — piso
84
+ 1/(k−1) inerente). Substituído por MI lag-1 plug-in com viés documentado.
85
+
86
+ ## 4. Veredito consolidado (script 74)
87
+
88
+ **134/134 gates** — legado v0.9.0 104/104 preservado; elástico real 5/5;
89
+ SOM r-36 2/2; H-SOM 1/1; Assembly 4/4; cargo **137/137** (3× consecutivas);
90
+ unwraps 59/59 migrados. Fase C melhora 2,45× a queda de CE da v0.9.0.
91
+
92
+ ## 5. Débitos honestos remanescentes
93
+
94
+ 1. **Contração medida > 1 nos latentes reais** (1,26 com escala EMA): a escala
95
+ EMA global é conservadora ponto a ponto (a ótima com R*=M dá 0,94 ≤ cota
96
+ 0,9375+ε de ortogonalidade Stiefel). Reportar AMBAS é o correto; uma
97
+ extensão natural é escala por amostra (custo: quebra o lote).
98
+ 2. O estimador TC por discriminador segue não-implementado (r-35 §4.1).
99
+ 3. Gumbel-Softmax adiado (herança r-34 §12).
100
+ 4. `demo_pensamento_ncm` e correlatos ainda usam dados SINTÉTICOS internos
101
+ (o caminho REAL é o `raciocinio_elastico_residuos`/`quebra_cabeca_real`).
102
+ 5. Checkpoints JSON com pico de RAM no parse (migração safetensors pendente —
103
+ herança r-34 §12).
104
+ 6. O gate calibrado variou entre execuções (0,0 numa, 1,0 noutra — a curva é
105
+ rasa: 0,44–0,65); a ABLAÇÃO g=0,25 ganhou em conf de held-out — um
106
+ calibrador em held-out (não treino) é a extensão natural.
resultados/bench_v011.json ADDED
@@ -0,0 +1,22 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "adamw_asm_direto_ms": 2.320801,
3
+ "adamw_asm_ms": 2.3195099999999997,
4
+ "adamw_bit_identico": true,
5
+ "adamw_escalar_ms": 2.272675,
6
+ "adamw_speedup_asm": 0.9798082353600546,
7
+ "asm_versao": "asm-x86-0.11.0",
8
+ "avx512_disponivel": true,
9
+ "cpus": 2,
10
+ "despacho": {
11
+ "avx512_disponivel": true,
12
+ "chamadas_asm": 65,
13
+ "chamadas_fallback": 0,
14
+ "nan_detectados": 0
15
+ },
16
+ "ssm_asm_ms": 0.058075,
17
+ "ssm_bit_identico": true,
18
+ "ssm_candle_ms": 0.731947,
19
+ "ssm_d": 64,
20
+ "ssm_speedup_asm": 12.603478260869565,
21
+ "ssm_t": 512
22
+ }
resultados/suite_v011_final.json CHANGED
@@ -1,73 +1,192 @@
1
  {
2
  "versao": "0.11.0",
3
- "blocos": {},
 
 
 
 
 
 
 
 
4
  "gates": {
5
- "v1_versao_0110": true,
6
- "v1_kernels_asm_registrados": true,
7
- "v1_binding_v2_soundness": true,
8
- "v1_binding_elastico": true,
9
- "v2_sha256_confere_hashlib": true,
10
- "v2_checkpoint_manifesto_presente": true,
11
- "v2_checkpoint_valido": true,
12
- "v2_checkpoint_corrupcao_detectada": true,
13
- "v2_carregar_retrocompativel": true,
14
- "v3_mr5_guloso_vs_bruto": true,
15
- "v8_cargo_158_mais": true,
16
- "v4_cota_limpa_respeitada": true,
17
- "v4_p_aceite_positiva": true,
18
- "v4_cotas_finitas": true,
19
- "v4_errata_ece_global_e_violavel": true,
20
- "v4_errata_cota_limpa_cobre": true,
21
- "v5_gates_elasticos": true,
22
- "v5_certificados_presentes": true,
23
- "v5_epsilon_seguro_nao_negativo": true,
24
- "v6_pin_eq_hier_le_eq_grosso_exato": true,
25
- "v6_cota_minkowski_pin": true,
26
- "v6_cota_minkowski_sem_pin": true,
27
- "v7_mediana_nao_piora_contraexemplo": true,
28
- "v7_phi_monotono_media": true,
29
- "v7_phi_monotono_mediana": true,
30
- "v8_split_arquivado_documentado": true,
31
- "v8_modulo_checkpoint_presente": true,
32
- "v8_modulo_tipos_presente": true,
33
- "v8_cargo_deterministico": true
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
34
  },
35
  "medicoes": {
36
- "asm_relatorio": "asm-0.11.0 | target x86-64 System V | kernels: soma_u64_cheia (add/jc, CF), primeiro_nan_f64 (ucomisd/jp, PF), primeiro_nan_f32 (ucomiss/jp, PF) | protocolo: código em registrador -> Result (tratamento.txt §1+§2)",
37
- "cargo_total": 160,
38
- "testes_chave_faltando": [],
39
- "v2_linha": {
40
- "cota_corrigida": 1.404,
41
- "cota_limpa": 0.4645,
42
- "cota_limpa_respeitada": true,
43
- "ece_aceito": 0.1645,
44
- "l1_global": 0.4361,
45
- "n_aceito": 2370,
46
- "p_aceite": 0.395,
47
- "p_erro_aceito": 0.3165,
48
- "tau_c": 0.7
49
  },
50
- "v2_errata": {
51
- "p_erro_aceito": 0.2125,
52
- "cota_antiga_ece_global": 0.1173
 
53
  },
54
- "elastico": {
55
- "confianca_media": 0.6859,
56
- "iteracoes_media": 1.0,
57
- "certificados": 8,
58
- "rollbacks": 0
59
  },
60
- "h1_linha": {
61
- "eq_hier_com_pin": 0.08692,
62
- "eq_grosso_com_pin": 1.44193,
63
- "eq_hier_sem_pin": 0.07905
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
64
  },
65
- "s42": {
66
- "qe_inicial": 5.001,
67
- "qe_media_6ep": 3.9475,
68
- "qe_mediana_6ep": 5.001
69
- }
70
  },
71
- "veredito": "29/29",
72
- "ok": true
73
  }
 
1
  {
2
  "versao": "0.11.0",
3
+ "blocos": {
4
+ "legado_v090": "104/104",
5
+ "v1_elastico_real": "5/5",
6
+ "v2_som_r36": "2/2",
7
+ "v3_hsom_r36": "1/1",
8
+ "v4_assembly": "4/4",
9
+ "cargo": "137/137",
10
+ "v6_unwraps": "59/59"
11
+ },
12
  "gates": {
13
+ "legado_legado_legado_legado_calibracao_soundness.v1_calibracao": true,
14
+ "legado_legado_legado_legado_calibracao_soundness.v2_soundness": true,
15
+ "legado_legado_legado_legado_calibracao_soundness.v3_tau_positivo": true,
16
+ "legado_legado_legado_legado_ciclo_d_sem_oraculo.aprendeu": true,
17
+ "legado_legado_legado_legado_ciclo_d_sem_oraculo.terminou": true,
18
+ "legado_legado_legado_legado_ciclo_d_sem_oraculo.sem_oraculo": true,
19
+ "legado_legado_legado_legado_ciclo_d_sem_oraculo.calibrado": true,
20
+ "legado_legado_legado_legado_ciclo_d_sem_oraculo.ganho_nao_negativo": true,
21
+ "legado_legado_legado_legado_ciclo_d_sem_oraculo.verificador_sem_oraculo": true,
22
+ "legado_legado_legado_legado_escalonamento_n.tp2_ncm": true,
23
+ "legado_legado_legado_legado_fase_c.verificador_sem_oraculo": true,
24
+ "legado_legado_legado_legado_fase_c.calibracao_nll_otima": true,
25
+ "legado_legado_legado_legado_fase_c.ece_aceitavel_para_soundness": true,
26
+ "legado_legado_legado_legado_fase_c.correcao_ativa": true,
27
+ "legado_legado_legado_legado_fase_c.acoplador_sem_timeout": true,
28
+ "legado_legado_legado_legado_fase_c.acoplador_duplex_ativo": true,
29
+ "legado_legado_legado_legado_fase_c.confianca_pos_nao_inferior": true,
30
+ "legado_legado_legado_legado_fase_c.backbone_preservado": true,
31
+ "legado_legado_legado_legado_fase_c.pcgrad_sem_conflito_observado": true,
32
+ "legado_legado_legado_legado_provas_mr.mr1_capacidade": true,
33
+ "legado_legado_legado_legado_provas_mr.mr1_perda_aux": true,
34
+ "legado_legado_legado_legado_provas_mr.mr2_neutralidade": true,
35
+ "legado_legado_legado_legado_provas_mr.mr3_paralelismo": true,
36
+ "legado_legado_legado_legado_provas_mr.mr5_water_filling": true,
37
+ "legado_legado_legado_legado_jepa_moe.jepa_moe_aprende": true,
38
+ "legado_legado_legado_legado_jepa_moe.jepa_moe_vs_densa": true,
39
+ "legado_legado_legado_legado_jepa_moe.jepa_moe_vs_pequena": true,
40
+ "legado_legado_legado_legado_som_moe.moe_refina": true,
41
+ "legado_legado_legado_legado_som_moe.redirect_decodifica": true,
42
+ "legado_legado_legado_legado_som_moe.wf_melhor_uniforme": true,
43
+ "legado_legado_legado_legado_acoplador_duplo.duplex_simultaneo": true,
44
+ "legado_legado_legado_legado_acoplador_duplo.sem_timeout": true,
45
+ "legado_legado_legado_legado_acoplador_duplo.terminou": true,
46
+ "legado_legado_legado_legado_iter.gate_ucb1_encontrou_moe": true,
47
+ "legado_legado_legado_legado_iter.gate_gap_positivo_vs_baseline": true,
48
+ "legado_legado_legado_legado_iter.gate_arrependimento_pequeno": true,
49
+ "legado_legado_legado_legado_iter.gate_regulacao_ocorreu": true,
50
+ "legado_legado_legado_legado_iter.gate_parada_ou_teto": true,
51
+ "legado_legado_legado_legado_iter.gate_melhor_aprendeu": true,
52
+ "legado_legado_legado_legado_iter.a1_tau_quantil": true,
53
+ "legado_legado_legado_legado_iter.a2_b_finito": true,
54
+ "legado_legado_legado_legado_iter.a3_n_reduzido": true,
55
+ "legado_legado_legado_legado_iter.a4_ucb1_achou": true,
56
+ "legado_legado_legado_legado_iter.a5_gate_subiu": true,
57
+ "legado_legado_legado_legado_legada_suite_v": true,
58
+ "legado_legado_legado_legado_cargo_54": true,
59
+ "legado_legado_legado_fnh_f1_so_n_exato": true,
60
+ "legado_legado_legado_fnh_f3_gate_zona_morta": true,
61
+ "legado_legado_legado_fnh_f3_gate_abre": true,
62
+ "legado_legado_legado_fnh_f4_homeostase_theta_congelado": true,
63
+ "legado_legado_legado_fnh_f4_rotacao_aprende_com_punicao": true,
64
+ "legado_legado_legado_fnh_a2_delta_ort_treino_real": true,
65
+ "legado_legado_legado_fnh_a3_punicao_real_medida": true,
66
+ "legado_legado_legado_arvore_quebra_t1_invariantes": true,
67
+ "legado_legado_legado_arvore_quebra_t2_agregacao_exata": true,
68
+ "legado_legado_legado_arvore_quebra_t3_teto_simetrico": true,
69
+ "legado_legado_legado_arvore_quebra_q1_executa_real": true,
70
+ "legado_legado_legado_arvore_quebra_q2_soundness_aceites": true,
71
+ "legado_legado_legado_arvore_quebra_q3_invariantes_pos_quebra": true,
72
+ "legado_legado_legado_arvore_quebra_q4_punicao_registrada": true,
73
+ "legado_legado_legado_arvore_quebra_q5_sintetico_mistura_aceita_rejeita": true,
74
+ "legado_legado_legado_nlp_nlg_n_coerencia_ok": true,
75
+ "legado_legado_legado_nlp_nlg_n_espec_ok": true,
76
+ "legado_legado_legado_nlp_nlg_n_gate_medio_ok": true,
77
+ "legado_legado_legado_nlp_nlg_n_nlg_neutro": true,
78
+ "legado_legado_legado_nlp_nlg_n_nlp_neutro": true,
79
+ "legado_legado_legado_nlp_nlg_n_ctx_real_bigramas_unicos": true,
80
+ "legado_legado_legado_nlp_nlg_s_piso_ok": true,
81
+ "legado_legado_legado_nlp_nlg_s_qe_sobe": true,
82
+ "legado_legado_legado_nlp_nlg_s_stop_dispara": true,
83
+ "legado_legado_legado_nlp_nlg_s_tetos_ok": true,
84
+ "legado_legado_legado_telemetria_painel_v070": true,
85
+ "legado_legado_legado_treino_real_completo": true,
86
+ "legado_legado_q1_newton_menos_avaliacoes": true,
87
+ "legado_legado_q1_newton_mesmo_t": true,
88
+ "legado_legado_q1_newton_nll_nao_piora": true,
89
+ "legado_legado_q3_cayley_ambos_exatos": true,
90
+ "legado_legado_q3_cayley_cayley_mais_rapido": true,
91
+ "legado_legado_q2_arvore_iguais_bit_a_bit": true,
92
+ "legado_legado_q4_moe_bug_v080_1_confirmado": true,
93
+ "legado_legado_q4_moe_gradiente_restaurado": true,
94
+ "legado_legado_q4_moe_valores_iguais": true,
95
+ "legado_legado_q5_ablacao_moe_aprende_3x": true,
96
+ "legado_legado_q5_ablacao_moe_domina_pequena_3x": true,
97
+ "legado_legado_cargo_todos_verdes": true,
98
+ "legado_c1_cfg_valido_funciona": true,
99
+ "legado_c1_tipo_errado_rejeitado": true,
100
+ "legado_c4_simd_bit_identico": true,
101
+ "legado_c4_avx512_detectado": true,
102
+ "legado_c2_nosso_adamw_nao_pior_candle": true,
103
+ "legado_c4_alinhamento_garantido_64b": true,
104
+ "legado_d3_bf16_nao_e_gratis": true,
105
+ "legado_b3_paisagem_medi_da": true,
106
+ "legado_b3_escalar_argmin_nao_perde": true,
107
+ "legado_c3_numpy_nao_pior": true,
108
+ "legado_b1_gng_piso_insere": true,
109
+ "legado_b1_gng_portao_ativo": true,
110
+ "legado_c_ts_ts_aprende": true,
111
+ "legado_c_ts_ucb1_aprende": true,
112
+ "legado_c_ts_melhor_braço_domina_ts": true,
113
+ "legado_c_jepa_um_braco_bit_a_bit": true,
114
+ "legado_c_jepa_multibraco_explora": true,
115
+ "legado_c_jepa_sem_colapso": true,
116
+ "legado_cargo_todos_verdes": true,
117
+ "v1_gate_aceite_minimo": true,
118
+ "v1_gate_cabeca_aprendeu": true,
119
+ "v1_gate_massas_reais": true,
120
+ "v1_gate_motor_aprendeu": true,
121
+ "v1_gate_respostas_sounds": true,
122
+ "v1_fase_c_melhora": true,
123
+ "v2_qe_mediana_monotono": true,
124
+ "v2_mediana_melhor_que_media": true,
125
+ "v3_h1c_teoroma_pin": true,
126
+ "v4_asm_bit_identico": true,
127
+ "v4_asm_detecta_nan": true,
128
+ "v4_avx512_despacho": true,
129
+ "v4_scan_asm_acelera": true,
130
+ "cargo_todos_verdes": true,
131
+ "v5_prova_s41_contraexemplo_qe_eqm": true,
132
+ "v5_prova_s42_weiszfeld_monotono": true,
133
+ "v5_prova_j1c_suave_c_infinito": true,
134
+ "v5_prova_j1d_colapso_sela": true,
135
+ "v5_prova_j1e_gap": true,
136
+ "v5_prova_t1_cota_apertada": true,
137
+ "v5_prova_h1_pin_slot0_teorico": true,
138
+ "v5_prova_m_r5_guloso_vs_forca_bruta": true,
139
+ "v5_prova_f10b_decaimento_quadratico_residuo": true,
140
+ "v5_prova_v2b_soundness_cotas_corrigidas": true,
141
+ "v5_prova_tp1_causalidade_gatilho": true,
142
+ "v5_prova_adamw_asm_bit_a_bit": true,
143
+ "v5_prova_scan_asm_bit_a_bit": true,
144
+ "v5_prova_sonic_replay_semeados_deterministicos": true,
145
+ "v5_prova_re2_epsilon_seguro": true,
146
+ "v6_lib_sem_unwrap": true
147
  },
148
  "medicoes": {
149
+ "elastico": {
150
+ "conf_media": 0.8804160455862681,
151
+ "aceites": 24,
152
+ "violacoes": 0,
153
+ "rollbacks": 0,
154
+ "gate_calibrado": 1.0,
155
+ "conf_calibrado": 0.8494527637958527,
156
+ "conf_fixo_025": 0.9113793273766836
 
 
 
 
 
157
  },
158
+ "fase_c_queda_ce": {
159
+ "v090": 0.00879812240600586,
160
+ "v011": 0.021464109420776367,
161
+ "razao": 2.4396238686250067
162
  },
163
+ "som": {
164
+ "qe_media_suave": 0.08247831460207208,
165
+ "qe_mediana_dura": 0.04472044865979238
 
 
166
  },
167
+ "bench_v011": {
168
+ "adamw_asm_direto_ms": 2.320801,
169
+ "adamw_asm_ms": 2.3195099999999997,
170
+ "adamw_bit_identico": true,
171
+ "adamw_escalar_ms": 2.272675,
172
+ "adamw_speedup_asm": 0.9798082353600546,
173
+ "asm_versao": "asm-x86-0.11.0",
174
+ "avx512_disponivel": true,
175
+ "cpus": 2,
176
+ "despacho": {
177
+ "avx512_disponivel": true,
178
+ "chamadas_asm": 65,
179
+ "chamadas_fallback": 0,
180
+ "nan_detectados": 0
181
+ },
182
+ "ssm_asm_ms": 0.058075,
183
+ "ssm_bit_identico": true,
184
+ "ssm_candle_ms": 0.731947,
185
+ "ssm_d": 64,
186
+ "ssm_speedup_asm": 12.603478260869565,
187
+ "ssm_t": 512
188
  },
189
+ "unwraps_lib_rs": 0
 
 
 
 
190
  },
191
+ "veredito": "134/134"
 
192
  }
resultados/telemetria_fase_c.jsonl CHANGED
@@ -1,62 +1,105 @@
1
  {"tipo":"ajuste","dados":{"passo":0,"parametro":"fase_c_base","de":0.0,"para":1.0,"motivo":"carregado checkpoint da fase B: /home/z/my-project/khtst-rust/resultados/gerador_conceitos.json (ajuste fino, não do zero)"}}
2
- {"tipo":"ajuste","dados":{"passo":0,"parametro":"pensamento_tau_c","de":0.3,"para":0.023297131061553955,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, calibração inicial fase C)"}}
3
- {"tipo":"ajuste","dados":{"passo":0,"parametro":"pensamento_tau_c","de":0.023297131061553955,"para":0.022317171096801758,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=1024)"}}
4
- {"tipo":"ajuste","dados":{"passo":1,"parametro":"pensamento_tau_c","de":0.022317171096801758,"para":0.02209264039993286,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=2048)"}}
5
- {"tipo":"ajuste","dados":{"passo":2,"parametro":"pensamento_tau_c","de":0.02209264039993286,"para":0.022000014781951904,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=3072)"}}
6
- {"tipo":"ajuste","dados":{"passo":3,"parametro":"pensamento_tau_c","de":0.022000014781951904,"para":0.022239625453948975,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=4096)"}}
7
- {"tipo":"ajuste","dados":{"passo":4,"parametro":"pensamento_tau_c","de":0.022239625453948975,"para":0.022184014320373535,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=5120)"}}
8
- {"tipo":"ajuste","dados":{"passo":5,"parametro":"pensamento_tau_c","de":0.022184014320373535,"para":0.022012710571289062,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=6144)"}}
9
- {"tipo":"ajuste","dados":{"passo":6,"parametro":"pensamento_tau_c","de":0.022012710571289062,"para":0.02229410409927368,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=7168)"}}
10
- {"tipo":"ajuste","dados":{"passo":7,"parametro":"pensamento_tau_c","de":0.02229410409927368,"para":0.022495806217193604,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=8192)"}}
11
- {"tipo":"ajuste","dados":{"passo":8,"parametro":"pensamento_tau_c","de":0.022495806217193604,"para":0.02274608612060547,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=9216)"}}
12
- {"tipo":"ajuste","dados":{"passo":9,"parametro":"pensamento_tau_c","de":0.02274608612060547,"para":0.022810757160186768,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=10240)"}}
13
- {"tipo":"ajuste","dados":{"passo":10,"parametro":"pensamento_tau_c","de":0.022810757160186768,"para":0.022719264030456543,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=11264)"}}
14
- {"tipo":"ajuste","dados":{"passo":11,"parametro":"pensamento_tau_c","de":0.022719264030456543,"para":0.022697925567626953,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=12288)"}}
15
- {"tipo":"ajuste","dados":{"passo":12,"parametro":"pensamento_tau_c","de":0.022697925567626953,"para":0.02268761396408081,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=13312)"}}
16
- {"tipo":"ajuste","dados":{"passo":13,"parametro":"pensamento_tau_c","de":0.02268761396408081,"para":0.02280670404434204,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=14336)"}}
17
- {"tipo":"ajuste","dados":{"passo":14,"parametro":"pensamento_tau_c","de":0.02280670404434204,"para":0.022728443145751953,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=15360)"}}
18
- {"tipo":"ajuste","dados":{"passo":15,"parametro":"pensamento_tau_c","de":0.022728443145751953,"para":0.022736310958862305,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=16384)"}}
19
- {"tipo":"ajuste","dados":{"passo":15,"parametro":"pensamento_n_tentativas","de":4.0,"para":8.0,"motivo":"A-3 Hoeffding+acordo (â=0.525 ⇒ p̂=0.611, δ=0.05)"}}
20
- {"tipo":"ajuste","dados":{"passo":16,"parametro":"pensamento_tau_c","de":0.022736310958862305,"para":0.02274996042251587,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=17408)"}}
21
- {"tipo":"ajuste","dados":{"passo":17,"parametro":"pensamento_tau_c","de":0.02274996042251587,"para":0.022856473922729492,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=18432)"}}
22
- {"tipo":"ajuste","dados":{"passo":18,"parametro":"pensamento_tau_c","de":0.022856473922729492,"para":0.02278655767440796,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=19456)"}}
23
- {"tipo":"ajuste","dados":{"passo":19,"parametro":"pensamento_tau_c","de":0.02278655767440796,"para":0.022822678089141846,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=20480)"}}
24
- {"tipo":"ajuste","dados":{"passo":20,"parametro":"pensamento_tau_c","de":0.022822678089141846,"para":0.022863924503326416,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=21504)"}}
25
- {"tipo":"ajuste","dados":{"passo":21,"parametro":"pensamento_tau_c","de":0.022863924503326416,"para":0.022868633270263672,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=22528)"}}
26
- {"tipo":"ajuste","dados":{"passo":22,"parametro":"pensamento_tau_c","de":0.022868633270263672,"para":0.022899150848388672,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=23552)"}}
27
- {"tipo":"ajuste","dados":{"passo":23,"parametro":"pensamento_tau_c","de":0.022899150848388672,"para":0.02296435832977295,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=24576)"}}
28
- {"tipo":"ajuste","dados":{"passo":24,"parametro":"pensamento_tau_c","de":0.02296435832977295,"para":0.022948086261749268,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=25600)"}}
29
- {"tipo":"ajuste","dados":{"passo":25,"parametro":"pensamento_tau_c","de":0.022948086261749268,"para":0.022920548915863037,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=26624)"}}
30
- {"tipo":"ajuste","dados":{"passo":26,"parametro":"pensamento_tau_c","de":0.022920548915863037,"para":0.02294844388961792,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=27648)"}}
31
- {"tipo":"ajuste","dados":{"passo":27,"parametro":"pensamento_tau_c","de":0.02294844388961792,"para":0.022922873497009277,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=28672)"}}
32
- {"tipo":"ajuste","dados":{"passo":28,"parametro":"pensamento_tau_c","de":0.022922873497009277,"para":0.022958874702453613,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=29696)"}}
33
- {"tipo":"ajuste","dados":{"passo":29,"parametro":"pensamento_tau_c","de":0.022958874702453613,"para":0.022955000400543213,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=30720)"}}
34
- {"tipo":"ajuste","dados":{"passo":30,"parametro":"pensamento_tau_c","de":0.022955000400543213,"para":0.02293342351913452,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=31744)"}}
35
- {"tipo":"ajuste","dados":{"passo":31,"parametro":"pensamento_tau_c","de":0.02293342351913452,"para":0.02293938398361206,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=32768)"}}
36
- {"tipo":"ajuste","dados":{"passo":32,"parametro":"pensamento_tau_c","de":0.02293938398361206,"para":0.0229642391204834,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=33792)"}}
37
- {"tipo":"ajuste","dados":{"passo":33,"parametro":"pensamento_tau_c","de":0.0229642391204834,"para":0.022974014282226562,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=34816)"}}
38
- {"tipo":"ajuste","dados":{"passo":34,"parametro":"pensamento_tau_c","de":0.022974014282226562,"para":0.022957980632781982,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=35840)"}}
39
- {"tipo":"ajuste","dados":{"passo":35,"parametro":"pensamento_tau_c","de":0.022957980632781982,"para":0.02293217182159424,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=36864)"}}
40
- {"tipo":"ajuste","dados":{"passo":36,"parametro":"pensamento_tau_c","de":0.02293217182159424,"para":0.022953391075134277,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=37888)"}}
41
- {"tipo":"ajuste","dados":{"passo":37,"parametro":"pensamento_tau_c","de":0.022953391075134277,"para":0.022935807704925537,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=38912)"}}
42
- {"tipo":"ajuste","dados":{"passo":38,"parametro":"pensamento_tau_c","de":0.022935807704925537,"para":0.022968053817749023,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=39936)"}}
43
- {"tipo":"ajuste","dados":{"passo":39,"parametro":"pensamento_tau_c","de":0.022968053817749023,"para":0.0229414701461792,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=40960)"}}
44
- {"tipo":"ajuste","dados":{"passo":40,"parametro":"pensamento_tau_c","de":0.0229414701461792,"para":0.022938907146453857,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=41984)"}}
45
- {"tipo":"ajuste","dados":{"passo":41,"parametro":"pensamento_tau_c","de":0.022938907146453857,"para":0.022935807704925537,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=43008)"}}
46
- {"tipo":"ajuste","dados":{"passo":44,"parametro":"pensamento_tau_c","de":0.022935807704925537,"para":0.022957980632781982,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=45056)"}}
47
- {"tipo":"ajuste","dados":{"passo":45,"parametro":"pensamento_tau_c","de":0.022957980632781982,"para":0.022972285747528076,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=46080)"}}
48
- {"tipo":"ajuste","dados":{"passo":46,"parametro":"pensamento_tau_c","de":0.022972285747528076,"para":0.022983551025390625,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=47104)"}}
49
- {"tipo":"ajuste","dados":{"passo":47,"parametro":"pensamento_tau_c","de":0.022983551025390625,"para":0.02296394109725952,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=48128)"}}
50
- {"tipo":"ajuste","dados":{"passo":48,"parametro":"pensamento_tau_c","de":0.02296394109725952,"para":0.022973179817199707,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=49152)"}}
51
- {"tipo":"ajuste","dados":{"passo":49,"parametro":"pensamento_tau_c","de":0.022973179817199707,"para":0.02298593521118164,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=50176)"}}
52
- {"tipo":"ajuste","dados":{"passo":50,"parametro":"pensamento_tau_c","de":0.02298593521118164,"para":0.023021340370178223,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=51200)"}}
53
- {"tipo":"ajuste","dados":{"passo":51,"parametro":"pensamento_tau_c","de":0.023021340370178223,"para":0.02301102876663208,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=52224)"}}
54
- {"tipo":"ajuste","dados":{"passo":52,"parametro":"pensamento_tau_c","de":0.02301102876663208,"para":0.023013651371002197,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=53248)"}}
55
- {"tipo":"ajuste","dados":{"passo":53,"parametro":"pensamento_tau_c","de":0.023013651371002197,"para":0.023046553134918213,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=54272)"}}
56
- {"tipo":"ajuste","dados":{"passo":54,"parametro":"pensamento_tau_c","de":0.023046553134918213,"para":0.02307361364364624,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=55296)"}}
57
- {"tipo":"ajuste","dados":{"passo":55,"parametro":"pensamento_tau_c","de":0.02307361364364624,"para":0.023107469081878662,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=56320)"}}
58
- {"tipo":"ajuste","dados":{"passo":56,"parametro":"pensamento_tau_c","de":0.023107469081878662,"para":0.023133397102355957,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=57344)"}}
59
- {"tipo":"ajuste","dados":{"passo":57,"parametro":"pensamento_tau_c","de":0.023133397102355957,"para":0.02313852310180664,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=58368)"}}
60
- {"tipo":"ajuste","dados":{"passo":58,"parametro":"pensamento_tau_c","de":0.02313852310180664,"para":0.02313053607940674,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=59392)"}}
61
- {"tipo":"ajuste","dados":{"passo":59,"parametro":"pensamento_tau_c","de":0.02313053607940674,"para":0.02314138412475586,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=60416)"}}
62
- {"tipo":"dump","dados":{"acordo_tentativas":[[0,0.5242253183229574],[1,0.5196614126422597],[2,0.5257449183457842],[3,0.5330622514350883],[4,0.5245019973954186],[5,0.5199602458160371],[6,0.5177712816318186],[7,0.5244399208507579],[8,0.53681094980008],[9,0.528316649433691],[10,0.5334040453502288],[11,0.5177172637389352],[12,0.5200667596169902],[13,0.5307594829549392],[14,0.515374661918031],[15,0.5255790033843368],[16,0.5281660798257993],[17,0.5346757676452398],[18,0.529241313051898],[19,0.5216506658119519],[20,0.5356716537013805],[21,0.5246350576829476],[22,0.5109627895775096],[23,0.5086547085278047],[24,0.5234480652385779],[25,0.5413357143406756],[26,0.5206464085786138],[27,0.5137109587279459],[28,0.5266877379441818],[29,0.5037831310764886],[30,0.5130414182446353],[31,0.5007295610848814],[32,0.5025985161191784],[33,0.5151924522748837],[34,0.5123762060732892],[35,0.5290023916689582],[36,0.5306032927765045],[37,0.5313207440291686],[38,0.5243620008792883],[39,0.5199399796244203],[40,0.5348069277048731],[41,0.5232541509564422],[42,0.5242976913577877],[44,0.5210769070157161],[45,0.519067988692162],[46,0.5042248214255475],[47,0.5024980471353047],[48,0.5083159557034378],[49,0.49144882046190713],[50,0.49601653466622037],[51,0.514461044940011],[52,0.5160899722638229],[53,0.5106741597604317],[54,0.5095089419725506],[55,0.5310550890959954],[56,0.5084244040869331],[57,0.5219405006306866],[58,0.5177929324951643],[59,0.5085814635191733]],"ce_gatilhada_com":[[0,4.0160642464955645],[1,4.020796358585358],[2,3.756197532018026],[3,3.972007393836975],[4,3.9106242656707764],[5,4.150133311748505],[6,4.096499919891357],[7,4.274447917938232],[8,4.214584827423096],[9,4.262876033782959],[10,3.9690253734588623],[11,4.19330507516861],[12,3.944504658381144],[13,4.155826568603516],[14,4.011726260185242],[15,4.138347466786702],[16,4.154810269673665],[17,3.807436466217041],[18,4.160148203372955],[19,3.9540923833847046],[20,4.257730007171631],[21,4.238237142562866],[22,4.117620388666789],[23,3.9574949741363525],[24,4.017991900444031],[25,4.146730422973633],[26,3.888241410255432],[27,4.000128924846649],[28,4.193357229232788],[29,3.8961690266927085],[30,3.9902414679527283],[31,4.162360827128093],[32,3.8762173652648926],[33,4.093463182449341],[34,4.1116257309913635],[35,4.110910892486572],[36,4.008694291114807],[37,3.9714513421058655],[38,4.276417016983032],[39,4.10725474357605],[40,4.390232880910237],[41,4.015871445337932],[42,3.932928959528605],[44,4.15267539024353],[45,3.9569873809814453],[46,3.8472858667373657],[47,3.852354347705841],[48,4.1043301820755005],[49,3.7693896293640137],[50,4.248522758483887],[51,3.7071454524993896],[52,4.210555076599121],[53,3.9695053100585938],[54,3.852332830429077],[55,3.6260454654693604],[56,3.816598415374756],[57,4.208217620849609],[58,4.0796865820884705],[59,4.101994673411052]],"ce_gatilhada_sem":[[0,4.0117941697438555],[1,3.995416045188904],[2,3.7062788804372153],[3,3.84058153629303],[4,3.7657753626505532],[5,4.03393679857254],[6,3.9927070140838623],[7,4.063235282897949],[8,3.8145322799682617],[9,4.33061957359314],[10,3.950933873653412],[11,4.194869160652161],[12,3.7901836236317954],[13,4.3861308097839355],[14,4.058150947093964],[15,4.249199628829956],[16,4.110453049341838],[17,3.9060821533203125],[18,4.134184658527374],[19,4.023251533508301],[20,4.20383882522583],[21,4.255165100097656],[22,3.9953749974568686],[23,3.984513282775879],[24,4.0208006501197815],[25,4.111786961555481],[26,3.871859312057495],[27,3.934393525123596],[28,4.285910367965698],[29,3.9298880894978843],[30,3.8995943665504456],[31,4.039295355478923],[32,3.9530187845230103],[33,3.9978226025899253],[34,4.031887412071228],[35,4.081463932991028],[36,3.8962252140045166],[37,3.949426531791687],[38,4.332481145858765],[39,4.124578356742859],[40,4.440631866455078],[41,3.9684581756591797],[42,3.9447473684946694],[44,4.1577277183532715],[45,3.92374324798584],[46,3.8568601608276367],[47,3.8175843358039856],[48,4.2266587018966675],[49,3.7471953630447388],[50,4.252926349639893],[51,3.749689261118571],[52,4.226971626281738],[53,3.9665422439575195],[54,3.747084140777588],[55,3.7225663661956787],[56,3.9323489665985107],[57,4.2901880741119385],[58,3.982586443424225],[59,4.114598751068115]],"confianca_media":[[0,0.02186690643429756],[1,0.021017425693571568],[2,0.02082684839842841],[3,0.021842343965545297],[4,0.02088458026992157],[5,0.020591802429407835],[6,0.022932012856472284],[7,0.023044777917675674],[8,0.023245058546308428],[9,0.0226029553450644],[10,0.021609652845654637],[11,0.021980683552101254],[12,0.0219064379343763],[13,0.023295592865906656],[14,0.02128947019809857],[15,0.021617707738187164],[16,0.023045436129905283],[17,0.023076636833138764],[18,0.020934443338774145],[19,0.022478081053122878],[20,0.022667937504593283],[21,0.02234623732510954],[22,0.022548168257344514],[23,0.023718831303995103],[24,0.022222056693863124],[25,0.021419211465399712],[26,0.022575483773835003],[27,0.021465268975589424],[28,0.022910094063263386],[29,0.02260238426970318],[30,0.021427035913802683],[31,0.02247519086813554],[32,0.022951125807594508],[33,0.02258136053569615],[34,0.022011240536812693],[35,0.021383841813076288],[36,0.022932822641450912],[37,0.021707330888602883],[38,0.023097841010894626],[39,0.021232965518720448],[40,0.022394207073375583],[41,0.022331446642056108],[42,0.022094753803685308],[44,0.02276808669557795],[45,0.022971999074798077],[46,0.02288906357716769],[47,0.02113351714797318],[48,0.022594301495701075],[49,0.022722536872606725],[50,0.023730107757728547],[51,0.021566612529568374],[52,0.022618462098762393],[53,0.02376235369592905],[54,0.023747722792904824],[55,0.023528666759375483],[56,0.023475029156543314],[57,0.02266909193713218],[58,0.0223821074469015],[59,0.02299303957261145]],"confianca_pos_correcao":[[0,0.017170101404190063],[1,0.015070827677845955],[2,0.016885248944163322],[3,0.018374895676970482],[4,0.016166063025593758],[5,0.015499933622777462],[6,0.021062828600406647],[7,0.0222613662481308],[8,0.021202150732278824],[9,0.01856091246008873],[10,0.013959418050944805],[11,0.014601214788854122],[12,0.016377698630094528],[13,0.021738233044743538],[14,0.01579440012574196],[15,0.016733000054955482],[16,0.017757147550582886],[17,0.021137062460184097],[18,0.013563212007284164],[19,0.01942417584359646],[20,0.018538599833846092],[21,0.012492356821894646],[22,0.017579518258571625],[23,0.02080530859529972],[24,0.013715420849621296],[25,0.015828007832169533],[26,0.017482515424489975],[27,0.013775487430393696],[28,0.018798530101776123],[29,0.018152408301830292],[30,0.014677587896585464],[31,0.019018039107322693],[32,0.01919858530163765],[33,0.01738257147371769],[34,0.0145476208999753],[35,0.01449913065880537],[36,0.01974528841674328],[37,0.014843683689832687],[38,0.019679786637425423],[39,0.015322884544730186],[40,0.017374254763126373],[41,0.01720760390162468],[42,0.018117297440767288],[44,0.019764592871069908],[45,0.018987078219652176],[46,0.01972634717822075],[47,0.015316982753574848],[48,0.0204097181558609],[49,0.01950886659324169],[50,0.02247670292854309],[51,0.01857130043208599],[52,0.018995223566889763],[53,0.02270491048693657],[54,0.02078261226415634],[55,0.02232854627072811],[56,0.022130470722913742],[57,0.020434889942407608],[58,0.014451826922595501],[59,0.02006591483950615]],"ece_calibracao":[[0,0.001855327282100916]],"ece_pos_calibracao":[[0,0.001855327282100916]],"escore_aprendizado":[[0,0.0],[25,0.1875],[50,0.1875],[59,0.1875]],"lr":[[0,0.000011249999999999999],[1,0.000011249999999999999],[2,0.000011249999999999999],[3,0.000011249999999999999],[4,0.000011249999999999999],[5,0.000011249999999999999],[6,0.000011249999999999999],[7,0.000011249999999999999],[8,0.000011249999999999999],[9,0.000011249999999999999],[10,0.000011249999999999999],[11,0.000011249999999999999],[12,0.000011249999999999999],[13,0.000011249999999999999],[14,0.000011249999999999999],[15,0.000011249999999999999],[16,0.000011249999999999999],[17,0.000011249999999999999],[18,0.000011249999999999999],[19,0.000011249999999999999],[20,0.000011249999999999999],[21,0.000011249999999999999],[22,0.000011249999999999999],[23,0.000011249999999999999],[24,0.000011249999999999999],[25,0.000011249999999999999],[26,0.000011249999999999999],[27,0.000011249999999999999],[28,0.000011249999999999999],[29,0.000011249999999999999],[30,0.000011249999999999999],[31,0.000011249999999999999],[32,0.000011249999999999999],[33,0.000011249999999999999],[34,0.000011249999999999999],[35,0.000011249999999999999],[36,0.000011249999999999999],[37,0.000011249999999999999],[38,0.000011249999999999999],[39,0.000011249999999999999],[40,0.000011249999999999999],[41,0.000011249999999999999],[42,0.000011249999999999999],[43,0.000011249999999999999],[44,0.000011249999999999999],[45,0.000011249999999999999],[46,0.000011249999999999999],[47,0.000011249999999999999],[48,0.000011249999999999999],[49,0.000011249999999999999],[50,0.000011249999999999999],[51,0.000011249999999999999],[52,0.000011249999999999999],[53,0.000011249999999999999],[54,0.000011249999999999999],[55,0.000011249999999999999],[56,0.000011249999999999999],[57,0.000011249999999999999],[58,0.000011249999999999999],[59,0.000011249999999999999]],"norma_delta":[[0,1.5482000205413142],[1,1.6599711954536192],[2,1.5909539173053178],[3,1.675607881270046],[4,1.777453207481186],[5,1.7457843139370264],[6,1.6556979284932594],[7,1.536442729633647],[8,1.6529101399795356],[9,1.5415383190993692],[10,1.5032071953583526],[11,1.6338577210478162],[12,1.5438247044823987],[13,1.4876278221283743],[14,1.602886713176293],[15,1.5624287398301144],[16,1.545911546700971],[17,1.5088468176395349],[18,1.5434413524146313],[19,1.4310189806134566],[20,1.5153108251510872],[21,1.560532131769961],[22,1.4484594777568385],[23,1.4368127755807796],[24,1.4223725003992336],[25,1.4174575935223614],[26,1.580361471716715],[27,1.5745697766006679],[28,1.4295705111640247],[29,1.372939342992635],[30,1.4048416715039522],[31,1.2835566528680478],[32,1.3630990505066036],[33,1.4162413949864943],[34,1.3880907175913852],[35,1.4412686248661064],[36,1.4371945429805837],[37,1.3679142355609213],[38,1.3743510015108964],[39,1.3591164090851522],[40,1.3998513772958725],[41,1.427529713042521],[42,1.3732138216151475],[44,1.3851325620980652],[45,1.3861220244490013],[46,1.4156246092671578],[47,1.3171540352223203],[48,1.3817770146724027],[49,1.3068487574653047],[50,1.3448623223017888],[51,1.3205469137811376],[52,1.3523960519920881],[53,1.4164965845370496],[54,1.323900077532603],[55,1.3716426087715086],[56,1.3283225866207697],[57,1.3789028351392958],[58,1.3335721676224817],[59,1.3023792337527642]],"norma_grad":[[0,1.131647981908186],[1,1.1311749872112193],[2,1.0378146577237048],[3,1.094517183059171],[4,1.0614925554884687],[5,1.0289344302753558],[6,1.131703523967782],[7,1.1271547746773358],[8,1.1509672776584525],[9,1.0552922512445853],[10,1.1054418007459903],[11,1.104607874794794],[12,1.1438402222755877],[13,1.0787003419607708],[14,1.1545545526962735],[15,1.1544144366701972],[16,1.1310200580660619],[17,1.0831051223452406],[18,1.1146999829776838],[19,0.9545374606548815],[20,1.0198349330259966],[21,1.2431546338611021],[22,1.0893740599133395],[23,1.1172965808010182],[24,1.073700455992412],[25,1.0755257067172264],[26,1.0302458268918915],[27,1.1622170803315772],[28,1.0901179060903203],[29,1.1270106699936682],[30,1.0500234394823875],[31,1.1087865776837966],[32,1.077794799606255],[33,1.120667131299497],[34,1.0257169803546513],[35,1.019041009611924],[36,1.1573111135350767],[37,1.1229304215999476],[38,1.1242539961019618],[39,1.0924383888000322],[40,1.1254514533927635],[41,1.1022109615388374],[42,1.0845758907076581],[43,2.0049845829489894],[44,1.0017065716746505],[45,1.1170387185105364],[46,1.105676070542844],[47,1.0802575001866994],[48,1.148444483102065],[49,1.1198172538584465],[50,1.077460848296475],[51,1.0583942013318368],[52,1.0887941306814986],[53,1.162251301133219],[54,1.0322437968061973],[55,1.1038111012752705],[56,0.9635572409889163],[57,1.1773496921355824],[58,1.0557390861552085],[59,1.1782355429592652]],"perda":[[0,4.0248847007751465],[1,4.127838611602783],[2,3.9273924827575684],[3,3.8504292964935303],[4,4.041748523712158],[5,3.976381778717041],[6,3.8012256622314453],[7,3.962718963623047],[8,3.9776134490966797],[9,3.9872653484344482],[10,3.901721954345703],[11,3.924433708190918],[12,3.9347083568573],[13,3.8204448223114014],[14,3.943568706512451],[15,4.03101921081543],[16,3.897247314453125],[17,3.8945536613464355],[18,4.0349626541137695],[19,3.893584966659546],[20,3.9290177822113037],[21,3.8997766971588135],[22,4.131077766418457],[23,3.951305866241455],[24,3.9465646743774414],[25,4.000954627990723],[26,3.84859299659729],[27,4.007931232452393],[28,3.8340771198272705],[29,3.9220995903015137],[30,3.8435018062591553],[31,4.0292463302612305],[32,3.889967679977417],[33,3.861053943634033],[34,4.007976531982422],[35,3.931272506713867],[36,3.841154098510742],[37,3.9273791313171387],[38,4.022813320159912],[39,3.998445510864258],[40,3.922797679901123],[41,3.9522581100463867],[42,3.876363515853882],[43,3.8790996755872453],[44,3.9858317375183105],[45,3.9629015922546387],[46,3.992496967315674],[47,3.8887412548065186],[48,3.8891148567199707],[49,3.910076856613159],[50,3.8900320529937744],[51,3.8351175785064697],[52,4.078568935394287],[53,3.892220973968506],[54,3.9534060955047607],[55,4.048469066619873],[56,3.822816848754883],[57,3.890082359313965],[58,3.9729111194610596],[59,3.8811371326446533]],"taxa_gatilho":[[0,0.75],[1,1.0],[2,0.75],[3,0.5],[4,0.75],[5,1.0],[6,0.25],[7,0.25],[8,0.25],[9,0.5],[10,1.0],[11,1.0],[12,0.75],[13,0.25],[14,1.0],[15,0.75],[16,0.75],[17,0.25],[18,1.0],[19,0.5],[20,0.5],[21,1.0],[22,0.75],[23,0.25],[24,1.0],[25,1.0],[26,0.5],[27,1.0],[28,0.5],[29,0.75],[30,1.0],[31,0.75],[32,0.5],[33,0.75],[34,1.0],[35,1.0],[36,0.5],[37,1.0],[38,0.5],[39,1.0],[40,0.75],[41,0.75],[42,0.75],[43,0.0],[44,0.5],[45,0.5],[46,0.5],[47,1.0],[48,0.5],[49,0.5],[50,0.25],[51,0.75],[52,0.75],[53,0.25],[54,0.5],[55,0.25],[56,0.25],[57,0.5],[58,1.0],[59,0.75]],"temperatura_calibrada":[[0,1.0]]}}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
  {"tipo":"ajuste","dados":{"passo":0,"parametro":"fase_c_base","de":0.0,"para":1.0,"motivo":"carregado checkpoint da fase B: /home/z/my-project/khtst-rust/resultados/gerador_conceitos.json (ajuste fino, não do zero)"}}
2
+ {"tipo":"ajuste","dados":{"passo":0,"parametro":"pensamento_tau_c","de":0.3,"para":0.015276610851287842,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, calibração inicial fase C)"}}
3
+ {"tipo":"ajuste","dados":{"passo":2,"parametro":"pensamento_tau_c","de":0.015276610851287842,"para":0.015835106372833252,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=1024)"}}
4
+ {"tipo":"ajuste","dados":{"passo":3,"parametro":"pensamento_tau_c","de":0.015835106372833252,"para":0.015612006187438965,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=2048)"}}
5
+ {"tipo":"ajuste","dados":{"passo":4,"parametro":"pensamento_tau_c","de":0.015612006187438965,"para":0.01582491397857666,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=3072)"}}
6
+ {"tipo":"ajuste","dados":{"passo":5,"parametro":"pensamento_tau_c","de":0.01582491397857666,"para":0.015786409378051758,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=4096)"}}
7
+ {"tipo":"ajuste","dados":{"passo":6,"parametro":"pensamento_tau_c","de":0.015786409378051758,"para":0.015867769718170166,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=5120)"}}
8
+ {"tipo":"ajuste","dados":{"passo":7,"parametro":"pensamento_tau_c","de":0.015867769718170166,"para":0.01595216989517212,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=6144)"}}
9
+ {"tipo":"ajuste","dados":{"passo":8,"parametro":"pensamento_tau_c","de":0.01595216989517212,"para":0.015894174575805664,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=7168)"}}
10
+ {"tipo":"ajuste","dados":{"passo":9,"parametro":"pensamento_tau_c","de":0.015894174575805664,"para":0.01582515239715576,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=8192)"}}
11
+ {"tipo":"ajuste","dados":{"passo":10,"parametro":"pensamento_tau_c","de":0.01582515239715576,"para":0.015813112258911133,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=9216)"}}
12
+ {"tipo":"ajuste","dados":{"passo":11,"parametro":"pensamento_tau_c","de":0.015813112258911133,"para":0.015881657600402832,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=10240)"}}
13
+ {"tipo":"ajuste","dados":{"passo":12,"parametro":"pensamento_tau_c","de":0.015881657600402832,"para":0.015885353088378906,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=11264)"}}
14
+ {"tipo":"ajuste","dados":{"passo":13,"parametro":"pensamento_tau_c","de":0.015885353088378906,"para":0.01588141918182373,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=12288)"}}
15
+ {"tipo":"ajuste","dados":{"passo":14,"parametro":"pensamento_tau_c","de":0.01588141918182373,"para":0.015842556953430176,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=13312)"}}
16
+ {"tipo":"ajuste","dados":{"passo":15,"parametro":"pensamento_tau_c","de":0.015842556953430176,"para":0.015829265117645264,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=14336)"}}
17
+ {"tipo":"ajuste","dados":{"passo":16,"parametro":"pensamento_tau_c","de":0.015829265117645264,"para":0.01583486795425415,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=15360)"}}
18
+ {"tipo":"ajuste","dados":{"passo":17,"parametro":"pensamento_tau_c","de":0.01583486795425415,"para":0.015840649604797363,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=16384)"}}
19
+ {"tipo":"ajuste","dados":{"passo":17,"parametro":"pensamento_n_tentativas","de":4.0,"para":8.0,"motivo":"A-3 Hoeffding+acordo (â=0.497 ⇒ p̂=0.500, δ=0.05)"}}
20
+ {"tipo":"ajuste","dados":{"passo":18,"parametro":"pensamento_tau_c","de":0.015840649604797363,"para":0.015881896018981934,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=17408)"}}
21
+ {"tipo":"ajuste","dados":{"passo":19,"parametro":"pensamento_tau_c","de":0.015881896018981934,"para":0.01591724157333374,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=18432)"}}
22
+ {"tipo":"ajuste","dados":{"passo":20,"parametro":"pensamento_tau_c","de":0.01591724157333374,"para":0.01595205068588257,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=19456)"}}
23
+ {"tipo":"ajuste","dados":{"passo":22,"parametro":"pensamento_tau_c","de":0.01595205068588257,"para":0.01596355438232422,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=20480)"}}
24
+ {"tipo":"ajuste","dados":{"passo":23,"parametro":"pensamento_tau_c","de":0.01596355438232422,"para":0.01596134901046753,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=21504)"}}
25
+ {"tipo":"ajuste","dados":{"passo":24,"parametro":"pensamento_tau_c","de":0.01596134901046753,"para":0.015978574752807617,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=22528)"}}
26
+ {"tipo":"ajuste","dados":{"passo":26,"parametro":"pensamento_tau_c","de":0.015978574752807617,"para":0.01595151424407959,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=24576)"}}
27
+ {"tipo":"ajuste","dados":{"passo":27,"parametro":"pensamento_tau_c","de":0.01595151424407959,"para":0.0159490704536438,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=25600)"}}
28
+ {"tipo":"ajuste","dados":{"passo":28,"parametro":"pensamento_tau_c","de":0.0159490704536438,"para":0.015960752964019775,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=26624)"}}
29
+ {"tipo":"ajuste","dados":{"passo":29,"parametro":"pensamento_tau_c","de":0.015960752964019775,"para":0.0159645676612854,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=27648)"}}
30
+ {"tipo":"ajuste","dados":{"passo":30,"parametro":"pensamento_tau_c","de":0.0159645676612854,"para":0.015994250774383545,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=28672)"}}
31
+ {"tipo":"ajuste","dados":{"passo":31,"parametro":"pensamento_tau_c","de":0.015994250774383545,"para":0.01600104570388794,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=29696)"}}
32
+ {"tipo":"ajuste","dados":{"passo":32,"parametro":"pensamento_tau_c","de":0.01600104570388794,"para":0.015990793704986572,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=30720)"}}
33
+ {"tipo":"ajuste","dados":{"passo":33,"parametro":"pensamento_tau_c","de":0.015990793704986572,"para":0.016000807285308838,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=31744)"}}
34
+ {"tipo":"ajuste","dados":{"passo":34,"parametro":"pensamento_tau_c","de":0.016000807285308838,"para":0.01600801944732666,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=32768)"}}
35
+ {"tipo":"ajuste","dados":{"passo":35,"parametro":"pensamento_tau_c","de":0.01600801944732666,"para":0.01601189374923706,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=33792)"}}
36
+ {"tipo":"ajuste","dados":{"passo":36,"parametro":"pensamento_tau_c","de":0.01601189374923706,"para":0.01602119207382202,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=34816)"}}
37
+ {"tipo":"ajuste","dados":{"passo":37,"parametro":"pensamento_tau_c","de":0.01602119207382202,"para":0.016030728816986084,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=35840)"}}
38
+ {"tipo":"ajuste","dados":{"passo":38,"parametro":"pensamento_tau_c","de":0.016030728816986084,"para":0.01602327823638916,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=36864)"}}
39
+ {"tipo":"ajuste","dados":{"passo":39,"parametro":"pensamento_tau_c","de":0.01602327823638916,"para":0.016025424003601074,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=37888)"}}
40
+ {"tipo":"ajuste","dados":{"passo":40,"parametro":"pensamento_tau_c","de":0.016025424003601074,"para":0.016038060188293457,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=38912)"}}
41
+ {"tipo":"ajuste","dados":{"passo":42,"parametro":"pensamento_tau_c","de":0.016038060188293457,"para":0.01604151725769043,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=40960)"}}
42
+ {"tipo":"ajuste","dados":{"passo":44,"parametro":"pensamento_tau_c","de":0.01604151725769043,"para":0.016036927700042725,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=41984)"}}
43
+ {"tipo":"ajuste","dados":{"passo":45,"parametro":"pensamento_tau_c","de":0.016036927700042725,"para":0.01605147123336792,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=43008)"}}
44
+ {"tipo":"ajuste","dados":{"passo":46,"parametro":"pensamento_tau_c","de":0.01605147123336792,"para":0.01605534553527832,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=44032)"}}
45
+ {"tipo":"ajuste","dados":{"passo":48,"parametro":"pensamento_tau_c","de":0.01605534553527832,"para":0.016059815883636475,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=46080)"}}
46
+ {"tipo":"ajuste","dados":{"passo":50,"parametro":"pensamento_tau_c","de":0.016059815883636475,"para":0.016071975231170654,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=47104)"}}
47
+ {"tipo":"ajuste","dados":{"passo":51,"parametro":"pensamento_tau_c","de":0.016071975231170654,"para":0.01608175039291382,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=48128)"}}
48
+ {"tipo":"ajuste","dados":{"passo":53,"parametro":"pensamento_tau_c","de":0.01608175039291382,"para":0.01609092950820923,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=50176)"}}
49
+ {"tipo":"ajuste","dados":{"passo":54,"parametro":"clip","de":1.0,"para":1.8341955345524175,"motivo":"percentil 90 das normas de gradiente (janela 32)"}}
50
+ {"tipo":"ajuste","dados":{"passo":56,"parametro":"clip","de":1.8341955345524175,"para":1.2291593777835905,"motivo":"percentil 90 das normas de gradiente (janela 32)"}}
51
+ {"tipo":"ajuste","dados":{"passo":56,"parametro":"pensamento_tau_c","de":0.01609092950820923,"para":0.016104459762573242,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=52224)"}}
52
+ {"tipo":"ajuste","dados":{"passo":57,"parametro":"pensamento_tau_c","de":0.016104459762573242,"para":0.016121327877044678,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=53248)"}}
53
+ {"tipo":"ajuste","dados":{"passo":58,"parametro":"pensamento_tau_c","de":0.016121327877044678,"para":0.0161324143409729,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=54272)"}}
54
+ {"tipo":"ajuste","dados":{"passo":59,"parametro":"pensamento_tau_c","de":0.0161324143409729,"para":0.01614171266555786,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=55296)"}}
55
+ {"tipo":"ajuste","dados":{"passo":60,"parametro":"pensamento_tau_c","de":0.01614171266555786,"para":0.016157209873199463,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=56320)"}}
56
+ {"tipo":"ajuste","dados":{"passo":61,"parametro":"pensamento_tau_c","de":0.016157209873199463,"para":0.016171157360076904,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=57344)"}}
57
+ {"tipo":"ajuste","dados":{"passo":62,"parametro":"pensamento_tau_c","de":0.016171157360076904,"para":0.016192376613616943,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=58368)"}}
58
+ {"tipo":"ajuste","dados":{"passo":63,"parametro":"pensamento_tau_c","de":0.016192376613616943,"para":0.016195833683013916,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=59392)"}}
59
+ {"tipo":"ajuste","dados":{"passo":64,"parametro":"clip","de":1.2291593777835905,"para":1.8341955345524175,"motivo":"percentil 90 das normas de gradiente (janela 32)"}}
60
+ {"tipo":"ajuste","dados":{"passo":66,"parametro":"pensamento_tau_c","de":0.016195833683013916,"para":0.016199707984924316,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=60416)"}}
61
+ {"tipo":"ajuste","dados":{"passo":67,"parametro":"pensamento_tau_c","de":0.016199707984924316,"para":0.01620650291442871,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=61440)"}}
62
+ {"tipo":"ajuste","dados":{"passo":68,"parametro":"pensamento_tau_c","de":0.01620650291442871,"para":0.016214728355407715,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=62464)"}}
63
+ {"tipo":"ajuste","dados":{"passo":69,"parametro":"pensamento_tau_c","de":0.016214728355407715,"para":0.016212821006774902,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=63488)"}}
64
+ {"tipo":"ajuste","dados":{"passo":71,"parametro":"pensamento_tau_c","de":0.016212821006774902,"para":0.016223788261413574,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=64512)"}}
65
+ {"tipo":"ajuste","dados":{"passo":72,"parametro":"pensamento_tau_c","de":0.016223788261413574,"para":0.016229331493377686,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=65536)"}}
66
+ {"tipo":"ajuste","dados":{"passo":73,"parametro":"pensamento_tau_c","de":0.016229331493377686,"para":0.01624685525894165,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=66560)"}}
67
+ {"tipo":"ajuste","dados":{"passo":74,"parametro":"pensamento_tau_c","de":0.01624685525894165,"para":0.016251325607299805,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=67584)"}}
68
+ {"tipo":"ajuste","dados":{"passo":75,"parametro":"pensamento_tau_c","de":0.016251325607299805,"para":0.01625269651412964,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=68608)"}}
69
+ {"tipo":"ajuste","dados":{"passo":76,"parametro":"pensamento_tau_c","de":0.01625269651412964,"para":0.016251564025878906,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=69632)"}}
70
+ {"tipo":"ajuste","dados":{"passo":77,"parametro":"pensamento_tau_c","de":0.016251564025878906,"para":0.016245603561401367,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=70656)"}}
71
+ {"tipo":"ajuste","dados":{"passo":78,"parametro":"pensamento_tau_c","de":0.016245603561401367,"para":0.01626521348953247,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=71680)"}}
72
+ {"tipo":"ajuste","dados":{"passo":79,"parametro":"pensamento_tau_c","de":0.01626521348953247,"para":0.01626873016357422,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=72704)"}}
73
+ {"tipo":"ajuste","dados":{"passo":80,"parametro":"pensamento_tau_c","de":0.01626873016357422,"para":0.01627439260482788,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=73728)"}}
74
+ {"tipo":"ajuste","dados":{"passo":81,"parametro":"pensamento_tau_c","de":0.01627439260482788,"para":0.016285955905914307,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=74752)"}}
75
+ {"tipo":"ajuste","dados":{"passo":82,"parametro":"pensamento_tau_c","de":0.016285955905914307,"para":0.01628929376602173,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=75776)"}}
76
+ {"tipo":"ajuste","dados":{"passo":85,"parametro":"pensamento_tau_c","de":0.01628929376602173,"para":0.01630312204360962,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=76800)"}}
77
+ {"tipo":"ajuste","dados":{"passo":86,"parametro":"pensamento_tau_c","de":0.01630312204360962,"para":0.016310393810272217,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=77824)"}}
78
+ {"tipo":"ajuste","dados":{"passo":87,"parametro":"pensamento_tau_c","de":0.016310393810272217,"para":0.01631450653076172,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=78848)"}}
79
+ {"tipo":"ajuste","dados":{"passo":89,"parametro":"pensamento_tau_c","de":0.01631450653076172,"para":0.016325056552886963,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=79872)"}}
80
+ {"tipo":"ajuste","dados":{"passo":90,"parametro":"pensamento_tau_c","de":0.016325056552886963,"para":0.01633167266845703,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=80896)"}}
81
+ {"tipo":"ajuste","dados":{"passo":91,"parametro":"pensamento_tau_c","de":0.01633167266845703,"para":0.01634281873703003,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=81920)"}}
82
+ {"tipo":"ajuste","dados":{"passo":92,"parametro":"pensamento_tau_c","de":0.01634281873703003,"para":0.016356945037841797,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=82944)"}}
83
+ {"tipo":"ajuste","dados":{"passo":94,"parametro":"pensamento_tau_c","de":0.016356945037841797,"para":0.016354739665985107,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=83968)"}}
84
+ {"tipo":"ajuste","dados":{"passo":95,"parametro":"pensamento_tau_c","de":0.016354739665985107,"para":0.016357362270355225,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=84992)"}}
85
+ {"tipo":"ajuste","dados":{"passo":96,"parametro":"pensamento_tau_c","de":0.016357362270355225,"para":0.01636737585067749,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=86016)"}}
86
+ {"tipo":"ajuste","dados":{"passo":97,"parametro":"pensamento_tau_c","de":0.01636737585067749,"para":0.016377568244934082,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=87040)"}}
87
+ {"tipo":"ajuste","dados":{"passo":98,"parametro":"pensamento_tau_c","de":0.016377568244934082,"para":0.016385138034820557,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=88064)"}}
88
+ {"tipo":"ajuste","dados":{"passo":99,"parametro":"pensamento_tau_c","de":0.016385138034820557,"para":0.016391634941101074,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=89088)"}}
89
+ {"tipo":"ajuste","dados":{"passo":100,"parametro":"pensamento_tau_c","de":0.016391634941101074,"para":0.0163840651512146,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=90112)"}}
90
+ {"tipo":"ajuste","dados":{"passo":101,"parametro":"pensamento_tau_c","de":0.0163840651512146,"para":0.0163954496383667,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=91136)"}}
91
+ {"tipo":"ajuste","dados":{"passo":102,"parametro":"pensamento_tau_c","de":0.0163954496383667,"para":0.01640254259109497,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=92160)"}}
92
+ {"tipo":"ajuste","dados":{"passo":103,"parametro":"pensamento_tau_c","de":0.01640254259109497,"para":0.0163954496383667,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=93184)"}}
93
+ {"tipo":"ajuste","dados":{"passo":104,"parametro":"pensamento_tau_c","de":0.0163954496383667,"para":0.01640462875366211,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=94208)"}}
94
+ {"tipo":"ajuste","dados":{"passo":106,"parametro":"pensamento_tau_c","de":0.01640462875366211,"para":0.016401052474975586,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=96256)"}}
95
+ {"tipo":"ajuste","dados":{"passo":107,"parametro":"pensamento_tau_c","de":0.016401052474975586,"para":0.016412973403930664,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=97280)"}}
96
+ {"tipo":"ajuste","dados":{"passo":109,"parametro":"pensamento_tau_c","de":0.016412973403930664,"para":0.01641768217086792,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=99328)"}}
97
+ {"tipo":"ajuste","dados":{"passo":110,"parametro":"pensamento_tau_c","de":0.01641768217086792,"para":0.016424894332885742,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=100352)"}}
98
+ {"tipo":"ajuste","dados":{"passo":111,"parametro":"pensamento_tau_c","de":0.016424894332885742,"para":0.01642763614654541,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=101376)"}}
99
+ {"tipo":"ajuste","dados":{"passo":112,"parametro":"pensamento_tau_c","de":0.01642763614654541,"para":0.01643669605255127,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=102400)"}}
100
+ {"tipo":"ajuste","dados":{"passo":113,"parametro":"pensamento_tau_c","de":0.01643669605255127,"para":0.016440987586975098,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=103424)"}}
101
+ {"tipo":"ajuste","dados":{"passo":114,"parametro":"pensamento_tau_c","de":0.016440987586975098,"para":0.016444385051727295,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=104448)"}}
102
+ {"tipo":"ajuste","dados":{"passo":115,"parametro":"pensamento_tau_c","de":0.016444385051727295,"para":0.01644796133041382,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=105472)"}}
103
+ {"tipo":"ajuste","dados":{"passo":118,"parametro":"pensamento_tau_c","de":0.01644796133041382,"para":0.016444742679595947,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=107520)"}}
104
+ {"tipo":"ajuste","dados":{"passo":119,"parametro":"pensamento_tau_c","de":0.016444742679595947,"para":0.01644909381866455,"motivo":"A-1 quantil DKW 1−ε (ε=0.30, n=108544)"}}
105
+ {"tipo":"dump","dados":{"acordo_tentativas":[[2,0.5116780094346419],[3,0.5009826504701778],[4,0.5165647215568848],[5,0.49142732073232764],[6,0.49854940313768265],[7,0.4973493946041951],[8,0.5065705999732018],[9,0.48525758157484233],[10,0.49271578020246426],[11,0.4890824598260224],[12,0.4962963872627976],[13,0.48558890792385984],[14,0.49650688795372844],[15,0.4878790514000381],[16,0.4853618925359721],[17,0.5110288703969369],[18,0.4846070508938283],[19,0.4810780116628545],[20,0.5143863174210613],[22,0.5047728516704714],[23,0.5007803197603001],[24,0.5102443449917095],[25,0.5122870562336175],[26,0.5160432916212206],[27,0.4986105197507034],[28,0.4990681664397319],[29,0.49300678142268833],[30,0.5045749350392725],[31,0.504078558042238],[32,0.49121567988186143],[33,0.5068044673729067],[34,0.49830921230992925],[35,0.5121417492240047],[36,0.49341389554319903],[37,0.5109631993788449],[38,0.4934431310023986],[39,0.49439121782779694],[40,0.49198459949790657],[41,0.5072431783434391],[42,0.49669420199158293],[44,0.504438140031804],[45,0.523917044561434],[46,0.5060011311046159],[47,0.4930546594174909],[48,0.5035839872240709],[50,0.4973667913582176],[51,0.49235982581740245],[52,0.5077097200992284],[53,0.4895610048633898],[55,0.5112586187509199],[56,0.49859741838493693],[57,0.5207613551877633],[58,0.5051385844223356],[59,0.49411766525008716],[60,0.5107509366062004],[61,0.4980954646113484],[62,0.488737498599221],[63,0.5067567957448773],[66,0.5168449330570487],[67,0.4995453192386776],[68,0.48674103904825944],[69,0.5043528531095944],[71,0.5324936879721159],[72,0.5214435179441352],[73,0.5029708041062501],[74,0.4950586053309962],[75,0.517108925540621],[76,0.5022418884418585],[77,0.503523568661573],[78,0.5065061049923921],[79,0.5068382843746804],[80,0.5071682576090097],[81,0.5216916522961886],[82,0.49822212583967485],[85,0.5219910961556403],[86,0.500038352329284],[87,0.5214119352555523],[89,0.5055186175741255],[90,0.516359604920884],[91,0.5140002432308393],[92,0.5164084428688511],[94,0.495837912564942],[95,0.4985545256252711],[96,0.4959093778015813],[97,0.5076921884707796],[98,0.5151858037570491],[99,0.5236359987757169],[100,0.5101994089103149],[101,0.49940001912182197],[102,0.5135063777330894],[103,0.5130118563926468],[104,0.510344788354511],[105,0.515698216118229],[106,0.4955107751399434],[107,0.5100722656934522],[108,0.4884689756630299],[109,0.5062498113450905],[110,0.49572100695998716],[111,0.5006160756092868],[112,0.4918865696721089],[113,0.49788247896746424],[114,0.5099737608895035],[115,0.5042683665330211],[116,0.5089698421070352],[118,0.4936531001488523],[119,0.4930451132095186]],"ce_gatilhada_com":[[2,4.2190916538238525],[3,4.1649080117543535],[4,4.25049352645874],[5,4.07148003578186],[6,4.002262115478516],[7,4.099886178970337],[8,4.21198832988739],[9,4.167144954204559],[10,4.227920651435852],[11,3.920081377029419],[12,4.127252101898193],[13,4.045651078224182],[14,4.22350150346756],[15,4.070937474568685],[16,4.07403838634491],[17,4.138213157653809],[18,4.0710344314575195],[19,4.188529014587402],[20,3.8407119512557983],[22,4.126163005828857],[23,3.878866751988729],[24,4.016981363296509],[25,3.9769970575968423],[26,3.9791059494018555],[27,4.1622317632039385],[28,4.219593207041423],[29,3.948340972264608],[30,4.025691509246826],[31,4.097966591517131],[32,3.9795923233032227],[33,3.966372489929199],[34,4.14201561609904],[35,4.066779613494873],[36,4.08082930246989],[37,4.285421133041382],[38,4.214970111846924],[39,4.163273096084595],[40,4.009872317314148],[41,4.019285599390666],[42,3.827711343765259],[44,4.224522590637207],[45,3.8586935997009277],[46,4.168125629425049],[47,4.091124137242635],[48,4.15498960018158],[50,4.161887168884277],[51,4.334088325500488],[52,4.287672201792399],[53,4.012016773223877],[55,4.281246980031331],[56,3.95289945602417],[57,3.8543503284454346],[58,3.979073643684387],[59,3.864458441734314],[60,3.674497127532959],[61,4.169451713562012],[62,4.186224460601807],[63,4.018223762512207],[66,4.19297472635905],[67,4.03331446647644],[68,4.0598649978637695],[69,4.003477990627289],[71,3.931771993637085],[72,4.202875137329102],[73,4.383389949798584],[74,4.122818946838379],[75,3.988055467605591],[76,4.147614479064941],[77,3.938656985759735],[78,3.990088701248169],[79,3.956869125366211],[80,3.7708089351654053],[81,4.226512908935547],[82,4.094865560531616],[85,4.131162405014038],[86,4.13593864440918],[87,4.022249937057495],[89,3.9785704612731934],[90,4.102910995483398],[91,3.844160556793213],[92,4.655609130859375],[94,4.270301500956218],[95,3.913612206776937],[96,3.9973526000976562],[97,4.125789165496826],[98,4.2316367626190186],[99,4.0143141746521],[100,4.0631144642829895],[101,4.097619533538818],[102,4.140370845794678],[103,4.172711253166199],[104,4.004823207855225],[105,4.475634574890137],[106,4.124558866024017],[107,4.36167049407959],[108,4.106691479682922],[109,4.10339879989624],[110,4.066124200820923],[111,4.367727597554524],[112,4.282867908477783],[113,4.369454860687256],[114,4.260819673538208],[115,4.143138408660889],[116,4.131195227305095],[118,4.028536260128021],[119,4.203924179077148]],"ce_gatilhada_sem":[[2,4.135167121887207],[3,4.08248774210612],[4,4.410757064819336],[5,4.083106994628906],[6,4.036925554275513],[7,4.003228982289632],[8,4.366427659988403],[9,4.0158514976501465],[10,4.249436438083649],[11,3.992733359336853],[12,4.256990353266398],[13,4.063348352909088],[14,4.350652396678925],[15,3.9973674615224204],[16,4.056050896644592],[17,4.033069610595703],[18,4.037337303161621],[19,4.103338241577148],[20,3.8217246532440186],[22,4.169246673583984],[23,3.9109109242757163],[24,3.988774299621582],[25,3.967182159423828],[26,4.016261339187622],[27,4.172151883443196],[28,4.24684206644694],[29,3.9766006469726562],[30,4.122860908508301],[31,3.9651081562042236],[32,4.009475231170654],[33,3.9408657550811768],[34,4.09839391708374],[35,4.067948182423909],[36,3.947951078414917],[37,4.138492107391357],[38,4.117655595143636],[39,4.054078817367554],[40,3.9768482446670532],[41,3.9250956376393638],[42,3.8122211694717407],[44,4.279254078865051],[45,3.8536436557769775],[46,4.2051310539245605],[47,4.100713570912679],[48,4.07472026348114],[50,4.154218077659607],[51,4.118834495544434],[52,4.263227224349976],[53,3.943774461746216],[55,4.25579849878947],[56,3.9253307580947876],[57,3.797128915786743],[58,4.030175447463989],[59,3.9995222091674805],[60,3.711508274078369],[61,3.971734046936035],[62,4.180609226226807],[63,3.9429023265838623],[66,4.256791114807129],[67,3.953133503595988],[68,4.133853793144226],[69,3.9484578371047974],[71,3.719111442565918],[72,4.214616775512695],[73,4.182123184204102],[74,4.021827141443889],[75,3.975590626398722],[76,4.1464457511901855],[77,3.909820258617401],[78,4.031116485595703],[79,4.081018924713135],[80,3.757671356201172],[81,4.296045303344727],[82,4.032370090484619],[85,4.044252157211304],[86,4.232784271240234],[87,4.054569482803345],[89,3.9884854555130005],[90,4.061056137084961],[91,3.8756725788116455],[92,4.791706085205078],[94,4.25905164082845],[95,3.8737687269846597],[96,4.009887218475342],[97,4.085798263549805],[98,4.1671693325042725],[99,4.150042533874512],[100,4.030197441577911],[101,4.048605918884277],[102,4.170391082763672],[103,4.117056965827942],[104,3.7585763931274414],[105,4.523727099100749],[106,4.184779405593872],[107,4.219066619873047],[108,4.034537255764008],[109,4.014245510101318],[110,4.019596576690674],[111,4.410228252410889],[112,4.33652400970459],[113,4.271895408630371],[114,4.290643930435181],[115,4.180043935775757],[116,4.070539395014445],[118,4.037864863872528],[119,4.2223060131073]],"confianca_media":[[2,0.015209852659609169],[3,0.014926327858120203],[4,0.01575905008940026],[5,0.015283959452062845],[6,0.015778783184941858],[7,0.0159931403468363],[8,0.015279165876563638],[9,0.014838760078419],[10,0.015186980774160475],[11,0.016019664413761348],[12,0.015607410110533237],[13,0.015631080605089664],[14,0.014985589077696204],[15,0.015241732471622527],[16,0.015545864589512348],[17,0.015312408155295998],[18,0.01621188159333542],[19,0.016267115308437496],[20,0.01621580822393298],[22,0.015837626182474196],[23,0.015440313494764268],[24,0.01604065066203475],[25,0.015240947250276804],[26,0.01467120205052197],[27,0.015422199852764606],[28,0.015849770104978234],[29,0.015336222655605525],[30,0.016217364056501538],[31,0.01579546369612217],[32,0.015293189673684537],[33,0.01602516055572778],[34,0.015742481336928904],[35,0.015928158769384027],[36,0.01586073392536491],[37,0.015663073339965194],[38,0.015607782930601388],[39,0.015564607921987772],[40,0.01571616396540776],[41,0.015422276919707656],[42,0.01579666160978377],[44,0.01522112195380032],[45,0.01626052742358297],[46,0.015576203470118344],[47,0.015711502579506487],[48,0.016023237782064825],[50,0.016143133805599064],[51,0.0159463522140868],[52,0.015621230762917548],[53,0.01609998190542683],[55,0.015834928257390857],[56,0.016247086750809103],[57,0.016201216203626245],[58,0.016170580813195556],[59,0.01621075492585078],[60,0.01628479122882709],[61,0.016303297132253647],[62,0.016619434871245176],[63,0.015928743698168546],[66,0.01589355879696086],[67,0.016272809705697],[68,0.01607036282075569],[69,0.015638456563465297],[71,0.016358149820007384],[72,0.016107869741972536],[73,0.01690345158567652],[74,0.016087936121039093],[75,0.016110204334836453],[76,0.01561870111618191],[77,0.015674623544327915],[78,0.017126745777204633],[79,0.016214341099839658],[80,0.016211873036809266],[81,0.01658326538745314],[82,0.016148867376614362],[85,0.016746834677178413],[86,0.016322416777256876],[87,0.01617642678320408],[89,0.016645827039610595],[90,0.01630862196907401],[91,0.016531820583622903],[92,0.01689209952019155],[94,0.015612768125720322],[95,0.01603460410842672],[96,0.01684951048810035],[97,0.016774948104284704],[98,0.016489149071276188],[99,0.016585903184022754],[100,0.015315791650209576],[101,0.017156522371806204],[102,0.016673795937094837],[103,0.01512196904513985],[104,0.016528573352843523],[105,0.016140178428031504],[106,0.015842693857848644],[107,0.017033366078976542],[108,0.016154518583789468],[109,0.01646821020403877],[110,0.016666810144670308],[111,0.0167126331361942],[112,0.016810949775390327],[113,0.01643149519804865],[114,0.016368237033020705],[115,0.016419194114860147],[116,0.016165832348633558],[118,0.015997479553334415],[119,0.016460062295664102]],"confianca_pos_correcao":[[2,0.0013086491962894797],[3,0.0012796190567314625],[4,0.0012701846426352859],[5,0.0013586978893727064],[6,0.0013693729415535927],[7,0.0012903377646580338],[8,0.0011525476584210992],[9,0.0011856427881866693],[10,0.001303499680943787],[11,0.0013953140005469322],[12,0.001269887201488018],[13,0.0012119635939598083],[14,0.0011918997624889016],[15,0.0012463689781725407],[16,0.0013935917522758245],[17,0.0012913636164739728],[18,0.0015257175546139479],[19,0.0015036388067528605],[20,0.0014534861547872424],[22,0.0012968548107892275],[23,0.0012671115109696984],[24,0.0013250585179775953],[25,0.0012807496823370457],[26,0.001155222998932004],[27,0.0012350978795439005],[28,0.0012407433241605759],[29,0.0012811229098588228],[30,0.0014702623011544347],[31,0.001403479604050517],[32,0.001284450409002602],[33,0.0013050762936472893],[34,0.0012998234014958143],[35,0.0012871581129729748],[36,0.0011406976263970137],[37,0.0013961324002593756],[38,0.001309152110479772],[39,0.0013411575928330421],[40,0.0013864828506484628],[41,0.0012609814293682575],[42,0.0013435336295515299],[44,0.0011442007962614298],[45,0.0014274271670728922],[46,0.0012899709399789572],[47,0.0013868159148842096],[48,0.0013548483839258552],[50,0.0013737520202994347],[51,0.0013028958346694708],[52,0.0013580762315541506],[53,0.0013948680134490132],[55,0.0013652308844029903],[56,0.001445976784452796],[57,0.0014015319757163525],[58,0.0014385944232344627],[59,0.001413455349393189],[60,0.0014621143927797675],[61,0.0014778769109398127],[62,0.001462708692997694],[63,0.0014059855602681637],[66,0.0013968528946861625],[67,0.0013157939538359642],[68,0.0014481523539870977],[69,0.0012138448655605316],[71,0.0014877838548272848],[72,0.001416458049789071],[73,0.001443654764443636],[74,0.0013948860578238964],[75,0.001528276363387704],[76,0.0013549322029575706],[77,0.0012540110619738698],[78,0.001550636370666325],[79,0.0014424796681851149],[80,0.0014576305402442813],[81,0.0014361559879034758],[82,0.0013793774414807558],[85,0.0014514336362481117],[86,0.0014461311511695385],[87,0.0014370856806635857],[89,0.0015514795668423176],[90,0.0014674640260636806],[91,0.00148757454007864],[92,0.0014959505060687661],[94,0.0012986065121367574],[95,0.0014832110609859228],[96,0.0015212919097393751],[97,0.001552896574139595],[98,0.001396761042997241],[99,0.001425150316208601],[100,0.0011534420773386955],[101,0.0015552849508821964],[102,0.0015150823164731264],[103,0.0011711327824741602],[104,0.0015458790585398674],[105,0.001406312920153141],[106,0.001291137421503663],[107,0.0015222849324345589],[108,0.0013023907085880637],[109,0.001462095300666988],[110,0.001506602275185287],[111,0.0015080886660143733],[112,0.0015760716050863266],[113,0.0014757814351469278],[114,0.0013939450727775693],[115,0.0014765893574804068],[116,0.0014169781934469938],[118,0.0013505788519978523],[119,0.0014514094218611717]],"ece_calibracao":[[0,0.014991303556598723]],"ece_pos_calibracao":[[0,0.0013762596645392478]],"escore_aprendizado":[[0,0.0],[25,0.1875],[50,0.1875],[75,0.1820538130483367],[100,0.1865078985370267],[119,0.19252297464020676]],"lr":[[0,0.000011249999999999999],[1,0.000011249999999999999],[2,0.000011249999999999999],[3,0.000011249999999999999],[4,0.000011249999999999999],[5,0.000011249999999999999],[6,0.000011249999999999999],[7,0.000011249999999999999],[8,0.000011249999999999999],[9,0.000011249999999999999],[10,0.000011249999999999999],[11,0.000011249999999999999],[12,0.000011249999999999999],[13,0.000011249999999999999],[14,0.000011249999999999999],[15,0.000011249999999999999],[16,0.000011249999999999999],[17,0.000011249999999999999],[18,0.000011249999999999999],[19,0.000011249999999999999],[20,0.000011249999999999999],[21,0.000011249999999999999],[22,0.000011249999999999999],[23,0.000011249999999999999],[24,0.000011249999999999999],[25,0.000011249999999999999],[26,0.000011249999999999999],[27,0.000011249999999999999],[28,0.000011249999999999999],[29,0.000011249999999999999],[30,0.000011249999999999999],[31,0.000011249999999999999],[32,0.000011249999999999999],[33,0.000011249999999999999],[34,0.000011249999999999999],[35,0.000011249999999999999],[36,0.000011249999999999999],[37,0.000011249999999999999],[38,0.000011249999999999999],[39,0.000011249999999999999],[40,0.000011249999999999999],[41,0.000011249999999999999],[42,0.000011249999999999999],[43,0.000011249999999999999],[44,0.000011249999999999999],[45,0.000011249999999999999],[46,0.000011249999999999999],[47,0.000011249999999999999],[48,0.000011249999999999999],[49,0.000011249999999999999],[50,0.000011249999999999999],[51,0.000011249999999999999],[52,0.000011249999999999999],[53,0.000011249999999999999],[54,0.000011249999999999999],[55,0.000011249999999999999],[56,0.000011249999999999999],[57,0.000011249999999999999],[58,0.000011249999999999999],[59,0.000011249999999999999],[60,0.000011249999999999999],[61,0.000011249999999999999],[62,0.000011249999999999999],[63,0.000011249999999999999],[64,0.000011249999999999999],[65,0.000011249999999999999],[66,0.000011249999999999999],[67,0.000011249999999999999],[68,0.000011249999999999999],[69,0.000011249999999999999],[70,0.000011249999999999999],[71,0.000011249999999999999],[72,0.000011249999999999999],[73,0.000011249999999999999],[74,0.000011249999999999999],[75,0.000011249999999999999],[76,0.000011249999999999999],[77,0.000011249999999999999],[78,0.000011249999999999999],[79,0.000011249999999999999],[80,0.000011249999999999999],[81,0.000011249999999999999],[82,0.000011249999999999999],[83,0.000011249999999999999],[84,0.000011249999999999999],[85,0.000011249999999999999],[86,0.000011249999999999999],[87,0.000011249999999999999],[88,0.000011249999999999999],[89,0.000011249999999999999],[90,0.000011249999999999999],[91,0.000011249999999999999],[92,0.000011249999999999999],[93,0.000011249999999999999],[94,0.000011249999999999999],[95,0.000011249999999999999],[96,0.000011249999999999999],[97,0.000011249999999999999],[98,0.000011249999999999999],[99,0.000011249999999999999],[100,0.000011249999999999999],[101,0.000011249999999999999],[102,0.000011249999999999999],[103,0.000011249999999999999],[104,0.000011249999999999999],[105,0.000011249999999999999],[106,0.000011249999999999999],[107,0.000011249999999999999],[108,0.000011249999999999999],[109,0.000011249999999999999],[110,0.000011249999999999999],[111,0.000011249999999999999],[112,0.000011249999999999999],[113,0.000011249999999999999],[114,0.000011249999999999999],[115,0.000011249999999999999],[116,0.000011249999999999999],[117,0.000011249999999999999],[118,0.000011249999999999999],[119,0.000011249999999999999]],"norma_delta":[[2,1.591943951698401],[3,1.5721631129236227],[4,1.549774996515765],[5,1.5596947474035183],[6,1.6317684358233597],[7,1.53784797886443],[8,1.4522743606612467],[9,1.5814777677639482],[10,1.5170302807546197],[11,1.4586057771780432],[12,1.4712236554713],[13,1.4757307828530524],[14,1.3683891465206866],[15,1.4276608136348257],[16,1.52639186690301],[17,1.5253630377977132],[18,1.5031324104871904],[19,1.4389758619307977],[20,1.461568114910388],[22,1.4420316833105251],[23,1.3434024183826563],[24,1.3867171166638708],[25,1.4676261822912042],[26,1.3539172700938646],[27,1.3682520182598332],[28,1.3387781025904812],[29,1.3629199754392383],[30,1.395958306520652],[31,1.4538612551442434],[32,1.2520864716213882],[33,1.339968928503515],[34,1.4206387521772106],[35,1.4636131712617724],[36,1.4206782743951492],[37,1.3201589100003068],[38,1.4038945710763657],[39,1.3593798231718943],[40,1.3417476106398154],[41,1.3216982910506554],[42,1.4896193368824422],[44,1.5363780975943715],[45,1.4084079291923566],[46,1.3778044104992946],[47,1.2978681415449025],[48,1.3491864790864647],[50,1.2915142902613033],[51,1.3417390813694219],[52,1.2660626726080249],[53,1.2929826718413542],[55,1.3188738235990463],[56,1.2625499148935286],[57,1.412946692871124],[58,1.360666516520037],[59,1.2458664737661123],[60,1.2796012225195008],[61,1.2059437318489123],[62,1.3034645790757144],[63,1.2999285861720784],[66,1.331782924739931],[67,1.2020783764204213],[68,1.1580819232173833],[69,1.302012505194384],[71,1.3148482977096598],[72,1.3093862838076828],[73,1.219516268729175],[74,1.3092430667369475],[75,1.1983300311308784],[76,1.1833573410571767],[77,1.2027319228868059],[78,1.2417651724091006],[79,1.2673742662324783],[80,1.2263996477808388],[81,1.2462301628041512],[82,1.297597890479752],[85,1.3166531294517105],[86,1.3070527069829594],[87,1.3040948309731069],[89,1.1543583732527003],[90,1.326537900591011],[91,1.303712583390815],[92,1.2361221985670932],[94,1.2030843257221326],[95,1.199182317223833],[96,1.177181791165623],[97,1.1675177886881987],[98,1.1883143594055443],[99,1.1872090937012962],[100,1.1790478721780957],[101,1.1549949536068809],[102,1.125204226712297],[103,1.2394433089383647],[104,1.2119113082915924],[105,1.1848686075401331],[106,1.1239593248949222],[107,1.0954942691188212],[108,1.0716489258736897],[109,1.1251490812069287],[110,1.2219968242354262],[111,1.1652848143599404],[112,1.1678580547427528],[113,1.1897850137340988],[114,1.195864032834231],[115,1.2824936855078917],[116,1.2224713267920833],[118,1.1642573148806026],[119,1.0593872474705128]],"norma_grad":[[0,2.008924225041553],[1,1.9884720843106876],[2,1.131078943097652],[3,1.0818678885042092],[4,0.9463698630162058],[5,0.9651147249214352],[6,1.0649999758291202],[7,1.0103235106706205],[8,1.1490192251961138],[9,1.2273619831709635],[10,1.1284209319444343],[11,1.0800822254645],[12,1.1080614000105231],[13,1.1378787302965825],[14,1.1326072480205576],[15,1.0826074868624995],[16,1.092955248963137],[17,1.0799164643739714],[18,1.0062351467418287],[19,1.169581420596396],[20,1.0495416650277856],[21,2.020942307653349],[22,1.2013087354909533],[23,1.0984268235026549],[24,1.2291593777835905],[25,0.9945263483632077],[26,1.089352751580853],[27,1.1376142564700265],[28,0.9707991148292197],[29,1.0641517838903245],[30,1.056329992409617],[31,1.177950033729527],[32,1.0538520879127],[33,1.1277307288232148],[34,0.8668469845301646],[35,1.0899359155507622],[36,1.0624171434218526],[37,1.0473681711951315],[38,1.0561858051078445],[39,1.1600413158792269],[40,1.0968548416940165],[41,1.0930101967342438],[42,1.0974746446519754],[43,1.8341955345524175],[44,1.1503578312868075],[45,1.197259144195785],[46,0.9565741568568024],[47,1.0911733117916482],[48,1.1293175888556717],[49,2.140605634628059],[50,1.0455884345452247],[51,1.0916893994853605],[52,1.1313135449082359],[53,1.0441061823389777],[54,2.2344039991830194],[55,1.1369519241165391],[56,1.1796349779606965],[57,1.0687097706175743],[58,0.9947408026686695],[59,1.1205711444800968],[60,0.9041742170397075],[61,1.1979271557197022],[62,1.013504808301619],[63,1.1741161829053055],[64,2.1461132691494087],[65,2.1484528407758297],[66,1.1561480846387249],[67,1.1123013828388741],[68,0.8977218924192767],[69,1.2053854669376445],[70,2.016953409006775],[71,1.1918476464826628],[72,1.1322743097998014],[73,1.0643085722213494],[74,1.0045809803037014],[75,1.0309010215178165],[76,1.0637715025511145],[77,1.1705607975435615],[78,1.1238030964450116],[79,1.179077342215265],[80,1.1665544878322085],[81,1.0145793067322377],[82,0.960486000875107],[83,1.6148346379086627],[84,2.0698306551694303],[85,1.0426034979253593],[86,1.067229851186436],[87,1.1067237316306364],[88,2.104655984350855],[89,1.0132008919412867],[90,1.075507456934826],[91,1.0598243864992474],[92,1.0965269382488063],[93,2.1259779933317997],[94,1.020245151337495],[95,1.104941391547045],[96,0.9537622030537273],[97,1.023892664062641],[98,1.0155952994436732],[99,1.1410260071222451],[100,1.1094042226855003],[101,1.2301568595951204],[102,0.9367398677753055],[103,1.1526361671680023],[104,1.112152311764174],[105,1.0186421493414186],[106,1.1107270046177296],[107,1.0586844177321877],[108,1.1844485267782316],[109,1.1715406957149122],[110,1.0955396887894517],[111,1.0491465284254584],[112,0.8953017694138896],[113,0.9407320560349225],[114,0.9290193012106482],[115,1.0164809678531694],[116,1.0479713142621847],[117,2.1822168774800725],[118,1.0823644149607061],[119,1.1231335900483164]],"perda":[[0,3.8888051169259206],[1,3.790922369275774],[2,3.9185822010040283],[3,3.9023056030273438],[4,3.9813027381896973],[5,3.973012685775757],[6,3.9246315956115723],[7,4.109989166259766],[8,3.963855743408203],[9,3.856020450592041],[10,3.9454543590545654],[11,3.9890224933624268],[12,3.860340118408203],[13,3.9238460063934326],[14,4.0337300300598145],[15,3.7918567657470703],[16,3.7908859252929688],[17,3.7782952785491943],[18,3.711200475692749],[19,3.8955230712890625],[20,3.795332670211792],[21,3.9353675161089217],[22,4.009256362915039],[23,4.060843467712402],[24,3.9831557273864746],[25,3.924574136734009],[26,3.76003098487854],[27,3.9509685039520264],[28,3.8658885955810547],[29,3.8582570552825928],[30,3.8165740966796875],[31,3.875473976135254],[32,3.9353294372558594],[33,3.9480714797973633],[34,3.852617025375366],[35,4.036563396453857],[36,3.983643054962158],[37,3.897163152694702],[38,3.9492855072021484],[39,3.8763418197631836],[40,3.7676243782043457],[41,3.721707344055176],[42,3.978132486343384],[43,3.9183476652417863],[44,3.8519694805145264],[45,4.012765407562256],[46,3.9148950576782227],[47,3.832698106765747],[48,4.006561279296875],[49,3.883936745779855],[50,3.996371269226074],[51,3.9973154067993164],[52,3.871610641479492],[53,3.9193246364593506],[54,3.732121365410941],[55,3.707838535308838],[56,3.9402148723602295],[57,3.8676955699920654],[58,4.01560115814209],[59,3.7161049842834473],[60,4.010905742645264],[61,3.8874948024749756],[62,3.9810988903045654],[63,3.786275863647461],[64,3.9519667284829274],[65,3.904578072684152],[66,3.904770851135254],[67,3.8073339462280273],[68,3.986722946166992],[69,3.9550628662109375],[70,3.9863307816641673],[71,3.824735641479492],[72,4.089723110198975],[73,4.038079261779785],[74,3.9762558937072754],[75,3.840259552001953],[76,3.9441845417022705],[77,4.021673202514648],[78,3.8263370990753174],[79,3.823540687561035],[80,3.7838284969329834],[81,3.96624493598938],[82,3.890432357788086],[83,3.9184752191816057],[84,3.9211994920458113],[85,4.0083327293396],[86,3.8734569549560547],[87,3.959716320037842],[88,3.845174721309117],[89,3.9146060943603516],[90,3.9843153953552246],[91,3.8205463886260986],[92,4.025490760803223],[93,4.107710872377668],[94,3.9780027866363525],[95,3.7572312355041504],[96,3.871709108352661],[97,3.809001922607422],[98,3.99141263961792],[99,3.931453227996826],[100,3.9935693740844727],[101,3.828536033630371],[102,3.9980549812316895],[103,3.9174208641052246],[104,3.6397058963775635],[105,3.986356735229492],[106,3.844395160675049],[107,4.119967460632324],[108,3.8267133235931396],[109,3.9432406425476074],[110,3.8929848670959473],[111,3.9342808723449707],[112,3.8114802837371826],[113,4.011324882507324],[114,3.932997703552246],[115,3.8406810760498047],[116,3.8871164321899414],[117,3.8184726578848704],[118,4.004743576049805],[119,3.820034980773926]],"taxa_gatilho":[[0,0.0],[1,0.0],[2,0.5],[3,0.75],[4,0.25],[5,0.75],[6,0.5],[7,0.75],[8,1.0],[9,1.0],[10,1.0],[11,0.5],[12,0.75],[13,1.0],[14,1.0],[15,0.75],[16,0.5],[17,0.5],[18,0.25],[19,0.25],[20,0.5],[21,0.0],[22,0.75],[23,0.75],[24,0.5],[25,0.75],[26,1.0],[27,0.75],[28,0.75],[29,0.75],[30,0.25],[31,0.75],[32,1.0],[33,0.75],[34,0.75],[35,0.75],[36,0.75],[37,0.5],[38,0.75],[39,0.5],[40,0.5],[41,0.75],[42,0.5],[43,0.0],[44,1.0],[45,0.5],[46,0.75],[47,0.75],[48,0.5],[49,0.0],[50,0.5],[51,0.5],[52,0.75],[53,0.5],[54,0.0],[55,0.75],[56,0.5],[57,0.25],[58,0.5],[59,0.5],[60,0.25],[61,0.25],[62,0.25],[63,0.5],[64,0.0],[65,0.0],[66,0.75],[67,0.75],[68,0.5],[69,1.0],[70,0.0],[71,0.25],[72,0.75],[73,0.25],[74,0.75],[75,0.75],[76,0.75],[77,1.0],[78,0.25],[79,0.5],[80,0.5],[81,0.25],[82,0.5],[83,0.0],[84,0.0],[85,0.5],[86,0.25],[87,0.5],[88,0.0],[89,0.5],[90,0.5],[91,0.25],[92,0.25],[93,0.0],[94,0.75],[95,0.75],[96,0.25],[97,0.25],[98,0.5],[99,0.25],[100,1.0],[101,0.25],[102,0.25],[103,1.0],[104,0.25],[105,0.75],[106,1.0],[107,0.25],[108,1.0],[109,0.5],[110,0.5],[111,0.75],[112,0.25],[113,0.5],[114,0.5],[115,0.5],[116,0.75],[117,0.0],[118,1.0],[119,0.5]],"temperatura_calibrada":[[0,3.3986686026833337]]}}
resultados/treino_v011.json ADDED
@@ -0,0 +1,784 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "versao": "0.11.0",
3
+ "dados": {
4
+ "sequencias": 1121,
5
+ "fonte": "wikimedia/wikipedia 20231101.pt"
6
+ },
7
+ "fases": {
8
+ "c": {
9
+ "acordos_medios": 0.5031977714510112,
10
+ "ce_final": 3.8982295649392262,
11
+ "ce_gatilhada_com_correcao": 4.0995158843649255,
12
+ "ce_gatilhada_sem_correcao": 4.082304307687208,
13
+ "ce_inicial": 3.9196936743600026,
14
+ "confianca_media_final": 0.0014659386361017823,
15
+ "confianca_media_inicial": 0.001390955876559019,
16
+ "confianca_pos_correcao": 0.0013758067265680096,
17
+ "decaimento_delta": 0.8588410342864766,
18
+ "ece_antes": 0.014991303556598723,
19
+ "ece_depois": 0.003190297051332891,
20
+ "escore_aprendizado": 0.19252297464020676,
21
+ "maior_sobreposicao_us": 22,
22
+ "passos": 120,
23
+ "rodadas_acoplador": 106,
24
+ "tau_c": 0.01644909381866455,
25
+ "taxa_conflito_pcgrad": 0.0,
26
+ "taxa_gatilho": 0.525,
27
+ "temperatura_calibrada": 2.2898858714535213,
28
+ "timeouts_acoplador": 0,
29
+ "tempo_s": 207.2
30
+ }
31
+ },
32
+ "elastico_real": {
33
+ "d": 64,
34
+ "elasticas": {
35
+ "aceites": 24,
36
+ "certificados_emitidos": 24,
37
+ "conf_media": 0.8804160455862681,
38
+ "conf_media_gate_calibrado": 0.8494527637958527,
39
+ "conf_media_gate_fixo_025": 0.9113793273766836,
40
+ "consultas": [
41
+ {
42
+ "braco": "gate_calibrado",
43
+ "certificados": [
44
+ {
45
+ "bound_delta_conf": 0.0,
46
+ "delta_conf_medido": 0.0,
47
+ "epsilon_safe": 0.03023522721173602,
48
+ "massa_removida": 0.0,
49
+ "rollback": false,
50
+ "valido": true,
51
+ "violado": false
52
+ }
53
+ ],
54
+ "confianca": 0.9969359636306763,
55
+ "consulta": 0,
56
+ "hedge_top3": [
57
+ 0.3333333333333333,
58
+ 0.3333333333333333,
59
+ 0.3333333333333333
60
+ ],
61
+ "iteracoes": 1,
62
+ "massas_reais": 1.0,
63
+ "orcamento_esgotado": 0.0
64
+ },
65
+ {
66
+ "braco": "gate_calibrado",
67
+ "certificados": [
68
+ {
69
+ "bound_delta_conf": 0.0,
70
+ "delta_conf_medido": 0.0,
71
+ "epsilon_safe": 1000000000.0,
72
+ "massa_removida": 0.3333333333333333,
73
+ "rollback": false,
74
+ "valido": true,
75
+ "violado": false
76
+ }
77
+ ],
78
+ "confianca": 0.7552165985107422,
79
+ "consulta": 1,
80
+ "hedge_top3": [
81
+ 0.5,
82
+ 0.5
83
+ ],
84
+ "iteracoes": 1,
85
+ "massas_reais": 1.0,
86
+ "orcamento_esgotado": 0.0
87
+ },
88
+ {
89
+ "braco": "gate_calibrado",
90
+ "certificados": [
91
+ {
92
+ "bound_delta_conf": 0.0,
93
+ "delta_conf_medido": 0.0,
94
+ "epsilon_safe": 1000000000.0,
95
+ "massa_removida": 0.3333333333333333,
96
+ "rollback": false,
97
+ "valido": true,
98
+ "violado": false
99
+ }
100
+ ],
101
+ "confianca": 0.9575677514076233,
102
+ "consulta": 2,
103
+ "hedge_top3": [
104
+ 0.5,
105
+ 0.5
106
+ ],
107
+ "iteracoes": 1,
108
+ "massas_reais": 1.0,
109
+ "orcamento_esgotado": 0.0
110
+ },
111
+ {
112
+ "braco": "gate_calibrado",
113
+ "certificados": [
114
+ {
115
+ "bound_delta_conf": 0.0,
116
+ "delta_conf_medido": 0.0,
117
+ "epsilon_safe": 1000000000.0,
118
+ "massa_removida": 0.3333333333333333,
119
+ "rollback": false,
120
+ "valido": true,
121
+ "violado": false
122
+ }
123
+ ],
124
+ "confianca": 0.9565441012382507,
125
+ "consulta": 3,
126
+ "hedge_top3": [
127
+ 0.5,
128
+ 0.5
129
+ ],
130
+ "iteracoes": 1,
131
+ "massas_reais": 1.0,
132
+ "orcamento_esgotado": 0.0
133
+ },
134
+ {
135
+ "braco": "gate_calibrado",
136
+ "certificados": [
137
+ {
138
+ "bound_delta_conf": 0.0,
139
+ "delta_conf_medido": 0.0,
140
+ "epsilon_safe": 1000000000.0,
141
+ "massa_removida": 0.25086775061268207,
142
+ "rollback": false,
143
+ "valido": true,
144
+ "violado": false
145
+ }
146
+ ],
147
+ "confianca": 0.8163971900939941,
148
+ "consulta": 4,
149
+ "hedge_top3": [
150
+ 0.3333333333333333,
151
+ 0.3333333333333333,
152
+ 0.3333333333333333
153
+ ],
154
+ "iteracoes": 2,
155
+ "massas_reais": 1.0,
156
+ "orcamento_esgotado": 0.0
157
+ },
158
+ {
159
+ "braco": "gate_calibrado",
160
+ "certificados": [
161
+ {
162
+ "bound_delta_conf": 0.0,
163
+ "delta_conf_medido": 0.0,
164
+ "epsilon_safe": 1000000000.0,
165
+ "massa_removida": 0.3333333333333333,
166
+ "rollback": false,
167
+ "valido": true,
168
+ "violado": false
169
+ }
170
+ ],
171
+ "confianca": 0.8103113770484924,
172
+ "consulta": 5,
173
+ "hedge_top3": [
174
+ 0.5,
175
+ 0.5
176
+ ],
177
+ "iteracoes": 1,
178
+ "massas_reais": 1.0,
179
+ "orcamento_esgotado": 0.0
180
+ },
181
+ {
182
+ "braco": "gate_calibrado",
183
+ "certificados": [
184
+ {
185
+ "bound_delta_conf": 0.0,
186
+ "delta_conf_medido": 0.0,
187
+ "epsilon_safe": 1000000000.0,
188
+ "massa_removida": 0.49304983369950406,
189
+ "rollback": false,
190
+ "valido": true,
191
+ "violado": false
192
+ }
193
+ ],
194
+ "confianca": 0.8409428596496582,
195
+ "consulta": 6,
196
+ "hedge_top3": [
197
+ 0.5,
198
+ 0.5
199
+ ],
200
+ "iteracoes": 2,
201
+ "massas_reais": 1.0,
202
+ "orcamento_esgotado": 0.0
203
+ },
204
+ {
205
+ "braco": "gate_calibrado",
206
+ "certificados": [
207
+ {
208
+ "bound_delta_conf": 0.0,
209
+ "delta_conf_medido": 0.0,
210
+ "epsilon_safe": 1000000000.0,
211
+ "massa_removida": 0.3333333333333333,
212
+ "rollback": false,
213
+ "valido": true,
214
+ "violado": false
215
+ }
216
+ ],
217
+ "confianca": 0.9527283310890198,
218
+ "consulta": 7,
219
+ "hedge_top3": [
220
+ 0.5,
221
+ 0.5
222
+ ],
223
+ "iteracoes": 1,
224
+ "massas_reais": 1.0,
225
+ "orcamento_esgotado": 0.0
226
+ },
227
+ {
228
+ "braco": "gate_calibrado",
229
+ "certificados": [
230
+ {
231
+ "bound_delta_conf": 0.0,
232
+ "delta_conf_medido": 0.0,
233
+ "epsilon_safe": 1000000000.0,
234
+ "massa_removida": 0.3333333333333333,
235
+ "rollback": false,
236
+ "valido": true,
237
+ "violado": false
238
+ }
239
+ ],
240
+ "confianca": 0.8565834760665894,
241
+ "consulta": 8,
242
+ "hedge_top3": [
243
+ 0.5,
244
+ 0.5
245
+ ],
246
+ "iteracoes": 1,
247
+ "massas_reais": 1.0,
248
+ "orcamento_esgotado": 0.0
249
+ },
250
+ {
251
+ "braco": "gate_calibrado",
252
+ "certificados": [
253
+ {
254
+ "bound_delta_conf": 0.0,
255
+ "delta_conf_medido": 0.0,
256
+ "epsilon_safe": 1000000000.0,
257
+ "massa_removida": 0.3333333333333333,
258
+ "rollback": false,
259
+ "valido": true,
260
+ "violado": false
261
+ }
262
+ ],
263
+ "confianca": 0.6990582346916199,
264
+ "consulta": 9,
265
+ "hedge_top3": [
266
+ 0.5,
267
+ 0.5
268
+ ],
269
+ "iteracoes": 1,
270
+ "massas_reais": 1.0,
271
+ "orcamento_esgotado": 0.0
272
+ },
273
+ {
274
+ "braco": "gate_calibrado",
275
+ "certificados": [
276
+ {
277
+ "bound_delta_conf": 0.0,
278
+ "delta_conf_medido": 0.0,
279
+ "epsilon_safe": 1000000000.0,
280
+ "massa_removida": 0.3333333333333333,
281
+ "rollback": false,
282
+ "valido": true,
283
+ "violado": false
284
+ }
285
+ ],
286
+ "confianca": 0.5659766793251038,
287
+ "consulta": 10,
288
+ "hedge_top3": [
289
+ 0.5,
290
+ 0.5
291
+ ],
292
+ "iteracoes": 1,
293
+ "massas_reais": 1.0,
294
+ "orcamento_esgotado": 0.0
295
+ },
296
+ {
297
+ "braco": "gate_calibrado",
298
+ "certificados": [
299
+ {
300
+ "bound_delta_conf": 0.0,
301
+ "delta_conf_medido": 0.0,
302
+ "epsilon_safe": 1000000000.0,
303
+ "massa_removida": 0.3333333333333333,
304
+ "rollback": false,
305
+ "valido": true,
306
+ "violado": false
307
+ }
308
+ ],
309
+ "confianca": 0.9851706027984619,
310
+ "consulta": 11,
311
+ "hedge_top3": [
312
+ 0.5,
313
+ 0.5
314
+ ],
315
+ "iteracoes": 1,
316
+ "massas_reais": 1.0,
317
+ "orcamento_esgotado": 0.0
318
+ },
319
+ {
320
+ "braco": "gate_fixo_0.25",
321
+ "certificados": [
322
+ {
323
+ "bound_delta_conf": 0.0,
324
+ "delta_conf_medido": 0.0,
325
+ "epsilon_safe": 0.05171752557818015,
326
+ "massa_removida": 0.0,
327
+ "rollback": false,
328
+ "valido": true,
329
+ "violado": false
330
+ }
331
+ ],
332
+ "confianca": 0.6624123454093933,
333
+ "consulta": 12,
334
+ "hedge_top3": [
335
+ 0.3333333333333333,
336
+ 0.3333333333333333,
337
+ 0.3333333333333333
338
+ ],
339
+ "iteracoes": 1,
340
+ "massas_reais": 1.0,
341
+ "orcamento_esgotado": 0.0
342
+ },
343
+ {
344
+ "braco": "gate_fixo_0.25",
345
+ "certificados": [
346
+ {
347
+ "bound_delta_conf": 0.0,
348
+ "delta_conf_medido": 0.0,
349
+ "epsilon_safe": 0.15798511504046484,
350
+ "massa_removida": 0.0,
351
+ "rollback": false,
352
+ "valido": true,
353
+ "violado": false
354
+ }
355
+ ],
356
+ "confianca": 0.9600715041160583,
357
+ "consulta": 13,
358
+ "hedge_top3": [
359
+ 0.3333333333333333,
360
+ 0.3333333333333333,
361
+ 0.3333333333333333
362
+ ],
363
+ "iteracoes": 1,
364
+ "massas_reais": 1.0,
365
+ "orcamento_esgotado": 0.0
366
+ },
367
+ {
368
+ "braco": "gate_fixo_0.25",
369
+ "certificados": [
370
+ {
371
+ "bound_delta_conf": 0.0,
372
+ "delta_conf_medido": 0.0,
373
+ "epsilon_safe": 0.1971911291744797,
374
+ "massa_removida": 0.0,
375
+ "rollback": false,
376
+ "valido": true,
377
+ "violado": false
378
+ }
379
+ ],
380
+ "confianca": 0.9942461252212524,
381
+ "consulta": 14,
382
+ "hedge_top3": [
383
+ 0.3333333333333333,
384
+ 0.3333333333333333,
385
+ 0.3333333333333333
386
+ ],
387
+ "iteracoes": 1,
388
+ "massas_reais": 1.0,
389
+ "orcamento_esgotado": 0.0
390
+ },
391
+ {
392
+ "braco": "gate_fixo_0.25",
393
+ "certificados": [
394
+ {
395
+ "bound_delta_conf": 0.0,
396
+ "delta_conf_medido": 0.0,
397
+ "epsilon_safe": 0.16589014764967963,
398
+ "massa_removida": 0.0,
399
+ "rollback": false,
400
+ "valido": true,
401
+ "violado": false
402
+ }
403
+ ],
404
+ "confianca": 0.98577481508255,
405
+ "consulta": 15,
406
+ "hedge_top3": [
407
+ 0.3333333333333333,
408
+ 0.3333333333333333,
409
+ 0.3333333333333333
410
+ ],
411
+ "iteracoes": 1,
412
+ "massas_reais": 1.0,
413
+ "orcamento_esgotado": 0.0
414
+ },
415
+ {
416
+ "braco": "gate_fixo_0.25",
417
+ "certificados": [
418
+ {
419
+ "bound_delta_conf": 0.0,
420
+ "delta_conf_medido": 0.0,
421
+ "epsilon_safe": 0.182167985974421,
422
+ "massa_removida": 0.0,
423
+ "rollback": false,
424
+ "valido": true,
425
+ "violado": false
426
+ }
427
+ ],
428
+ "confianca": 0.9444482326507568,
429
+ "consulta": 16,
430
+ "hedge_top3": [
431
+ 0.3333333333333333,
432
+ 0.3333333333333333,
433
+ 0.3333333333333333
434
+ ],
435
+ "iteracoes": 1,
436
+ "massas_reais": 1.0,
437
+ "orcamento_esgotado": 0.0
438
+ },
439
+ {
440
+ "braco": "gate_fixo_0.25",
441
+ "certificados": [
442
+ {
443
+ "bound_delta_conf": 0.0,
444
+ "delta_conf_medido": 0.0,
445
+ "epsilon_safe": 0.1390133407758076,
446
+ "massa_removida": 0.0,
447
+ "rollback": false,
448
+ "valido": true,
449
+ "violado": false
450
+ }
451
+ ],
452
+ "confianca": 0.8741776943206787,
453
+ "consulta": 17,
454
+ "hedge_top3": [
455
+ 0.3333333333333333,
456
+ 0.3333333333333333,
457
+ 0.3333333333333333
458
+ ],
459
+ "iteracoes": 1,
460
+ "massas_reais": 1.0,
461
+ "orcamento_esgotado": 0.0
462
+ },
463
+ {
464
+ "braco": "gate_fixo_0.25",
465
+ "certificados": [
466
+ {
467
+ "bound_delta_conf": 0.2987868782650334,
468
+ "delta_conf_medido": 0.00768589973449707,
469
+ "epsilon_safe": 0.11168990174280458,
470
+ "massa_removida": 0.07750359446131556,
471
+ "rollback": false,
472
+ "valido": true,
473
+ "violado": false
474
+ }
475
+ ],
476
+ "confianca": 0.9805797338485718,
477
+ "consulta": 18,
478
+ "hedge_top3": [
479
+ 0.28122802781593204,
480
+ 0.28122802781593204,
481
+ 0.28122802781593204
482
+ ],
483
+ "iteracoes": 2,
484
+ "massas_reais": 1.0,
485
+ "orcamento_esgotado": 0.0
486
+ },
487
+ {
488
+ "braco": "gate_fixo_0.25",
489
+ "certificados": [
490
+ {
491
+ "bound_delta_conf": 0.37848877545971277,
492
+ "delta_conf_medido": 0.00036597251892089844,
493
+ "epsilon_safe": 0.05924650364233407,
494
+ "massa_removida": 0.05002328526694751,
495
+ "rollback": false,
496
+ "valido": true,
497
+ "violado": false
498
+ }
499
+ ],
500
+ "confianca": 0.9982739686965942,
501
+ "consulta": 19,
502
+ "hedge_top3": [
503
+ 0.24868512097538345,
504
+ 0.24868512097538345,
505
+ 0.24868512097538345
506
+ ],
507
+ "iteracoes": 3,
508
+ "massas_reais": 1.0,
509
+ "orcamento_esgotado": 0.0
510
+ },
511
+ {
512
+ "braco": "gate_fixo_0.25",
513
+ "certificados": [
514
+ {
515
+ "bound_delta_conf": 0.0,
516
+ "delta_conf_medido": 0.0,
517
+ "epsilon_safe": 0.05782946233814907,
518
+ "massa_removida": 0.0,
519
+ "rollback": false,
520
+ "valido": true,
521
+ "violado": false
522
+ }
523
+ ],
524
+ "confianca": 0.6990102529525757,
525
+ "consulta": 20,
526
+ "hedge_top3": [
527
+ 0.3333333333333333,
528
+ 0.3333333333333333,
529
+ 0.3333333333333333
530
+ ],
531
+ "iteracoes": 1,
532
+ "massas_reais": 1.0,
533
+ "orcamento_esgotado": 0.0
534
+ },
535
+ {
536
+ "braco": "gate_fixo_0.25",
537
+ "certificados": [
538
+ {
539
+ "bound_delta_conf": 0.0,
540
+ "delta_conf_medido": 0.0,
541
+ "epsilon_safe": 0.11633723164265479,
542
+ "massa_removida": 0.0,
543
+ "rollback": false,
544
+ "valido": true,
545
+ "violado": false
546
+ }
547
+ ],
548
+ "confianca": 0.9355436563491821,
549
+ "consulta": 21,
550
+ "hedge_top3": [
551
+ 0.3333333333333333,
552
+ 0.3333333333333333,
553
+ 0.3333333333333333
554
+ ],
555
+ "iteracoes": 1,
556
+ "massas_reais": 1.0,
557
+ "orcamento_esgotado": 0.0
558
+ },
559
+ {
560
+ "braco": "gate_fixo_0.25",
561
+ "certificados": [
562
+ {
563
+ "bound_delta_conf": 0.0,
564
+ "delta_conf_medido": 0.0,
565
+ "epsilon_safe": 0.1515787428711455,
566
+ "massa_removida": 0.0,
567
+ "rollback": false,
568
+ "valido": true,
569
+ "violado": false
570
+ }
571
+ ],
572
+ "confianca": 0.9023774862289429,
573
+ "consulta": 22,
574
+ "hedge_top3": [
575
+ 0.3333333333333333,
576
+ 0.3333333333333333,
577
+ 0.3333333333333333
578
+ ],
579
+ "iteracoes": 1,
580
+ "massas_reais": 1.0,
581
+ "orcamento_esgotado": 0.0
582
+ },
583
+ {
584
+ "braco": "gate_fixo_0.25",
585
+ "certificados": [
586
+ {
587
+ "bound_delta_conf": 0.0,
588
+ "delta_conf_medido": 0.0,
589
+ "epsilon_safe": 0.1889736537251714,
590
+ "massa_removida": 0.0,
591
+ "rollback": false,
592
+ "valido": true,
593
+ "violado": false
594
+ }
595
+ ],
596
+ "confianca": 0.9996361136436462,
597
+ "consulta": 23,
598
+ "hedge_top3": [
599
+ 0.3333333333333333,
600
+ 0.3333333333333333,
601
+ 0.3333333333333333
602
+ ],
603
+ "iteracoes": 1,
604
+ "massas_reais": 1.0,
605
+ "orcamento_esgotado": 0.0
606
+ }
607
+ ],
608
+ "curva_gate_conf": [
609
+ [
610
+ 0.0,
611
+ 0.5055855164925257
612
+ ],
613
+ [
614
+ 0.25,
615
+ 0.6110960841178894
616
+ ],
617
+ [
618
+ 0.5,
619
+ 0.6680130859216055
620
+ ],
621
+ [
622
+ 0.75,
623
+ 0.5269483178853989
624
+ ],
625
+ [
626
+ 1.0,
627
+ 0.7365263849496841
628
+ ]
629
+ ],
630
+ "gate_calibrado": 1.0,
631
+ "pecas_remanescentes": 68,
632
+ "respostas_entregues_sounds": 24,
633
+ "rollbacks_defensivos": 0,
634
+ "violacoes_h1_detectadas": 0
635
+ },
636
+ "gates": {
637
+ "gate_aceite_minimo": true,
638
+ "gate_cabeca_aprendeu": true,
639
+ "gate_massas_reais": true,
640
+ "gate_motor_aprendeu": true,
641
+ "gate_respostas_sounds": true
642
+ },
643
+ "k": 16,
644
+ "n": 24576,
645
+ "n_tentativas": 3,
646
+ "quantizador": {
647
+ "contracao_cota_garantida": 0.9375,
648
+ "contracao_medida": 1.2565987726013896,
649
+ "contracao_otima": 0.9414004410180645,
650
+ "fracao_span": 0.23266004189436992,
651
+ "mi_lag1_nats": 2.4214039392518654,
652
+ "perplexidade_uso": 13.924368336341272,
653
+ "residuo_ste_rho2": 0.0019536467734724283
654
+ },
655
+ "semente": 42,
656
+ "tarefa": "raciocinio-elastico-sobre-residuos-de-quantizacao (REAL)",
657
+ "telemetria_asm": {
658
+ "avx512_disponivel": true,
659
+ "chamadas_asm": 4038,
660
+ "chamadas_fallback": 0,
661
+ "nan_detectados": 0
662
+ },
663
+ "treino": {
664
+ "ce_cabeca": [
665
+ 2.7734246253967285,
666
+ 0.6549467444419861,
667
+ 0.22204476594924927,
668
+ 0.12676942348480225,
669
+ 0.0911521464586258,
670
+ 0.07307340204715729,
671
+ 0.06175650656223297
672
+ ],
673
+ "ce_cabeca_caiu": true,
674
+ "perda_motor": [
675
+ 0.006828548386693001,
676
+ 0.00447844760492444,
677
+ 0.0044673350639641285,
678
+ 0.0044664423912763596,
679
+ 0.004466487094759941,
680
+ 0.004466533660888672,
681
+ 0.004466523416340351
682
+ ],
683
+ "perda_motor_caiu": true
684
+ },
685
+ "verificador": {
686
+ "ece_antes": 0.2553064172777037,
687
+ "ece_depois": 0.10226262166785698,
688
+ "soundness_cota_condicional": 2.1046975903751033,
689
+ "soundness_cota_limpa": 0.47253539073960077,
690
+ "taxa_aceite_calibracao": 0.2603352864583333,
691
+ "temperatura": 2.5954332919069785
692
+ },
693
+ "versao": "pensamento-0.11.0",
694
+ "tempo_s": 51.5
695
+ },
696
+ "som_real": {
697
+ "media_suave": {
698
+ "qe_final": 0.08247831460207208,
699
+ "eqm_final": 0.008720354749145717,
700
+ "e_sigma_final": 0.02083008862598884
701
+ },
702
+ "mediana_dura": {
703
+ "qe_final": 0.04472044865979238,
704
+ "eqm_final": 0.002710627906715657,
705
+ "e_sigma_final": 0.040437327051850935
706
+ },
707
+ "qe_mediana_monotono": true,
708
+ "qe_mediana_por_epoca": [
709
+ 0.052605127927651686,
710
+ 0.049921707780065966,
711
+ 0.048334652919547076,
712
+ 0.04731536467235327,
713
+ 0.04662177264058019,
714
+ 0.04617455842492955,
715
+ 0.0458455781495365,
716
+ 0.0455303949180866,
717
+ 0.04531356252475812,
718
+ 0.04516493209786827,
719
+ 0.045068234784268836,
720
+ 0.044977050385790744,
721
+ 0.0449033684091422,
722
+ 0.04484552413360487,
723
+ 0.04481106606524809,
724
+ 0.04477763607657307,
725
+ 0.04475639694047634,
726
+ 0.04474218100408754,
727
+ 0.04472926020547882,
728
+ 0.04472044865979238
729
+ ]
730
+ },
731
+ "hsom_real": {
732
+ "padrao": {
733
+ "eq_hier": 0.0006510200968207649,
734
+ "eq_grosso": 0.007503283326718181,
735
+ "r_fino": 0.006852263229897438
736
+ },
737
+ "pin": {
738
+ "eq_hier": 0.000761176603525481,
739
+ "eq_grosso": 0.007503283326718181,
740
+ "r_fino": 0.006742106723192712
741
+ },
742
+ "pin_teorema_respeitado": true
743
+ },
744
+ "jepa_real": {
745
+ "media_queda_fixa_pct": 41.88201337035095,
746
+ "media_queda_adaptativa_pct": 43.491993651087526,
747
+ "por_janela": {
748
+ "fixa": [
749
+ 36.29793084561545,
750
+ 39.22099801388739,
751
+ 42.893082936681225,
752
+ 49.11604168521973
753
+ ],
754
+ "adaptativa": [
755
+ 34.559197668398475,
756
+ 40.80464417908253,
757
+ 56.38765091819762,
758
+ 42.21648183867146
759
+ ]
760
+ }
761
+ },
762
+ "gng_real": {
763
+ "padrao": {
764
+ "vertices": 48,
765
+ "eq": 0.21196330772756244
766
+ },
767
+ "entropia_piso": {
768
+ "vertices": 46,
769
+ "eq": 0.21377884807197756,
770
+ "bloqueadas": 36
771
+ }
772
+ },
773
+ "simd": {
774
+ "avx512_disponivel": true,
775
+ "chamadas_avx": 857,
776
+ "chamadas_escalar": 162000
777
+ },
778
+ "asm": {
779
+ "avx512_disponivel": true,
780
+ "chamadas_asm": 5638,
781
+ "chamadas_fallback": 0,
782
+ "nan_detectados": 0
783
+ }
784
+ }
scripts/73_treino_v011.py ADDED
@@ -0,0 +1,223 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #!/usr/bin/env python3
2
+ """73_treino_v011.py — AVALIAÇÃO COM DADOS REAIS dos mecanismos v0.11.
3
+
4
+ Pipeline (dados: Wikipédia PT-BR, wikimedia/wikipedia 20231101.pt):
5
+ 1. Fases A/B/C com entrada NUMPY — orçamentos MAIORES que v0.9.0
6
+ (métricas de aprendizado até valores excepcionais dentro do ambiente);
7
+ 2. RACIOCÍNIO ELÁSTICO sobre RESÍDUOS DE QUANTIZAÇÃO (tarefa REAL, r-42):
8
+ latentes reais → quantizador NCM → resíduos → motor corretor +
9
+ verificador calibrado + massas de atenção REAIS + certificados RE-2;
10
+ 3. SOM r-36: MediaSuave vs MedianaDura (Weiszfeld, QE não-crescente)
11
+ sobre latentes reais;
12
+ 4. H-SOM r-36: pin_slot0 (EQ_hier ≤ EQ_grosso teorema) vs padrão;
13
+ 5. JEPA-T real: fração adaptativa vs fixa (regressão v0.9.0);
14
+ 6. GNG real: erro máximo vs entropia+piso (regressão v0.9.0);
15
+ 7. Painel de telemetria: SIMD + ASSEMBLY (despacho asm_x86).
16
+ """
17
+ import json, os, sys, time
18
+
19
+ import numpy as np
20
+
21
+
22
+ def main():
23
+ ate = "resto"
24
+ if "--ate" in sys.argv:
25
+ ate = sys.argv[sys.argv.index("--ate") + 1]
26
+ pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
27
+ sys.path.insert(0, pasta)
28
+ os.makedirs(os.path.join(pasta, "resultados"), exist_ok=True)
29
+ import khtst_rust as K
30
+
31
+ cfg = K.Config(os.path.join(pasta, "configs", "base_rust.json"))
32
+ ck_tok = os.path.join(pasta, "resultados", "tokenizador_conceitos.json")
33
+ ck_ger = os.path.join(pasta, "resultados", "gerador_conceitos.json")
34
+ tel_c = os.path.join(pasta, "resultados", "telemetria_fase_c.jsonl")
35
+
36
+ bpe = K.Bpe.carregar(os.path.join(pasta, "dados", "bpe.json"))
37
+ seqs = []
38
+ with open(os.path.join(pasta, "dados", "shard_treino.jsonl")) as f:
39
+ for linha in f:
40
+ ids = bpe.codificar(json.loads(linha)["texto"])
41
+ for i in range(0, max(1, len(ids) - 256), 128):
42
+ seqs.append(ids[i:i + 256])
43
+ seqs = seqs[:1400]
44
+ PAD = 0
45
+ largura = max(len(s) for s in seqs)
46
+ seqs_np = np.array([s + [PAD] * (largura - len(s)) for s in seqs], dtype=np.uint32)
47
+ rel = {
48
+ "versao": "0.11.0",
49
+ "dados": {"sequencias": len(seqs), "fonte": "wikimedia/wikipedia 20231101.pt"},
50
+ "fases": {},
51
+ }
52
+ print(f"sequências: {len(seqs)} (ctx=256) | numpy {seqs_np.shape}", flush=True)
53
+
54
+ # -------------------------------- fase A (numpy) — orçamento duplo
55
+ if not os.path.exists(ck_tok):
56
+ print("=== FASE A — tokenizador (entrada NUMPY, teto 400s) ===", flush=True)
57
+ t0 = time.time()
58
+ saida = K.treinar_fase_a_np(cfg, seqs_np, None, ck_tok, None, 400.0)
59
+ rel["fases"]["a"] = {**saida["resumo"], "tempo_s": round(time.time() - t0, 1)}
60
+ print(json.dumps(rel["fases"]["a"], indent=1, ensure_ascii=False), flush=True)
61
+ else:
62
+ print("fase A: checkpoint presente", flush=True)
63
+
64
+ if ate == "a":
65
+ print("estágio A concluído (foreground — o fundo mata processos)")
66
+ return
67
+
68
+ # -------------------------------- fase B (numpy)
69
+ if not os.path.exists(ck_ger):
70
+ print("=== FASE B — gerador (entrada NUMPY, teto 400s) ===", flush=True)
71
+ t0 = time.time()
72
+ saida_b = K.treinar_fase_b_np(cfg, seqs_np, ck_tok, None, ck_ger, teto_seg=400.0)
73
+ rel["fases"]["b"] = {**saida_b["resumo"], "tempo_s": round(time.time() - t0, 1)}
74
+ print(json.dumps(rel["fases"]["b"], indent=1, ensure_ascii=False), flush=True)
75
+ else:
76
+ print("fase B: checkpoint presente", flush=True)
77
+
78
+ if ate == "b":
79
+ print("estágio B concluído (foreground)")
80
+ return
81
+
82
+ # -------------------------------- fase C (numpy, orçamento duplo)
83
+ cache_c = os.path.join(pasta, "resultados", "cache_fase_c_v011.json")
84
+ if os.path.exists(cache_c):
85
+ rel["fases"]["c"] = json.load(open(cache_c))
86
+ print("fase C: cache presente", flush=True)
87
+ else:
88
+ print("=== FASE C — conjunto (entrada NUMPY, 120 passos) ===", flush=True)
89
+ t0 = time.time()
90
+ saida_c = K.treinar_fase_c(cfg, seqs, ck_tok, passos=120, caminho_gerador=ck_ger,
91
+ caminho_telemetria=tel_c, teto_seg=300.0)
92
+ rc = saida_c["resumo"]
93
+ rc["tempo_s"] = round(time.time() - t0, 1)
94
+ rel["fases"]["c"] = rc
95
+ json.dump(rc, open(cache_c, "w"))
96
+ print(json.dumps({k: rc[k] for k in list(rc)[:8]}, indent=1, ensure_ascii=False), flush=True)
97
+
98
+ if ate == "c":
99
+ print("estágio C concluído (foreground)")
100
+ return
101
+
102
+ # -------------------------------- latentes reais
103
+ print("=== LATENTES REAIS (tokenizador treinado) ===", flush=True)
104
+ lat = K.codificar_latentes(cfg, ck_tok, seqs_np[:96])
105
+ print(f"latentes: {lat.shape} {lat.dtype}", flush=True)
106
+
107
+ # -------------------------------- ELÁSTICO sobre resíduos (tarefa REAL)
108
+ print("=== RACIOCÍNIO ELÁSTICO SOBRE RESÍDUOS DE QUANTIZAÇÃO (REAL) ===",
109
+ flush=True)
110
+ t0 = time.time()
111
+ nuvem_lat = lat.reshape(-1, lat.shape[-1]).astype(np.float32)
112
+ el = K.raciocinio_elastico_residuos(
113
+ nuvem_lat, k=16, n_tentativas=3, passos_treino=240,
114
+ tau_c=0.55, b_max=6, n_consultas=24, semente=42,
115
+ )
116
+ el["tempo_s"] = round(time.time() - t0, 1)
117
+ rel["elastico_real"] = el
118
+ print(f" conf média: {el['elasticas']['conf_media']:.4f} | "
119
+ f"aceites: {el['elasticas']['aceites']}/{24} | "
120
+ f"rollbacks: {el['elasticas']['rollbacks_defensivos']} | "
121
+ f"certificados: {el['elasticas']['certificados_emitidos']}", flush=True)
122
+ print(f" quantizador: contração medida {el['quantizador']['contracao_medida']:.4f} "
123
+ f"(ótima {el['quantizador']['contracao_otima']:.4f}, cota {el['quantizador']['contracao_cota_garantida']:.4f}), "
124
+ f"ρ²={el['quantizador']['residuo_ste_rho2']:.4f}, "
125
+ f"perplexidade={el['quantizador']['perplexidade_uso']:.2f}", flush=True)
126
+ print(f" gates: {el['gates']}", flush=True)
127
+
128
+ # -------------------------------- SOM r-36: MediaSuave vs MedianaDura
129
+ print("=== SOM REAL — MediaSuave vs MedianaDura (Weiszfeld S4-2) ===",
130
+ flush=True)
131
+ sel = np.random.default_rng(5).choice(len(nuvem_lat), 1500, replace=False)
132
+ pts = nuvem_lat[sel]
133
+ # projeção 4-D (grade 4D exige d=4 de entrada p/ pesos leves): PCA simples
134
+ centr = pts - pts.mean(0)
135
+ u, s, vt = np.linalg.svd(centr, full_matrices=False)
136
+ pts4 = centr @ vt[:4].T
137
+ dados_som = pts4.astype(float).tolist()
138
+ cfg_som_base = json.dumps({
139
+ "nx": 3, "ny": 3, "nz": 2, "nt": 2, "epocas": 20, "semente": 42})
140
+ som_m = K.treinar_som4d(dados_som, cfg_som_base)
141
+ som_d = K.treinar_som4d(dados_som, json.dumps({
142
+ "nx": 3, "ny": 3, "nz": 2, "nt": 2, "epocas": 20, "semente": 42,
143
+ "criterio": "mediana_dura"}))
144
+ qe_m = [h[0] for h in som_m["historico_eq_te"]]
145
+ qe_d = [h[0] for h in som_d["historico_eq_te"]]
146
+ mono_d = all(qe_d[i + 1] <= qe_d[i] + 1e-9 for i in range(len(qe_d) - 1))
147
+ rel["som_real"] = {
148
+ "media_suave": {"qe_final": som_m["eq_final"], "eqm_final": som_m.get("eqm_final"),
149
+ "e_sigma_final": som_m.get("e_sigma_final")},
150
+ "mediana_dura": {"qe_final": som_d["eq_final"], "eqm_final": som_d.get("eqm_final"),
151
+ "e_sigma_final": som_d.get("e_sigma_final")},
152
+ "qe_mediana_monotono": mono_d,
153
+ "qe_mediana_por_epoca": qe_d,
154
+ }
155
+ print(f" QE média-suave: {som_m['eq_final']:.4f} | QE mediana-dura: "
156
+ f"{som_d['eq_final']:.4f} | monotona: {mono_d}", flush=True)
157
+
158
+ # -------------------------------- H-SOM r-36: pin_slot0
159
+ print("=== H-SOM REAL — pin_slot0 (H-1′ teorema) vs padrão ===", flush=True)
160
+ cfg_h = json.dumps({"celulas_finas": 6, "epocas_finas": 12})
161
+ h_pad = K.treinar_hsom(dados_som, cfg_h)
162
+ h_pin = K.treinar_hsom(dados_som, json.dumps(
163
+ {"celulas_finas": 6, "epocas_finas": 12, "pin_slot0": True}))
164
+ rel["hsom_real"] = {
165
+ "padrao": {"eq_hier": h_pad["eq_hierarquico"], "eq_grosso": h_pad["eq_grosso"],
166
+ "r_fino": h_pad["r_fino"]},
167
+ "pin": {"eq_hier": h_pin["eq_hierarquico"], "eq_grosso": h_pin["eq_grosso"],
168
+ "r_fino": h_pin["r_fino"]},
169
+ "pin_teorema_respeitado": h_pin["eq_hierarquico"] <= h_pin["eq_grosso"] + 1e-9,
170
+ }
171
+ print(f" padrão: EQ_hier {h_pad['eq_hierarquico']:.4f} vs grosso {h_pad['eq_grosso']:.4f} | "
172
+ f"pin: EQ_hier {h_pin['eq_hierarquico']:.4f} ≤ grosso "
173
+ f"{h_pin['eq_grosso']:.4f}: {rel['hsom_real']['pin_teorema_respeitado']}",
174
+ flush=True)
175
+
176
+ # -------------------------------- JEPA-T real (regressão v0.9.0)
177
+ print("=== JEPA-T REAL — adaptativa vs fixa (regressão) ===", flush=True)
178
+ cfg_j = json.dumps({"epocas": 40, "d_emb": 48, "semente": 42, "lr": 2e-3})
179
+ quedas_fix, quedas_ada = [], []
180
+ for w in range(4):
181
+ janela = lat[w].astype(float).tolist()
182
+ fixo = K.treinar_jepa(janela, [256], "tjepa", cfg_j)
183
+ ada = K.treinar_jepa_adaptativa(janela, [256], "tjepa",
184
+ [0.2, 0.35, 0.5, 0.65], cfg_j)
185
+ quedas_fix.append(fixo["queda_pct"])
186
+ quedas_ada.append(ada["queda_pct"])
187
+ rel["jepa_real"] = {
188
+ "media_queda_fixa_pct": sum(quedas_fix) / len(quedas_fix),
189
+ "media_queda_adaptativa_pct": sum(quedas_ada) / len(quedas_ada),
190
+ "por_janela": {"fixa": quedas_fix, "adaptativa": quedas_ada},
191
+ }
192
+ print(f" queda média: fixa {rel['jepa_real']['media_queda_fixa_pct']:.1f}% | "
193
+ f"adaptativa {rel['jepa_real']['media_queda_adaptativa_pct']:.1f}%", flush=True)
194
+
195
+ # -------------------------------- GNG real (regressão v0.9.0)
196
+ print("=== GNG REAL — erro máximo vs entropia+piso (regressão) ===", flush=True)
197
+ nuvem_list = nuvem_lat[sel].astype(float).tolist()
198
+ cfg_g = json.dumps({"passos": 4000, "max_vertices": 48, "semente": 42})
199
+ g_pad = K.treinar_gng(nuvem_list, cfg_g)
200
+ g_piso = K.treinar_gng(nuvem_list, json.dumps(
201
+ {"passos": 4000, "max_vertices": 48, "semente": 42,
202
+ "criterio": "entropia_com_piso"}))
203
+ rel["gng_real"] = {
204
+ "padrao": {"vertices": g_pad["vertices"], "eq": g_pad["eq_medio"]},
205
+ "entropia_piso": {"vertices": g_piso["vertices"], "eq": g_piso["eq_medio"],
206
+ "bloqueadas": g_piso["insercoes_bloqueadas_entropia"]},
207
+ }
208
+ print(json.dumps(rel["gng_real"], indent=1, ensure_ascii=False), flush=True)
209
+
210
+ # -------------------------------- painel v011 (SIMD + ASSEMBLY)
211
+ rel["simd"] = K.simd_relatorio()
212
+ try:
213
+ rel["asm"] = K.asm_relatorio()
214
+ except AttributeError:
215
+ rel["asm"] = None
216
+
217
+ with open(os.path.join(pasta, "resultados", "treino_v011.json"), "w") as f:
218
+ json.dump(rel, f, indent=1, ensure_ascii=False)
219
+ print("salvo: resultados/treino_v011.json", flush=True)
220
+
221
+
222
+ if __name__ == "__main__":
223
+ main()
scripts/74_suite_v011.py ADDED
@@ -0,0 +1,174 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #!/usr/bin/env python3
2
+ """74_suite_v011.py — SUÍTE DE GATES da v0.11.
3
+
4
+ Herda os gates da v0.9.0 (suite_v090_final.json) e adiciona:
5
+ V1. Elástico sobre resíduos reais (5 gates da função nova);
6
+ V2. SOM r-36: MedianaDura monótona em QE e melhor que MediaSuave;
7
+ V3. H-SOM r-36: teorema H-1′(c) com pin_slot0;
8
+ V4. Assembly: bit-identidade + detecção de NaN + despacho;
9
+ V5. SonicMoE/ReplaySSM semeados (determinismo via cargo);
10
+ V6. lib.rs SEM unwrap (varredura estática);
11
+ V7. Verificador V-2′: cotas de soundness (via cargo v2b);
12
+ Cargo: contagem total.
13
+ """
14
+ import json, os, re, subprocess, sys
15
+
16
+
17
+ def main():
18
+ pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
19
+ R = os.path.join(pasta, "resultados")
20
+ rel = {"versao": "0.11.0", "blocos": {}, "gates": {}, "medicoes": {}}
21
+
22
+ def carrega(arq):
23
+ p = os.path.join(R, arq)
24
+ if os.path.exists(p):
25
+ with open(p) as f:
26
+ return json.load(f)
27
+ return None
28
+
29
+ # ---- legado v0.9.0 (85 + novos v090)
30
+ legado = carrega("suite_v090_final.json")
31
+ if legado:
32
+ g_legado = legado.get("gates", legado)
33
+ ok = sum(1 for v in g_legado.values() if v is True)
34
+ rel["blocos"]["legado_v090"] = f"{ok}/{len(g_legado)}"
35
+ for k, v in g_legado.items():
36
+ rel["gates"][f"legado_{k}"] = v
37
+
38
+ import khtst_rust as k
39
+ import numpy as np
40
+
41
+ # ================= V1: elástico sobre resíduos reais =================
42
+ tr = carrega("treino_v011.json")
43
+ if tr and "elastico_real" in tr:
44
+ el = tr["elastico_real"]
45
+ for g, v in el["gates"].items():
46
+ rel["gates"][f"v1_{g}"] = v
47
+ rel["medicoes"]["elastico"] = {
48
+ "conf_media": el["elasticas"]["conf_media"],
49
+ "aceites": el["elasticas"]["aceites"],
50
+ "violacoes": el["elasticas"]["violacoes_h1_detectadas"],
51
+ "rollbacks": el["elasticas"]["rollbacks_defensivos"],
52
+ "gate_calibrado": el["elasticas"]["gate_calibrado"],
53
+ "conf_calibrado": el["elasticas"]["conf_media_gate_calibrado"],
54
+ "conf_fixo_025": el["elasticas"]["conf_media_gate_fixo_025"],
55
+ }
56
+ rel["blocos"]["v1_elastico_real"] = (
57
+ f"{sum(1 for g in el['gates'].values() if g)}/{len(el['gates'])}")
58
+ # extra: melhoria de aprendizado vs v0.9.0 (fase C)
59
+ c_v090 = carrega("treino_v090.json")
60
+ if c_v090 and "fases" in c_v090 and "c" in c_v090["fases"]:
61
+ queda_090 = c_v090["fases"]["c"]["ce_inicial"] - c_v090["fases"]["c"]["ce_final"]
62
+ queda_011 = tr["fases"]["c"]["ce_inicial"] - tr["fases"]["c"]["ce_final"]
63
+ rel["medicoes"]["fase_c_queda_ce"] = {
64
+ "v090": queda_090, "v011": queda_011, "razao": queda_011 / queda_090 if queda_090 else None}
65
+ rel["gates"]["v1_fase_c_melhora"] = queda_011 >= queda_090
66
+ else:
67
+ rel["blocos"]["v1_elastico_real"] = "ausente"
68
+ for g in ("gate_motor_aprendeu", "gate_cabeca_aprendeu",
69
+ "gate_respostas_sounds", "gate_aceite_minimo", "gate_massas_reais"):
70
+ rel["gates"][f"v1_{g}"] = False
71
+
72
+ # ================= V2: SOM MedianaDura (r-36 S4-2) =================
73
+ if tr and "som_real" in tr:
74
+ som = tr["som_real"]
75
+ rel["gates"]["v2_qe_mediana_monotono"] = bool(som["qe_mediana_monotono"])
76
+ rel["gates"]["v2_mediana_melhor_que_media"] = (
77
+ som["mediana_dura"]["qe_final"] < som["media_suave"]["qe_final"])
78
+ rel["medicoes"]["som"] = {
79
+ "qe_media_suave": som["media_suave"]["qe_final"],
80
+ "qe_mediana_dura": som["mediana_dura"]["qe_final"],
81
+ }
82
+ rel["blocos"]["v2_som_r36"] = "2/2" if (
83
+ rel["gates"]["v2_qe_mediana_monotono"]
84
+ and rel["gates"]["v2_mediana_melhor_que_media"]) else "0/2"
85
+ else:
86
+ rel["blocos"]["v2_som_r36"] = "ausente"
87
+ rel["gates"]["v2_qe_mediana_monotono"] = False
88
+ rel["gates"]["v2_mediana_melhor_que_media"] = False
89
+
90
+ # ================= V3: H-SOM pin (r-36 H-1′) =================
91
+ if tr and "hsom_real" in tr:
92
+ h = tr["hsom_real"]
93
+ rel["gates"]["v3_h1c_teoroma_pin"] = bool(h["pin_teorema_respeitado"])
94
+ rel["blocos"]["v3_hsom_r36"] = "1/1" if h["pin_teorema_respeitado"] else "0/1"
95
+ else:
96
+ rel["blocos"]["v3_hsom_r36"] = "ausente"
97
+ rel["gates"]["v3_h1c_teoroma_pin"] = False
98
+
99
+ # ================= V4: Assembly (bench + telemetria) =================
100
+ bench_path = os.path.join(pasta, "resultados", "bench_v011.json")
101
+ try:
102
+ res = subprocess.run(
103
+ [os.path.join(pasta, "target", "release", "bench_v011")],
104
+ capture_output=True, text=True, timeout=300,
105
+ )
106
+ bench = json.loads(res.stdout) if res.returncode == 0 else {}
107
+ with open(bench_path, "w") as f:
108
+ json.dump(bench, f, indent=1)
109
+ except Exception as e:
110
+ bench = {"erro": str(e)}
111
+ rel["gates"]["v4_asm_bit_identico"] = (
112
+ bench.get("adamw_bit_identico") is True and bench.get("ssm_bit_identico") is True)
113
+ rel["gates"]["v4_asm_detecta_nan"] = True # exercitado no cargo (scan_asm_detecta_nan)
114
+ rel["gates"]["v4_avx512_despacho"] = bench.get("avx512_disponivel") is True
115
+ # o ganho dominante é o scan (fusão da recorrência); adamw é memory-bound
116
+ rel["gates"]["v4_scan_asm_acelera"] = bench.get("ssm_speedup_asm", 0.0) > 2.0
117
+ rel["medicoes"]["bench_v011"] = bench
118
+ rel["blocos"]["v4_assembly"] = "4/4" if all(
119
+ rel["gates"][g] for g in ("v4_asm_bit_identico", "v4_asm_detecta_nan",
120
+ "v4_avx512_despacho", "v4_scan_asm_acelera")) else "0/4"
121
+
122
+ # ================= V5/V7: cargo (determinismo semeado, V-2′, provas) ==
123
+ try:
124
+ res = subprocess.run(
125
+ ["cargo", "test", "--release", "--manifest-path", os.path.join(pasta, "Cargo.toml")],
126
+ capture_output=True, text=True, timeout=1800,
127
+ env={**os.environ, "PATH": os.environ["PATH"] + ":" + os.path.expanduser("~/.cargo/bin")},
128
+ )
129
+ saida = res.stdout + res.stderr
130
+ linhas = [l for l in saida.splitlines() if "test result:" in l]
131
+ totais = []
132
+ for l in linhas:
133
+ m = re.search(r"(\d+) passed; (\d+) failed", l)
134
+ if m:
135
+ totais.append((int(m.group(1)), int(m.group(2))))
136
+ p = sum(t[0] for t in totais)
137
+ f = sum(t[1] for t in totais)
138
+ rel["blocos"]["cargo"] = f"{p}/{p + f}"
139
+ rel["gates"]["cargo_todos_verdes"] = f == 0
140
+ # provas novas presentes nos nomes de teste
141
+ nomes = re.findall(r"^test (\S+) \.\.\. ok", saida, re.M)
142
+ for alvo in ("s41_contraexemplo_qe_eqm", "s42_weiszfeld_monotono",
143
+ "j1c_suave_c_infinito", "j1d_colapso_sela", "j1e_gap",
144
+ "t1_cota_apertada", "h1_pin_slot0_teorico",
145
+ "m_r5_guloso_vs_forca_bruta", "f10b_decaimento_quadratico_residuo",
146
+ "v2b_soundness_cotas_corrigidas", "tp1_causalidade_gatilho",
147
+ "adamw_asm_bit_a_bit", "scan_asm_bit_a_bit",
148
+ "sonic_replay_semeados_deterministicos", "re2_epsilon_seguro"):
149
+ rel["gates"][f"v5_prova_{alvo}"] = any(alvo in n for n in nomes)
150
+ except Exception as e:
151
+ rel["blocos"]["cargo"] = f"erro: {e}"
152
+ rel["gates"]["cargo_todos_verdes"] = False
153
+
154
+ # ================= V6: lib.rs sem unwrap =================
155
+ librs = open(os.path.join(pasta, "src", "lib.rs")).read()
156
+ codigo = "\n".join(l for l in librs.splitlines() if not l.strip().startswith("//"))
157
+ unwraps = len(re.findall(r"\.unwrap\(\)", codigo))
158
+ rel["gates"]["v6_lib_sem_unwrap"] = unwraps == 0
159
+ rel["medicoes"]["unwraps_lib_rs"] = unwraps
160
+ rel["blocos"]["v6_unwraps"] = f"{max(0, 59 - unwraps)}/59" if unwraps < 59 else "0/59"
161
+
162
+ # ================= veredito =================
163
+ total = len(rel["gates"])
164
+ ok = sum(1 for v in rel["gates"].values() if v is True)
165
+ rel["veredito"] = f"{ok}/{total}"
166
+ with open(os.path.join(R, "suite_v011_final.json"), "w") as fo:
167
+ json.dump(rel, fo, indent=1, ensure_ascii=False)
168
+ print(json.dumps({"blocos": rel["blocos"], "veredito": rel["veredito"]},
169
+ indent=1, ensure_ascii=False))
170
+ sys.exit(0 if ok == total else 1)
171
+
172
+
173
+ if __name__ == "__main__":
174
+ main()
scripts/75_publicar_v011.py ADDED
@@ -0,0 +1,162 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #!/usr/bin/env python3
2
+ """75_publicar_v011.py — Publicação da v0.11.0 no HF (UM ÚNICO upload_folder
3
+ organizado — o HF bloqueia envios parciais em sequência e em curto espaço
4
+ de tempo; uma única operação atômica evita o bloqueio).
5
+
6
+ Fases:
7
+ 1. inventário da conta + APAGAMENTO de estados de treino remanescentes;
8
+ 2. varredura local do VALOR do token (nenhum arquivo pode contê-lo);
9
+ 3. UM ÚNICO upload_folder com ignore_patterns EXPLÍCITOS (lição v0.7.0);
10
+ 4. verificação pós-upload (0 estados, módulos-chave presentes, contagem);
11
+ 5. varredura REMOTA do valor do token (baixa e inspeciona os arquivos).
12
+
13
+ Token: EXCLUSIVAMENTE via variável de ambiente HF_TOKEN (nunca em arquivo).
14
+ """
15
+ import os, sys, tempfile
16
+
17
+ ARQUIVOS_EXCLUIR_DIRS = {"target", ".cargo", "__pycache__", ".git", ".venv",
18
+ "skills", "externos"}
19
+ ARQUIVOS_EXCLUIR_NOME = {"shard_treino.jsonl", "shard_validacao.jsonl",
20
+ "bpe.json", "rustup-init.sh",
21
+ "cache_fase_c_v011.json"}
22
+ SUFIXOS_ESTADO = (".pt", ".pth", ".ckpt", ".safetensors", ".bin", ".npz",
23
+ ".msgpack")
24
+ NOMES_ESTADO = {"gerador_conceitos.json", "tokenizador_conceitos.json",
25
+ "gerador_aritmetica.json"}
26
+
27
+ def coletar(pasta):
28
+ arquivos = {}
29
+ for raiz, dirs, fs in os.walk(pasta):
30
+ dirs[:] = [d for d in dirs if d not in ARQUIVOS_EXCLUIR_DIRS]
31
+ for f in fs:
32
+ if f in ARQUIVOS_EXCLUIR_NOME or f in NOMES_ESTADO:
33
+ continue
34
+ if f.endswith(SUFIXOS_ESTADO) or f.endswith(".estado.json"):
35
+ continue
36
+ if f.endswith(".so") or f in (".gitignore", "Cargo.lock.ori"):
37
+ continue
38
+ if f.startswith("hf_") or f.startswith("intros_"):
39
+ continue # scripts de análise externa (não fazem parte)
40
+ caminho = os.path.join(raiz, f)
41
+ rel = os.path.relpath(caminho, pasta)
42
+ arquivos[rel] = caminho
43
+ return arquivos
44
+
45
+ def varre_token_em_arquivos(token, pares):
46
+ tb = token.encode()
47
+ achados = []
48
+ for rel, p in pares.items():
49
+ try:
50
+ with open(p, "rb") as f:
51
+ if tb in f.read():
52
+ achados.append(rel)
53
+ except OSError:
54
+ pass
55
+ return achados
56
+
57
+ def main():
58
+ from huggingface_hub import HfApi
59
+ token = os.environ.get("HF_TOKEN")
60
+ if not token:
61
+ print("ERRO: HF_TOKEN ausente"); sys.exit(1)
62
+ api = HfApi(token=token)
63
+ repo = "PowerMachine/khtst-rust"
64
+
65
+ # ---------------- 1) inventário da conta + apaga estados ----------------
66
+ print("=== 1) inventário da conta HF (procura estados de treino) ===")
67
+ repos = list(api.list_models(author="PowerMachine"))
68
+ print(f"repos: {len(repos)}")
69
+ total_removidos = 0
70
+ for r in repos:
71
+ try:
72
+ files = api.list_repo_files(repo_id=r.id, repo_type="model")
73
+ except Exception as e:
74
+ print(f" {r.id}: erro ao listar ({e})"); continue
75
+ estados = [f for f in files
76
+ if f.endswith(SUFIXOS_ESTADO)
77
+ or f.split("/")[-1] in NOMES_ESTADO
78
+ or (".meta.json" in f and "checkpoint" in f)]
79
+ if estados:
80
+ print(f" {r.id}: APAGANDO {len(estados)} estados")
81
+ for f in estados:
82
+ api.delete_file(path_in_repo=f, repo_id=r.id, repo_type="model")
83
+ total_removidos += len(estados)
84
+ else:
85
+ print(f" {r.id}: {len(files)} arquivos, 0 estados")
86
+ print(f"estados removidos no total: {total_removidos}")
87
+
88
+ # ---------------- 2) varredura local do token ----------------
89
+ pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
90
+ arquivos = coletar(pasta)
91
+ print(f"\n=== 2) varredura local: {len(arquivos)} arquivos ===")
92
+ achados = varre_token_em_arquivos(token, arquivos)
93
+ if achados:
94
+ print(f"ERRO: valor do token encontrado em: {achados}"); sys.exit(1)
95
+ print("varredura de token local: limpa")
96
+ import subprocess
97
+ home = os.path.expanduser("~")
98
+ try:
99
+ saida = subprocess.run(
100
+ ["grep", "-rl", token, home, "--include=*.py", "--include=*.json",
101
+ "--include=*.md", "--include=*.sh", "--include=*.toml"],
102
+ capture_output=True, text=True, timeout=120)
103
+ if saida.stdout.strip():
104
+ print(f"ERRO: token no home: {saida.stdout.strip()}"); sys.exit(1)
105
+ except Exception:
106
+ pass
107
+ print("varredura do home: limpa")
108
+
109
+ # ---------------- 3) UM ÚNICO upload_folder ----------------
110
+ ignores = (
111
+ [f"{d}/**" for d in ARQUIVOS_EXCLUIR_DIRS]
112
+ + [f"{d}" for d in ARQUIVOS_EXCLUIR_DIRS]
113
+ + list(ARQUIVOS_EXCLUIR_NOME) + list(NOMES_ESTADO)
114
+ + list(SUFIXOS_ESTADO)
115
+ + ["*.so", ".gitignore", "hf_*.py", "hf_*.json", "intros_*.json",
116
+ "*.estado.json"]
117
+ )
118
+ print(f"\n=== 3) upload_folder ÚNICO ({len(arquivos)} arquivos) ===")
119
+ api.upload_folder(
120
+ repo_id=repo, repo_type="model", folder_path=pasta,
121
+ ignore_patterns=ignores, commit_message="v0.11.0: lote DeepSeek provado/corrigido (r-35..r-42) — Weiszfeld S4-2 (QE −46% real, monótona), VC suave C^∞ J-1′, V-2′ soundness, M-R5′ guloso ótimo; raciocínio ELÁSTICO certificado sobre resíduos de quantização REAIS (conf 0,88, 24/24, 0 violações); ASSEMBLY AVX-512 bit-a-bit (scan SSM 12,7×); SonicMoE/ReplaySSM semeados; lib.rs 0 unwraps — 134/134 gates, 137/137 cargo",
122
+ )
123
+ print("upload concluído")
124
+
125
+ # ---------------- 4) verificação pós-upload ----------------
126
+ print("\n=== 4) verificação pós-upload ===")
127
+ files = api.list_repo_files(repo_id=repo, repo_type="model")
128
+ estados = [f for f in files if f.endswith(SUFIXOS_ESTADO)
129
+ or f.split("/")[-1] in NOMES_ESTADO]
130
+ assert not estados, f"estados publicados: {estados}"
131
+ chaves = ["src/asm_x86.rs", "src/pensamento/raciocinio_elastico.rs",
132
+ "src/verificador.rs", "src/som4d.rs", "src/jepa.rs",
133
+ "scripts/73_treino_v011.py", "scripts/74_suite_v011.py",
134
+ "docs/memorias/r-35-analise-criticas-deepseek-v011.md",
135
+ "docs/memorias/r-43-resultados-v011.md",
136
+ "resultados/suite_v011_final.json", "resultados/treino_v011.json"]
137
+ faltando = [c for c in chaves if c not in files]
138
+ assert not faltando, f"faltando: {faltando}"
139
+ print(f"repo: {len(files)} arquivos | 0 estados | módulos-chave OK")
140
+
141
+ # ---------------- 5) varredura REMOTA do token ----------------
142
+ print("\n=== 5) varredura REMOTA do valor do token ===")
143
+ with tempfile.TemporaryDirectory() as tmp:
144
+ achados_remotos = []
145
+ for f in files:
146
+ if f.endswith((".py", ".rs", ".md", ".json", ".toml", ".sh", ".cfg",
147
+ ".txt", ".jsonl")):
148
+ try:
149
+ p = api.hf_hub_download(repo_id=repo, repo_type="model",
150
+ filename=f, local_dir=tmp)
151
+ with open(p, "rb") as fh:
152
+ if token.encode() in fh.read():
153
+ achados_remotos.append(f)
154
+ except Exception:
155
+ pass
156
+ if achados_remotos:
157
+ print(f"ERRO: token remoto em: {achados_remotos}"); sys.exit(1)
158
+ print("varredura remota: limpa")
159
+ print("\nPUBLICAÇÃO v0.11.0 CONCLUÍDA")
160
+
161
+ if __name__ == "__main__":
162
+ main()
src/asm_x86.rs ADDED
@@ -0,0 +1,463 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ //! v0.11 — Núcleos em ASSEMBLY x86-64 (AVX-512) integrados a Rust
2
+ //! (`global_asm!`), com tratamento de erros por FLAGS de hardware
3
+ //! (tratamento.txt §2) e despacho em runtime (padrão r-34: portabilidade
4
+ //! e velocidade — nunca RUSTFLAGS globais num repo publicado).
5
+ //!
6
+ //! # Convenções (tratamento.txt §2 — documentadas por kernel)
7
+ //!
8
+ //! * **Chamada**: System V AMD64. Inteiros em RDI, RSI, RDX, RCX, R8, R9;
9
+ //! 7º argumento na PILHA (`[rsp+8]` no entry). Retorno: código de erro
10
+ //! em EAX — `0` = sucesso, `1` = NaN/Inf detectado no resultado
11
+ //! (`vcmpunordps` → máscara K → `kmovd` — a DETECÇÃO usa o estado do
12
+ //! processador, não exceções).
13
+ //! * **Clobbers**: RAX, R10, R11, R12, R13, R14 (R12–R14 salvos com push),
14
+ //! ZMM0–ZMM31 e K1 são considerados voláteis e SÃO alterados.
15
+ //! * **Bit-a-bit (Teo X-1 estendido)**: nenhum kernel usa FMA — a ORDEM
16
+ //! das operações replica EXATAMENTE os kernels escalares/Rust-SIMD que
17
+ //! substituem (vmulps/vaddps/vdivps/vsqrtps IEEE-exatas) ⇒ saída
18
+ //! idêntica em `to_bits()` (testes `adamw_asm_bit_a_bit`,
19
+ //! `scan_asm_bit_a_bit`).
20
+ //! * **Erros**: o código em EAX é mapeado no Rust para `Result`
21
+ //! (scan) ou telemetria (adamw — o passo de treino JÁ tem guarda
22
+ //! inf/NaN no `AdamWManual`; duplicar o abort mudaria semântica).
23
+ //!
24
+ //! # Por que Assembly aqui (honestidade r-43)
25
+ //!
26
+ //! O compilador Rust já emite AVX-512 a partir dos intrinsics do `simd.rs`;
27
+ //! o ganho do Assembly manual é: (a) escalonamento de registradores e
28
+ //! agenda de instruções GARANTIDOS (imunes a mudanças do llvm-version),
29
+ //! (b) a detecção de NaN por máscara sem custo extra de ramificação,
30
+ //! (c) a fusão da recorrência do SSM (T·d·3 ops em UM despacho, contra
31
+ //! ~5 ops de tensor por passo no candle — o ganho dominante não é SIMD,
32
+ //! é eliminar o dispatch). Medido honestamente em `bench_v011`.
33
+
34
+ use std::arch::global_asm;
35
+ use std::sync::atomic::{AtomicUsize, Ordering};
36
+
37
+ // ---------------------------------------------------------------------------
38
+ // Telemetria de despacho
39
+ // ---------------------------------------------------------------------------
40
+ static CHAMADAS_ASM: AtomicUsize = AtomicUsize::new(0);
41
+ static CHAMADAS_FALLBACK: AtomicUsize = AtomicUsize::new(0);
42
+ static NAN_DETECTADOS: AtomicUsize = AtomicUsize::new(0);
43
+
44
+ /// Relatório do despacho Assembly (painel de telemetria).
45
+ pub fn relatorio() -> serde_json::Value {
46
+ serde_json::json!({
47
+ "chamadas_asm": CHAMADAS_ASM.load(Ordering::Relaxed),
48
+ "chamadas_fallback": CHAMADAS_FALLBACK.load(Ordering::Relaxed),
49
+ "nan_detectados": NAN_DETECTADOS.load(Ordering::Relaxed),
50
+ "avx512_disponivel": tem_avx512(),
51
+ })
52
+ }
53
+
54
+ pub fn tem_avx512() -> bool {
55
+ #[cfg(target_arch = "x86_64")]
56
+ {
57
+ std::arch::is_x86_feature_detected!("avx512f")
58
+ && std::arch::is_x86_feature_detected!("avx512dq")
59
+ }
60
+ #[cfg(not(target_arch = "x86_64"))]
61
+ {
62
+ false
63
+ }
64
+ }
65
+
66
+ // ---------------------------------------------------------------------------
67
+ // Kernel 1: passo AdamW (blocos de 16 floats) — bit-a-bit com simd.rs
68
+ // ---------------------------------------------------------------------------
69
+ // Argumentos (System V AMD64):
70
+ // RDI = w (ptr f32) RSI = g (ptr f32) RDX = m (ptr f32 mut)
71
+ // RCX = v (ptr f32 mut) R8 = out (ptr f32) R9 = n (floats)
72
+ // [RSP+8] = ponteiro para 9 constantes f32:
73
+ // [lr, b1, b2, eps, wd, bc1, bc2, omb1, omb2]
74
+ // Retorna EAX: 0 = ok, 1 = NaN/Inf produzido em `out`.
75
+ // Clobbers: RAX, R10, R11, R12 (salvo), ZMM0–ZMM24, K1.
76
+ // Ordem EXATA do escalar (sem FMA):
77
+ // m = b1*m + omb1*g ; v = b2*v + (omb2*g)*g
78
+ // out = w - lr*( (m/bc1) / (sqrt(v/bc2) + eps) + wd*w )
79
+ global_asm! {
80
+ ".intel_syntax noprefix",
81
+ ".align 16",
82
+ "khtst_adamw_f32_asm:",
83
+ " test r9, r9",
84
+ " je .Ladamw_zero",
85
+ " mov r10, [rsp+8]", // ponteiro das constantes
86
+ " vbroadcastss zmm16, dword ptr [r10]", // lr
87
+ " vbroadcastss zmm17, dword ptr [r10+4]", // b1
88
+ " vbroadcastss zmm18, dword ptr [r10+8]", // b2
89
+ " vbroadcastss zmm19, dword ptr [r10+12]", // eps
90
+ " vbroadcastss zmm20, dword ptr [r10+16]", // wd
91
+ " vbroadcastss zmm21, dword ptr [r10+20]", // bc1
92
+ " vbroadcastss zmm22, dword ptr [r10+24]", // bc2
93
+ " vbroadcastss zmm23, dword ptr [r10+28]", // omb1
94
+ " vbroadcastss zmm24, dword ptr [r10+32]", // omb2
95
+ " xor r11d, r11d", // acumulador de NaN
96
+ " mov rax, r9",
97
+ " and rax, -16", // floats em blocos completos
98
+ " push r12",
99
+ " xor r12d, r12d", // j = 0
100
+ ".Ladamw_loop:",
101
+ " cmp r12, rax",
102
+ " jae .Ladamw_fim",
103
+ " vmovups zmm0, [rdi + r12*4]", // w
104
+ " vmovups zmm1, [rsi + r12*4]", // g
105
+ " vmovups zmm2, [rdx + r12*4]", // m
106
+ " vmovups zmm3, [rcx + r12*4]", // v
107
+ " vmulps zmm4, zmm23, zmm1", // t1 = omb1 * g
108
+ " vmulps zmm5, zmm17, zmm2", // b1m = b1 * m
109
+ " vaddps zmm5, zmm5, zmm4", // nm = b1m + t1
110
+ " vmulps zmm6, zmm24, zmm1", // t2 = omb2 * g
111
+ " vmulps zmm6, zmm6, zmm1", // t2g = t2 * g
112
+ " vmulps zmm7, zmm18, zmm3", // b2v = b2 * v
113
+ " vaddps zmm7, zmm7, zmm6", // nv = b2v + t2g
114
+ " vdivps zmm8, zmm5, zmm21", // mh = nm / bc1
115
+ " vdivps zmm9, zmm7, zmm22", // vh = nv / bc2
116
+ " vsqrtps zmm10, zmm9", // raiz IEEE-exata
117
+ " vaddps zmm11, zmm10, zmm19", // denom = raiz + eps
118
+ " vdivps zmm12, zmm8, zmm11", // quoc = mh / denom
119
+ " vmulps zmm13, zmm20, zmm0", // decaimento = wd * w
120
+ " vaddps zmm13, zmm12, zmm13", // ajuste = quoc + decaimento
121
+ " vmulps zmm14, zmm16, zmm13", // passo = lr * ajuste
122
+ " vsubps zmm15, zmm0, zmm14", // novo = w - passo
123
+ // TRATAMENTO DE ERRO por flag de hardware: vcmpunordps testa
124
+ // NaN/Inf via máscara K (sem exceção, sem ramificação de dados)
125
+ " vcmpunordps k1, zmm15, zmm15",
126
+ " kmovd r10d, k1", // r10 livre: const ptr já usado
127
+ " or r11d, r10d",
128
+ " vmovups [rdx + r12*4], zmm5", // m
129
+ " vmovups [rcx + r12*4], zmm7", // v
130
+ " vmovups [r8 + r12*4], zmm15", // out
131
+ " add r12, 16",
132
+ " jmp .Ladamw_loop",
133
+ ".Ladamw_fim:",
134
+ " pop r12",
135
+ " mov eax, r11d",
136
+ " ret",
137
+ ".Ladamw_zero:",
138
+ " xor eax, eax",
139
+ " ret",
140
+ }
141
+
142
+ // ---------------------------------------------------------------------------
143
+ // Kernel 2: recorrência SSM de porta diagonal (caminho de INFERÊNCIA)
144
+ // ---------------------------------------------------------------------------
145
+ // h_prev = zeros na 1ª linha (bit-a-bit com Tensor::zeros do candle);
146
+ // h[i] = (porta ⊙ h_prev) + (um_menos ⊙ entrada[i]) [ordem do candle]
147
+ // Argumentos:
148
+ // RDI = porta (ptr f32, d) RSI = um_menos (ptr f32, d)
149
+ // RDX = entrada (ptr f32, T·d) RCX = h_out (ptr f32 mut, T·d)
150
+ // R8 = T (linhas) R9 = d [RSP+8] = zeros (ptr f32, d)
151
+ // Retorna EAX: 0 = ok, 1 = NaN/Inf em h_out.
152
+ // Clobbers: RAX, R10, R11, R12–R14 (salvos), ZMM0–ZMM6, XMM0–XMM6, K1.
153
+ global_asm! {
154
+ ".intel_syntax noprefix",
155
+ ".align 16",
156
+ "khtst_scan_ssm_f32_asm:",
157
+ " test r9, r9",
158
+ " je .Lscan_zero",
159
+ " test r8, r8",
160
+ " je .Lscan_zero",
161
+ " mov r10, [rsp+8]", // zeros = h_prev da 1ª linha
162
+ " push rbx",
163
+ " push r12",
164
+ " push r13",
165
+ " push r14",
166
+ " push r15",
167
+ " xor r14d, r14d", // offset da linha (floats)
168
+ " mov r13, r9",
169
+ " and r13, -16", // blocos completos por linha
170
+ " xor r11d, r11d", // acumulador de NaN
171
+ ".Lscan_row:",
172
+ // bases da linha corrente (x86 permite UM índice por endereço)
173
+ " lea rax, [rdx + r14*4]", // entrada + linha
174
+ " lea r15, [rcx + r14*4]", // h_out + linha
175
+ " xor r12d, r12d",
176
+ ".Lscan_chunk:",
177
+ " cmp r12, r13",
178
+ " jae .Lscan_tail_ini",
179
+ " vmovups zmm0, [r10 + r12*4]", // h_prev
180
+ " vmovups zmm1, [rdi + r12*4]", // porta
181
+ " vmovups zmm2, [rsi + r12*4]", // um_menos
182
+ " vmovups zmm3, [rax + r12*4]", // entrada
183
+ " vmulps zmm4, zmm1, zmm0", // porta*h
184
+ " vmulps zmm5, zmm2, zmm3", // um_menos*x
185
+ " vaddps zmm6, zmm4, zmm5", // h (ordem exata)
186
+ " vmovups [r15 + r12*4], zmm6",
187
+ " vcmpunordps k1, zmm6, zmm6",
188
+ " kmovd ebx, k1", // rbx dedicado à máscara (salvo)
189
+ " or r11d, ebx",
190
+ " add r12, 16",
191
+ " jmp .Lscan_chunk",
192
+ ".Lscan_tail_ini:",
193
+ " mov r12, r13",
194
+ ".Lscan_tail:",
195
+ " cmp r12, r9",
196
+ " jae .Lscan_fim_linha",
197
+ " vmovss xmm0, [r10 + r12*4]",
198
+ " vmovss xmm1, [rdi + r12*4]",
199
+ " vmovss xmm2, [rsi + r12*4]",
200
+ " vmovss xmm3, [rax + r12*4]",
201
+ " vmulss xmm4, xmm1, xmm0",
202
+ " vmulss xmm5, xmm2, xmm3",
203
+ " vaddss xmm6, xmm4, xmm5",
204
+ " vmovss [r15 + r12*4], xmm6",
205
+ " vcmpunordss k1, xmm6, xmm6",
206
+ " kmovd ebx, k1",
207
+ " or r11d, ebx",
208
+ " inc r12",
209
+ " jmp .Lscan_tail",
210
+ ".Lscan_fim_linha:",
211
+ " mov r10, r15", // prev = linha recém-escrita
212
+ " add r14, r9",
213
+ " dec r8",
214
+ " jnz .Lscan_row",
215
+ " mov eax, r11d",
216
+ " pop r15",
217
+ " pop r14",
218
+ " pop r13",
219
+ " pop r12",
220
+ " pop rbx",
221
+ " ret",
222
+ ".Lscan_zero:",
223
+ " xor eax, eax",
224
+ " ret",
225
+ }
226
+
227
+ extern "C" {
228
+ fn khtst_adamw_f32_asm(
229
+ w: *const f32,
230
+ g: *const f32,
231
+ m: *mut f32,
232
+ v: *mut f32,
233
+ out: *mut f32,
234
+ n: usize,
235
+ constantes: *const f32,
236
+ ) -> u32;
237
+ fn khtst_scan_ssm_f32_asm(
238
+ porta: *const f32,
239
+ um_menos: *const f32,
240
+ entrada: *const f32,
241
+ h_out: *mut f32,
242
+ t: usize,
243
+ d: usize,
244
+ zeros: *const f32,
245
+ ) -> u32;
246
+ }
247
+
248
+ /// Passo AdamW (apenas BLOCOS de 16 — a cauda escalar fica no chamador,
249
+ /// como no `simd::passo_adamw`). Devolve `true` se o caminho Assembly
250
+ /// executou (AVX-512 presente) — os NaN detectados vão para a telemetria
251
+ /// (o passo de treino tem guarda própria; abortar aqui mudaria semântica).
252
+ ///
253
+ /// **Bit-a-bit**: mesma ordem de operações do escalar (sem FMA) — os
254
+ /// blocos processados aqui são idênticos em `to_bits()` ao caminho
255
+ /// intrinsics do `simd.rs` (teste `adamw_asm_bit_a_bit`).
256
+ #[allow(clippy::too_many_arguments)]
257
+ pub fn passo_adamw_blocos(
258
+ w: &[f32],
259
+ g: &[f32],
260
+ m: &mut [f32],
261
+ v: &mut [f32],
262
+ out: &mut [f32],
263
+ lr: f32,
264
+ b1: f32,
265
+ b2: f32,
266
+ eps: f32,
267
+ wd: f32,
268
+ bc1: f32,
269
+ bc2: f32,
270
+ omb1: f32,
271
+ omb2: f32,
272
+ ) -> bool {
273
+ let n = w.len().min(g.len()).min(m.len()).min(v.len()).min(out.len());
274
+ if !tem_avx512() || n < 16 {
275
+ CHAMADAS_FALLBACK.fetch_add(1, Ordering::Relaxed);
276
+ return false;
277
+ }
278
+ let constantes = [lr, b1, b2, eps, wd, bc1, bc2, omb1, omb2];
279
+ let codigo = unsafe {
280
+ khtst_adamw_f32_asm(
281
+ w.as_ptr(),
282
+ g.as_ptr(),
283
+ m.as_mut_ptr(),
284
+ v.as_mut_ptr(),
285
+ out.as_mut_ptr(),
286
+ n,
287
+ constantes.as_ptr(),
288
+ )
289
+ };
290
+ CHAMADAS_ASM.fetch_add(1, Ordering::Relaxed);
291
+ if codigo != 0 {
292
+ NAN_DETECTADOS.fetch_add(1, Ordering::Relaxed);
293
+ }
294
+ true
295
+ }
296
+
297
+ /// Recorrência SSM de porta diagonal (caminho de inferência): devolve
298
+ /// (T, d) com `h_t = porta⊙h_{t−1} + um_menos⊙entrada_t`, bit-a-bit com o
299
+ /// `ReplaySsm::scan` do candle (zeros na origem, mul/mul/add na mesma
300
+ /// ordem). NaN/Inf ⇒ `Err` (código de flag do Assembly mapeado em Result —
301
+ /// tratamento.txt §2: "códigos de retorno em registradores").
302
+ pub fn scan_ssm(
303
+ porta: &candle_core::Tensor,
304
+ um_menos: &candle_core::Tensor,
305
+ entrada: &candle_core::Tensor,
306
+ t: usize,
307
+ d: usize,
308
+ ) -> candle_core::Result<candle_core::Tensor> {
309
+ use candle_core::{DType, Tensor};
310
+ let dev = entrada.device();
311
+ if t == 0 || d == 0 {
312
+ return Ok(Tensor::zeros((t, d), DType::F32, &dev)?);
313
+ }
314
+ let porta_v = porta.flatten_all()?.to_vec1::<f32>()?;
315
+ let um_v = um_menos.flatten_all()?.to_vec1::<f32>()?;
316
+ let ent_v = entrada.flatten_all()?.to_vec1::<f32>()?;
317
+ let mut h = vec![0f32; t * d];
318
+ let zeros = vec![0f32; d];
319
+ if tem_avx512() {
320
+ let codigo = unsafe {
321
+ khtst_scan_ssm_f32_asm(
322
+ porta_v.as_ptr(),
323
+ um_v.as_ptr(),
324
+ ent_v.as_ptr(),
325
+ h.as_mut_ptr(),
326
+ t,
327
+ d,
328
+ zeros.as_ptr(),
329
+ )
330
+ };
331
+ CHAMADAS_ASM.fetch_add(1, Ordering::Relaxed);
332
+ if codigo != 0 {
333
+ candle_core::bail!("scan_ssm (asm): NaN/Inf detectado no estado h (flag EAX=1)");
334
+ }
335
+ } else {
336
+ // fallback escalar — MESMA ordem de operações (bit-a-bit)
337
+ CHAMADAS_FALLBACK.fetch_add(1, Ordering::Relaxed);
338
+ for i in 0..t {
339
+ for j in 0..d {
340
+ let prev = if i == 0 { 0.0f32 } else { h[(i - 1) * d + j] };
341
+ let x = ent_v[i * d + j];
342
+ h[i * d + j] = porta_v[j] * prev + um_v[j] * x;
343
+ }
344
+ }
345
+ }
346
+ Ok(Tensor::from_vec(h, (t, d), &dev)?)
347
+ }
348
+
349
+ pub fn versao() -> &'static str {
350
+ "asm-x86-0.11.0"
351
+ }
352
+
353
+ // ---------------------------------------------------------------------------
354
+ // Testes de falsificação
355
+ // ---------------------------------------------------------------------------
356
+
357
+ #[cfg(test)]
358
+ mod testes {
359
+ use super::*;
360
+
361
+ /// Bit-a-bit: blocos do Assembly == referência escalar do simd.rs.
362
+ #[test]
363
+ fn adamw_asm_bit_a_bit() {
364
+ if !tem_avx512() {
365
+ eprintln!("AVX-512 ausente — teste bit-a-bit do asm executa só o fallback");
366
+ return;
367
+ }
368
+ let n = 4096usize;
369
+ let mut rng = crate::rng::RngDeterministico::novo(9);
370
+ let w: Vec<f32> = (0..n).map(|_| rng.normal(0.0, 0.1) as f32).collect();
371
+ let g: Vec<f32> = (0..n).map(|_| rng.normal(0.0, 0.01) as f32).collect();
372
+ let m0: Vec<f32> = (0..n).map(|_| rng.normal(0.0, 0.05) as f32).collect();
373
+ let v0: Vec<f32> = (0..n).map(|_| rng.normal(0.0, 0.001).abs() as f32).collect();
374
+ let (lr, b1, b2, eps, wd) = (1e-3f32, 0.9f32, 0.999f32, 1e-8f32, 0.01f32);
375
+ let (bc1, bc2) = (1.0 - b1.powi(1), 1.0 - b2.powi(1));
376
+ let (omb1, omb2) = (1.0 - b1, 1.0 - b2);
377
+ // caminho Assembly
378
+ let (mut m_a, mut v_a) = (m0.clone(), v0.clone());
379
+ let mut out_a = vec![0f32; n];
380
+ let executou = passo_adamw_blocos(
381
+ &w, &g, &mut m_a, &mut v_a, &mut out_a, lr, b1, b2, eps, wd, bc1, bc2, omb1, omb2,
382
+ );
383
+ assert!(executou, "AVX-512 presente — asm deve executar");
384
+ // cauda idêntica à do simd::passo_adamw (j >= n & !15)
385
+ let ini = n & !15;
386
+ for j in ini..n {
387
+ m_a[j] = b1 * m_a[j] + omb1 * g[j];
388
+ v_a[j] = b2 * v_a[j] + omb2 * g[j] * g[j];
389
+ let mh = m_a[j] / bc1;
390
+ let vh = v_a[j] / bc2;
391
+ out_a[j] = w[j] - lr * (mh / (vh.sqrt() + eps) + wd * w[j]);
392
+ }
393
+ // referência escalar
394
+ let (mut m_r, mut v_r) = (m0, v0);
395
+ let mut out_r = vec![0f32; n];
396
+ for j in 0..n {
397
+ m_r[j] = b1 * m_r[j] + omb1 * g[j];
398
+ v_r[j] = b2 * v_r[j] + omb2 * g[j] * g[j];
399
+ let mh = m_r[j] / bc1;
400
+ let vh = v_r[j] / bc2;
401
+ out_r[j] = w[j] - lr * (mh / (vh.sqrt() + eps) + wd * w[j]);
402
+ }
403
+ for j in 0..n {
404
+ assert_eq!(m_a[j].to_bits(), m_r[j].to_bits(), "m[{j}] diverge");
405
+ assert_eq!(v_a[j].to_bits(), v_r[j].to_bits(), "v[{j}] diverge");
406
+ assert_eq!(out_a[j].to_bits(), out_r[j].to_bits(), "out[{j}] diverge");
407
+ }
408
+ }
409
+
410
+ /// Bit-a-bit: scan do Assembly == scan diferenciável do ReplaySsm.
411
+ #[test]
412
+ fn scan_asm_bit_a_bit() {
413
+ use candle_core::Device;
414
+ let dev = Device::Cpu;
415
+ let ssm = crate::jepa::ReplaySsm::novo_com_semente(4, 6, 0.5, 8, 55, &dev).unwrap();
416
+ let mut rng = crate::rng::RngDeterministico::novo(3);
417
+ let x: Vec<f32> = (0..12 * 4)
418
+ .map(|i| {
419
+ let _ = i;
420
+ (rng.normal(0.0, 1.0)) as f32
421
+ })
422
+ .collect();
423
+ let xt = candle_core::Tensor::from_vec(x, (12, 4), &dev).unwrap();
424
+ let h_candle = ssm.scan(&xt).unwrap();
425
+ let h_asm = ssm.scan_inferencia(&xt).unwrap();
426
+ let a = h_candle.flatten_all().unwrap().to_vec1::<f32>().unwrap();
427
+ let b = h_asm.flatten_all().unwrap().to_vec1::<f32>().unwrap();
428
+ assert_eq!(a.len(), b.len());
429
+ for i in 0..a.len() {
430
+ assert_eq!(a[i].to_bits(), b[i].to_bits(), "h[{i}] diverge (asm vs candle)");
431
+ }
432
+ }
433
+
434
+ /// Tratamento de erro por flag: NaN na entrada ⇒ código 1 ⇒ Err.
435
+ #[test]
436
+ fn scan_asm_detecta_nan() {
437
+ use candle_core::Device;
438
+ let dev = Device::Cpu;
439
+ let porta = candle_core::Tensor::from_vec(vec![0.5f32; 8], (8,), &dev).unwrap();
440
+ let entrada = candle_core::Tensor::from_vec(
441
+ vec![f32::NAN; 16 * 8],
442
+ (16, 8),
443
+ &dev,
444
+ )
445
+ .unwrap();
446
+ let r = scan_ssm(&porta, &porta, &entrada, 16, 8);
447
+ assert!(r.is_err(), "NaN na entrada deve produzir Err (flag EAX=1)");
448
+ }
449
+
450
+ /// Determinismo: mesma semente ⇒ mesmo scan bit-a-bit (2 execuções).
451
+ #[test]
452
+ fn scan_asm_deterministico() {
453
+ use candle_core::Device;
454
+ let dev = Device::Cpu;
455
+ let ssm = crate::jepa::ReplaySsm::novo_com_semente(4, 6, 0.5, 8, 77, &dev).unwrap();
456
+ let x = candle_core::Tensor::from_vec(vec![0.5f32; 32 * 4], (32, 4), &dev).unwrap();
457
+ let a = ssm.scan_inferencia(&x).unwrap();
458
+ let b = ssm.scan_inferencia(&x).unwrap();
459
+ let va = a.flatten_all().unwrap().to_vec1::<f32>().unwrap();
460
+ let vb = b.flatten_all().unwrap().to_vec1::<f32>().unwrap();
461
+ assert_eq!(va, vb);
462
+ }
463
+ }
src/bin/bench_v011.rs ADDED
@@ -0,0 +1,126 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ //! Bench v0.11 — medições honestas dos núcleos ASSEMBLY AVX-512 (r-43):
2
+ //! (A) passo AdamW: escalar vs intrinsics-Rust vs Assembly;
3
+ //! (B) scan SSM (inferência): candle (ops de tensor por passo) vs
4
+ //! recorrência fundida em Assembly.
5
+ //! Saída JSON em stdout. Bit-identidade verificada em cena real.
6
+
7
+ use khtst_rust::asm_x86;
8
+ use khtst_rust::rng::RngDeterministico;
9
+ use khtst_rust::simd;
10
+ use std::hint::black_box;
11
+ use std::time::Instant;
12
+
13
+ fn mediana(mut xs: Vec<f64>) -> f64 {
14
+ xs.sort_by(|a, b| a.partial_cmp(b).unwrap());
15
+ xs[xs.len() / 2]
16
+ }
17
+
18
+ fn bench<F: FnMut()>(mut f: F, reps: usize) -> f64 {
19
+ let mut tempos = Vec::with_capacity(reps);
20
+ for _ in 0..reps {
21
+ let t = Instant::now();
22
+ f();
23
+ tempos.push(t.elapsed().as_secs_f64() * 1e3);
24
+ }
25
+ mediana(tempos)
26
+ }
27
+
28
+ fn main() {
29
+ let reps = 21usize;
30
+ let mut r = serde_json::Map::new();
31
+ r.insert("asm_versao".into(), asm_x86::versao().into());
32
+ r.insert("avx512_disponivel".into(), asm_x86::tem_avx512().into());
33
+ r.insert(
34
+ "cpus".into(),
35
+ std::thread::available_parallelism().map(|n| n.get()).unwrap_or(1).into(),
36
+ );
37
+
38
+ // ---------------- A) AdamW: escalar vs intrinsics vs ASSEMBLY ----------------
39
+ {
40
+ let n = 2_000_000usize;
41
+ let mut rng = RngDeterministico::novo(1);
42
+ let w: Vec<f32> = (0..n).map(|_| rng.normal(0.0, 0.5) as f32).collect();
43
+ let g: Vec<f32> = (0..n).map(|_| rng.normal(0.0, 0.1) as f32).collect();
44
+ let (mut m, mut v, mut out) = (vec![0f32; n], vec![0f32; n], vec![0f32; n]);
45
+ let (lr, b1, b2, eps, wd, bc1, bc2) = (3e-4f64, 0.9, 0.999, 1e-8, 0.01, 0.91, 0.001);
46
+ let (omb1, omb2) = (1.0 - b1 as f32, 1.0 - b2 as f32);
47
+
48
+ let t_esc = bench(
49
+ || {
50
+ simd::passo_adamw_escalar(&w, &g, &mut m, &mut v, &mut out, lr, b1, b2, eps, wd, bc1, bc2);
51
+ black_box(&out);
52
+ },
53
+ reps,
54
+ );
55
+ // intrinsics puro: despacho desligado — chama o kernel AVX direto
56
+ // via passo_adamw (que agora prefere asm)... para isolar o
57
+ // INTRINSICS usamos o caminho com asm desabilitado por tamanho
58
+ // (n < 16 cai no escalar) — medimos então: simd::passo_adamw (asm)
59
+ let t_asm = bench(
60
+ || {
61
+ simd::passo_adamw(&w, &g, &mut m, &mut v, &mut out, lr, b1, b2, eps, wd, bc1, bc2);
62
+ black_box(&out);
63
+ },
64
+ reps,
65
+ );
66
+ // kernel asm DIRETO (sem a cauda — mesma quantidade de trabalho)
67
+ let t_asm_direto = bench(
68
+ || {
69
+ let _ = asm_x86::passo_adamw_blocos(
70
+ &w, &g, &mut m, &mut v, &mut out, lr as f32, b1 as f32, b2 as f32,
71
+ eps as f32, wd as f32, bc1 as f32, bc2 as f32, omb1, omb2,
72
+ );
73
+ black_box(&out);
74
+ },
75
+ reps,
76
+ );
77
+ // bit-identidade asm vs escalar (estados frescos)
78
+ let (mut ma, mut va, mut oa) = (vec![0f32; n], vec![0f32; n], vec![0f32; n]);
79
+ let (mut mb, mut vb, mut ob) = (vec![0f32; n], vec![0f32; n], vec![0f32; n]);
80
+ simd::passo_adamw_escalar(&w, &g, &mut ma, &mut va, &mut oa, lr, b1, b2, eps, wd, bc1, bc2);
81
+ let _ = asm_x86::passo_adamw_blocos(
82
+ &w, &g, &mut mb, &mut vb, &mut ob, lr as f32, b1 as f32, b2 as f32,
83
+ eps as f32, wd as f32, bc1 as f32, bc2 as f32, omb1, omb2,
84
+ );
85
+ // cauda do asm (n % 16 == 0 aqui — sem cauda)
86
+ let identico =
87
+ oa.iter().zip(ob.iter()).all(|(a, b)| a.to_bits() == b.to_bits());
88
+ r.insert("adamw_escalar_ms".into(), t_esc.into());
89
+ r.insert("adamw_asm_ms".into(), t_asm.into());
90
+ r.insert("adamw_asm_direto_ms".into(), t_asm_direto.into());
91
+ r.insert("adamw_speedup_asm".into(), (t_esc / t_asm).into());
92
+ r.insert("adamw_bit_identico".into(), identico.into());
93
+ // nota honesta: passo AdamW é MEMORY-BOUND (r-34 §6.2: roofline
94
+ // 40 MB/passo) — o teto do ganho é a banda, não o SIMD.
95
+ }
96
+
97
+ // ---------------- B) scan SSM: candle vs ASSEMBLY (inferência) ----------------
98
+ {
99
+ use candle_core::Device;
100
+ let dev = Device::Cpu;
101
+ let (t_len, d_in, d) = (512usize, 16usize, 64usize);
102
+ let ssm = khtst_rust::jepa::ReplaySsm::novo_com_semente(d_in, d, 0.5, 8, 42, &dev).unwrap();
103
+ let mut rng = RngDeterministico::novo(7);
104
+ let x: Vec<f32> = (0..t_len * d_in).map(|_| rng.normal(0.0, 1.0) as f32).collect();
105
+ let xt = candle_core::Tensor::from_vec(x, (t_len, d_in), &dev).unwrap();
106
+
107
+ // aquecimento + bit-identidade
108
+ let h_c = ssm.scan(&xt).unwrap();
109
+ let h_a = ssm.scan_inferencia(&xt).unwrap();
110
+ let vc = h_c.flatten_all().unwrap().to_vec1::<f32>().unwrap();
111
+ let va = h_a.flatten_all().unwrap().to_vec1::<f32>().unwrap();
112
+ let identico = vc.iter().zip(va.iter()).all(|(a, b)| a.to_bits() == b.to_bits());
113
+
114
+ let t_candle = bench(|| { let h = ssm.scan(&xt).unwrap(); black_box(&h); }, reps);
115
+ let t_asm = bench(|| { let h = ssm.scan_inferencia(&xt).unwrap(); black_box(&h); }, reps);
116
+ r.insert("ssm_t".into(), t_len.into());
117
+ r.insert("ssm_d".into(), d.into());
118
+ r.insert("ssm_candle_ms".into(), t_candle.into());
119
+ r.insert("ssm_asm_ms".into(), t_asm.into());
120
+ r.insert("ssm_speedup_asm".into(), (t_candle / t_asm).into());
121
+ r.insert("ssm_bit_identico".into(), identico.into());
122
+ }
123
+
124
+ r.insert("despacho".into(), asm_x86::relatorio());
125
+ println!("{}", serde_json::to_string_pretty(&serde_json::Value::Object(r)).unwrap());
126
+ }
src/bin/bench_v090.rs CHANGED
@@ -10,7 +10,7 @@ use std::hint::black_box;
10
  use std::time::Instant;
11
 
12
  fn mediana(mut xs: Vec<f64>) -> f64 {
13
- xs.sort_by(|a, b| a.total_cmp(b));
14
  xs[xs.len() / 2]
15
  }
16
 
 
10
  use std::time::Instant;
11
 
12
  fn mediana(mut xs: Vec<f64>) -> f64 {
13
+ xs.sort_by(|a, b| a.partial_cmp(b).unwrap());
14
  xs[xs.len() / 2]
15
  }
16
 
src/controlador.rs CHANGED
@@ -95,7 +95,7 @@ impl Controlador {
95
  pub fn clip_corrente(&mut self, hub: &mut TelemetryHub) -> f64 {
96
  if self.normas_grad.len() >= 32 {
97
  let mut v = self.normas_grad.clone();
98
- v.sort_by(|a, b| a.total_cmp(b));
99
  let idx = ((self.clip_percentil / 100.0) * (v.len() - 1) as f64).round() as usize;
100
  let novo = v[idx.min(v.len() - 1)].max(0.25);
101
  if (novo - self.clip).abs() / self.clip > 0.3 {
@@ -187,7 +187,7 @@ impl AutoAjustePensamento {
187
  return self.tau_c; // amostra insuficiente — mantém (honesto)
188
  }
189
  let mut v = self.confs_retidas.clone();
190
- v.sort_by(|a, b| a.total_cmp(b));
191
  let idx = (((1.0 - epsilon.clamp(0.0, 0.5)) * v.len() as f64).ceil() as usize)
192
  .saturating_sub(1)
193
  .min(v.len() - 1);
@@ -215,7 +215,7 @@ impl AutoAjustePensamento {
215
  if razoes.len() < 4 {
216
  return self.orcamento_b;
217
  }
218
- razoes.sort_by(|a, b| a.total_cmp(b));
219
  let rho = razoes[razoes.len() / 2]; // mediana (robusto)
220
  let delta0 = self.ganhos_por_iteracao.iter().cloned().fold(f64::MIN, f64::max).max(1e-9);
221
  // B* = ceil( ln(c·(1−ρ)/Δ) / ln(ρ) ) — ótimo do custo marginal
@@ -236,7 +236,7 @@ impl AutoAjustePensamento {
236
  return self.n_tentativas;
237
  }
238
  let mut v = self.acordos.clone();
239
- v.sort_by(|a, b| a.total_cmp(b));
240
  let a_med = v[v.len() / 2];
241
  // lema do acordo: a = p² + (1−p)² ⇒ p = (1 + √(2a−1))/2 (a ≥ 1/2)
242
  let p_chapeu = if a_med >= 0.5 {
 
95
  pub fn clip_corrente(&mut self, hub: &mut TelemetryHub) -> f64 {
96
  if self.normas_grad.len() >= 32 {
97
  let mut v = self.normas_grad.clone();
98
+ v.sort_by(|a, b| a.partial_cmp(b).unwrap());
99
  let idx = ((self.clip_percentil / 100.0) * (v.len() - 1) as f64).round() as usize;
100
  let novo = v[idx.min(v.len() - 1)].max(0.25);
101
  if (novo - self.clip).abs() / self.clip > 0.3 {
 
187
  return self.tau_c; // amostra insuficiente — mantém (honesto)
188
  }
189
  let mut v = self.confs_retidas.clone();
190
+ v.sort_by(|a, b| a.partial_cmp(b).unwrap());
191
  let idx = (((1.0 - epsilon.clamp(0.0, 0.5)) * v.len() as f64).ceil() as usize)
192
  .saturating_sub(1)
193
  .min(v.len() - 1);
 
215
  if razoes.len() < 4 {
216
  return self.orcamento_b;
217
  }
218
+ razoes.sort_by(|a, b| a.partial_cmp(b).unwrap());
219
  let rho = razoes[razoes.len() / 2]; // mediana (robusto)
220
  let delta0 = self.ganhos_por_iteracao.iter().cloned().fold(f64::MIN, f64::max).max(1e-9);
221
  // B* = ceil( ln(c·(1−ρ)/Δ) / ln(ρ) ) — ótimo do custo marginal
 
236
  return self.n_tentativas;
237
  }
238
  let mut v = self.acordos.clone();
239
+ v.sort_by(|a, b| a.partial_cmp(b).unwrap());
240
  let a_med = v[v.len() / 2];
241
  // lema do acordo: a = p² + (1−p)² ⇒ p = (1 + √(2a−1))/2 (a ≥ 1/2)
242
  let p_chapeu = if a_med >= 0.5 {
src/fnh.rs CHANGED
@@ -198,7 +198,13 @@ impl RotacaoSkew {
198
  let ident = Tensor::eye(self.n, DType::F32, &dev)?;
199
  let half = a.affine(0.5, 0.0)?; // B = A/2 (skew)
200
  let m = ident.sub(&half)?; // M = I − A/2 — invertível (F-9.i)
201
- // X₀ = αMᵀ com α = 1/(1+‖B‖²_F) ⇒ ‖I − MX₀‖₂ < 1 (F-10)
 
 
 
 
 
 
202
  let bf2 = half.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
203
  let alpha = 1.0 / (1.0 + bf2);
204
  let mut x = m.transpose(0, 1)?.affine(alpha, 0.0)?;
@@ -388,22 +394,6 @@ impl GatePunicao {
388
  let sig = 1.0 / (1.0 + (-z).exp());
389
  (2.0 * sig - 1.0).max(0.0)
390
  }
391
-
392
- /// **v0.11.0 (tipos de domínio, T-V2):** gate TIPADO —
393
- /// `Probabilidade → GateAtivacao`. O valor bruto é sempre ∈ [0,1]
394
- /// (Teo F-3: sigmoide retificada), mas o construtor tipado é defesa em
395
- /// profundidade: falha impossível vira clamp AUDITÁVEL com log (nunca
396
- /// panic em caminho de produção — tratamento.txt §1).
397
- pub fn valor_tipado(&self, punicao: &crate::tipos::Probabilidade) -> crate::tipos::GateAtivacao {
398
- let g = self.valor(punicao.valor());
399
- match crate::tipos::GateAtivacao::novo(g) {
400
- Ok(t) => t,
401
- Err(e) => {
402
- log::error!("valor_tipado: gate {g} fora de [0,1] ({e}) — clamp a ZERO");
403
- crate::tipos::GateAtivacao::ZERO
404
- }
405
- }
406
- }
407
  }
408
 
409
  /// Camada FNH — uma hipótese flexível com rotações aprendíveis, suavização de
@@ -858,6 +848,65 @@ mod testes {
858
  /// (todos os θ = 0,5) e o resultado confere com a inversão explícita
859
  /// Gauss–Jordan em f64.
860
  #[test]
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
861
  fn f10_newton_inverso_pior_caso() -> Result<()> {
862
  let dev = Device::Cpu;
863
  let n = 16;
 
198
  let ident = Tensor::eye(self.n, DType::F32, &dev)?;
199
  let half = a.affine(0.5, 0.0)?; // B = A/2 (skew)
200
  let m = ident.sub(&half)?; // M = I − A/2 — invertível (F-9.i)
201
+ // X₀ = αMᵀ com α = 1/(1+‖B‖²_F) ⇒ ρ(I − MX₀) < 1 (F-10, r-41
202
+ // prova explícita): M = I−B normal (B skew ⇒ MᵀM = I−B²), eig(MMᵀ)
203
+ // = 1+λ²(B) ∈ [1, 1+‖B‖₂²]; eig(I−αMMᵀ) = 1−α(1+λ²) ∈
204
+ // [1−α(1+‖B‖₂²), 1−α] ⊆ [0, 1−α] pois ‖B‖_F² ≥ ‖B‖₂² ⇒ α(1+‖B‖₂²)
205
+ // ≤ 1. Logo ρ(E₀) ≤ 1−α < 1 ESTRITAMENTE — a iteração E_{k+1} = E_k²
206
+ // converge QUADRATICAMENTE sem condição extra (o clamp |θ|≤0,5
207
+ // sequer é necessário para a convergência; só mantém κ baixo).
208
  let bf2 = half.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
209
  let alpha = 1.0 / (1.0 + bf2);
210
  let mut x = m.transpose(0, 1)?.affine(alpha, 0.0)?;
 
394
  let sig = 1.0 / (1.0 + (-z).exp());
395
  (2.0 * sig - 1.0).max(0.0)
396
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
397
  }
398
 
399
  /// Camada FNH — uma hipótese flexível com rotações aprendíveis, suavização de
 
848
  /// (todos os θ = 0,5) e o resultado confere com a inversão explícita
849
  /// Gauss–Jordan em f64.
850
  #[test]
851
+
852
+ /// F-10 (r-41, auditoria): decaimento QUADRÁTICO do resíduo
853
+ /// ‖I − MX_k‖∞ — medido ≤ anterior² + tolerância (E_{k+1} = E_k²),
854
+ /// no nascimento (θ≈0), meio e pior caso do clamp (|θ| = 0,5).
855
+ #[test]
856
+ fn f10b_decaimento_quadratico_residuo() -> Result<()> {
857
+ let dev = Device::Cpu;
858
+ for escala in [0.01f64, 0.25, 0.5] {
859
+ let n = 8usize;
860
+ let mut theta: Vec<f32> = Vec::new();
861
+ let mut rng = crate::rng::RngDeterministico::novo(41);
862
+ for _ in 0..(n * (n - 1) / 2) {
863
+ theta.push((escala * rng.normal(0.0, 1.0)) as f32);
864
+ }
865
+ let camada = RotacaoSkew::nova(n, &dev)?;
866
+ camada.theta.set(&Tensor::from_vec(theta, ((n * (n - 1)) / 2,), &dev)?)?;
867
+ // replica a iteração interna medindo o resíduo por passo
868
+ let a = camada.skew()?;
869
+ let ident = Tensor::eye(n, DType::F32, &dev)?;
870
+ let half = a.affine(0.5, 0.0)?;
871
+ let m = ident.sub(&half)?;
872
+ let bf2 = half.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
873
+ let alpha = 1.0 / (1.0 + bf2);
874
+ let mut x = m.transpose(0, 1)?.affine(alpha, 0.0)?;
875
+ let mut anterior = f64::INFINITY;
876
+ for _ in 0..12 {
877
+ let mx = m.matmul(&x)?;
878
+ // norma F do resíduo E_k = I − MX_k — TEOREMA (F-10):
879
+ // ‖E_{k+1}‖_F = ‖E_k²‖_F ≤ ‖E_k‖_F·‖E_k‖_2 ≤ ‖E_k‖_F²
880
+ // (submultiplicatividade) ⇒ regime quadrático EXATO quando
881
+ // ‖E_k‖_F ≤ 1; antes disso, decaimento geométrico por
882
+ // ρ(E_0) ≤ 1−α < 1 (prova no comentário de rotacao_cayley).
883
+ let residuo = (&ident - &mx)?.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
884
+ let residuo = residuo.sqrt();
885
+ if residuo < 1e-7 {
886
+ break;
887
+ }
888
+ // piso de ruído de f32: abaixo de 1e-5 a diferença entre
889
+ // iterações é arredondamento (não sinal de divergência)
890
+ if anterior.is_finite() && residuo > 1e-5 {
891
+ assert!(residuo < anterior,
892
+ "resíduo não decai ({residuo} >= {anterior}, escala {escala})");
893
+ if (1e-5..=1.0).contains(&anterior) {
894
+ assert!(residuo <= anterior * anterior + 1e-6,
895
+ "não-quadrático: {residuo} > {}² (escala {escala})", anterior);
896
+ }
897
+ }
898
+ anterior = residuo;
899
+ let dois_i_menos = ident.affine(2.0, 0.0)?.sub(&mx)?;
900
+ x = x.matmul(&dois_i_menos)?;
901
+ }
902
+ // ao final, R é ortogonal (F-9) — sanity
903
+ let r = camada.rotacao_cayley()?;
904
+ let d = erro_ortogonalidade(&r)?;
905
+ assert!(d < 1e-3, "δ_ort = {d} (escala {escala})");
906
+ }
907
+ Ok(())
908
+ }
909
+
910
  fn f10_newton_inverso_pior_caso() -> Result<()> {
911
  let dev = Device::Cpu;
912
  let n = 16;
src/gerador.rs CHANGED
@@ -246,9 +246,9 @@ impl GeradorConceitos {
246
  }
247
  let txt = serde_json::to_string(&serde_json::Value::Object(obj))
248
  .map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?;
249
- // v0.11.0 (restaurado da v0.10.0): checkpoint ATÔMICO completo —
250
- // tmp→fsync→rename→fsync(dir) + manifesto SHA-256 (Teo CP-1/CP-2)
251
- crate::checkpoint::salvar_atomico(caminho, &txt)?;
252
  Ok(())
253
  }
254
 
 
246
  }
247
  let txt = serde_json::to_string(&serde_json::Value::Object(obj))
248
  .map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?;
249
+ let tmp = format!("{caminho}.tmp");
250
+ std::fs::write(&tmp, txt).map_err(|e| candle_core::Error::Msg(format!("io: {e}")))?;
251
+ std::fs::rename(&tmp, caminho).map_err(|e| candle_core::Error::Msg(format!("rename: {e}")))?;
252
  Ok(())
253
  }
254
 
src/jepa.rs CHANGED
@@ -103,40 +103,6 @@ impl MlpJepa {
103
  }
104
  }
105
 
106
- /// Modo do termo de variância do regularizador VC (v0.10.0, crítica
107
- /// DeepSeek J-1 — análise e provas completas em r-35 §1).
108
- ///
109
- /// A crítica acerta que a prova original do J-1 é INVÁLIDA no argumento de
110
- /// ponto crítico (`∂V/∂std ≠ 0` **não** implica `∇_z V ≠ 0`: a cadeia passa
111
- /// pela raiz `std = √var`, não-diferenciável em `var = 0`, e `∇_z var = 0` no
112
- /// colapso — o produto é `−∞·0`, indefinido). MAS o mecanismo apontado pela
113
- /// crítica (a dobradiça `max(0,γ−s)²` ter kink em `s = 0`) está ERRADO: a
114
- /// dobradiça é C¹ em todo `ℝ` (derivada contínua `−2(γ−s)·1[s<γ]`, com
115
- /// `−2·0 = 0` em `s = γ`); o kink é da RAIZ. Consequência prática: o
116
- /// `Softplus` proposto NÃO restaura a diferenciabilidade w.r.t. `z` (Teo
117
- /// J-1′-iii, teste `j1d`). O teorema correto (J-1′) é que o colapso é uma
118
- /// **sela sharp**: `D⁺V(u) = −(2γ/d)·Σ_j s_j(u) < 0` para toda direção
119
- /// centrada `u ≠ 0`, e sempre existe direção de descida para `L` completa
120
- /// (tome `u` centrada e ⊥ `∇L_pred`).
121
- #[derive(Debug, Clone, Copy, PartialEq, Eq)]
122
- pub enum ModoVariancia {
123
- /// `max(0, γ−√var)²` — comportamento v0.5.0–v0.9.0 (bit-a-bit).
124
- /// Sela SHARP no colapso: escape LINEAR em `|t|` (melhor dinâmica de
125
- /// fuga); gradiente w.r.t. z não existe no colapso exato (medido no
126
- /// teste `j1a`) — configuracão de medida zero em f32.
127
- Dobradica,
128
- /// `max(0, γ−√(var+ε))²` — único modo `C^∞` em `z`. No colapso o
129
- /// gradiente EXISTE e é 0 (ponto crítico), mas a sela é ESTRITA:
130
- /// `V_ε` decai quadraticamente ao afastar-se (J-1′-ii). Viés
131
- /// `≤ 2γ√ε·d` em relação à dobradiça (ε=1e-12 ⇒ ~1e-6·γ).
132
- RaizSuavizada,
133
- /// `softplus(k(γ−std))²` — proposta DeepSeek. NÃO restaura a
134
- /// diferenciabilidade w.r.t. `z` (o kink é da raiz — contraexemplo
135
- /// `j1d`); remove apenas a não-C² da dobradiça em `std = γ`. Opt-in
136
- /// documentado p/ uso com métodos de 2ª ordem no regularizador.
137
- Softplus,
138
- }
139
-
140
  /// Núcleo JEPA: codificador + preditor + alvo EMA + regularizador VC.
141
  pub struct NucleoJepa {
142
  pub encoder: MlpJepa,
@@ -149,12 +115,19 @@ pub struct NucleoJepa {
149
  pub m: f64,
150
  pub lambda_vc: f64,
151
  pub gamma_vc: f64,
152
- /// v0.10.0 — modo do termo de variância (crítica DeepSeek J-1).
153
- pub modo_var: ModoVariancia,
154
- /// ε do modo `RaizSuavizada`.
155
- pub eps_raiz: f64,
156
- /// k do modo `Softplus`.
157
- pub k_softplus: f64,
 
 
 
 
 
 
 
158
  }
159
 
160
  impl NucleoJepa {
@@ -210,19 +183,20 @@ impl NucleoJepa {
210
  m,
211
  lambda_vc,
212
  gamma_vc,
213
- modo_var: ModoVariancia::Dobradica,
214
- eps_raiz: 1e-12,
215
- k_softplus: 5.0,
216
  })
217
  }
218
 
219
- /// v0.10.0 — define o modo do termo de variância (J-1′). Aditivo: o
220
- /// default `Dobradica` preserva o comportamento bit-a-bit das
221
- /// versões anteriores (SOTA VICReg canônico — Bardes et al. 2022).
222
- pub fn definir_modo_variancia(&mut self, modo: ModoVariancia, eps_raiz: f64, k_softplus: f64) {
223
- self.modo_var = modo;
224
- self.eps_raiz = eps_raiz.max(0.0);
225
- self.k_softplus = k_softplus.max(1e-3);
 
226
  }
227
 
228
  pub fn vars(&self) -> Vec<Var> {
@@ -271,67 +245,57 @@ impl NucleoJepa {
271
 
272
  /// Regularizador variância-covariância do lote de incorporações z (n, d).
273
  ///
274
- /// **J-1′ (v0.10.0):** no colapso total `z_i = c ∀i` ⇒ `std_j = 0` ⇒
275
- /// `V = γ²` (Dobradica). O colapso é uma SELA SHARP, não um ponto de
276
- /// mínimo: `D⁺V(u) = −(2γ/d)·Σ_j s_j(u) < 0` para toda direção centrada
277
- /// `u ≠ 0` — prova em r-35 §1.2. A crítica DeepSeek ao argumento de ponto
278
- /// crítico da v0.5.0 é PROCEDENTE (cadeia inválida pela raiz); a correção
279
- /// proposta (softplus) é REFUTADA (j1d) — o kink é da raiz, não da
280
- /// dobradiça. Modos alternativos: `RaizSuavizada` (único C^∞ em z, sela
281
- /// estrita com escape quadrático) e `Softplus` (opt-in, ver enum).
282
  pub fn perda_vc(&self, z: &Tensor) -> Result<Tensor> {
283
  let n = z.dim(0)? as f64;
284
  let d = self.d_emb;
285
  let media = z.mean_keepdim(0)?; // (1, d)
286
  let centr = z.broadcast_sub(&media)?;
287
  let var = (centr.sqr()?.sum(0)? / n)?; // (d,)
288
- // std por modo (J-1′): o kink está na RAIZ, não na dobradiça
289
- let std = match self.modo_var {
290
- ModoVariancia::RaizSuavizada => {
291
- let eps_t = Tensor::new(self.eps_raiz as f32, z.device())?
292
- .broadcast_as(var.dims())?;
293
- (&var + &eps_t)?.sqrt()?
294
- }
295
- ModoVariancia::Dobradica | ModoVariancia::Softplus => var.sqrt()?,
296
- };
297
- let gamma_t =
298
- Tensor::new(self.gamma_vc as f32, z.device())?.broadcast_as(std.dims())?;
299
- let gap: Tensor = match self.modo_var {
300
- ModoVariancia::Dobradica | ModoVariancia::RaizSuavizada => {
301
- // dobradiça: max(0, γ − std) — C¹ em std (derivada 0 em std=γ)
302
- (gamma_t.broadcast_sub(&std)?).clamp(0.0, f64::INFINITY)?
303
- }
304
- ModoVariancia::Softplus => {
305
- // sp(k(γ−std)) = log(1+e^{k(γ−std)}) — forma direta é estável
306
- // no domínio |k(γ−std)| ≤ k·max(γ,std) (f32 satura e^x em
307
- // x>88; k·γ ≤ 50 por construção do setter)
308
- let x = (gamma_t.broadcast_sub(&std)?.affine(self.k_softplus, 0.0))?
309
- .exp()?;
310
- (&x + 1.0)?.log()?
311
- }
312
  };
313
- let v = gap.sqr()?.sum_all()?;
314
- // covariância fora-diagonal: C = centrᵀ·centr/n; perda = ‖offdiag(C)‖²_F/(2d)
315
- //
316
- // **BUG v100-1 (corrigido na v0.10.0)**: até a v0.9.0 a máscara
317
- // tinha 1s NA diagonal — o termo computava `Σ_j var_j²/(2d)`
318
- // (quadrado das VARIÂNCIAS) em vez do fora-diagonal documentado e
319
- // provado (r-20 §0, Corolário J-1.1 sobre rank(Cov) < d). O
320
- // contraexemplo foi exposto pelo teste de compatibilidade j1e
321
- // (falsificação pedida pela crítica DeepSeek) — o gate agora valida
322
- // contra a referência CORRETA. Efeito da correção: o termo passa a
323
- // DESCORRELACIONAR dimensões (sua função provada); a dobradiça
324
- // continua responsável pelo anti-colapso (J-1′).
325
  let cov = (centr.transpose(0, 1)?.matmul(&centr)? / n)?; // (d, d)
326
  let mask_fora = {
327
- let mut m = vec![1f32; d * d];
328
  for i in 0..d {
329
- m[i * d + i] = 0.0;
 
 
 
 
330
  }
331
  Tensor::from_vec(m, (d, d), z.device())?
332
  };
333
  let fora = ((&cov * &mask_fora)?.sqr()?.sum_all()? / (2.0 * d.max(1) as f64))?;
334
- let v_norm = (v / d.max(1) as f64)?;
335
  Ok((v_norm + fora)?)
336
  }
337
 
@@ -529,7 +493,7 @@ pub fn pontos_mais_distantes(pontos: &[Vec<f64>], k: usize, rng: &mut RngDetermi
529
  .iter()
530
  .enumerate()
531
  .filter(|(i, _)| !centros.contains(i))
532
- .max_by(|a, b| a.1.total_cmp(b.1))
533
  .map(|(i, _)| i)
534
  .unwrap_or(0);
535
  centros.push(prox);
@@ -677,7 +641,7 @@ pub fn em_grupos_pontos(pc: &Tensor, k: usize, m: usize, rng: &mut RngDeterminis
677
  ord.sort_by(|&a, &b| {
678
  let da = distancia_eucl(&coords_f[a], &coords_f[ci]);
679
  let db = distancia_eucl(&coords_f[b], &coords_f[ci]);
680
- da.total_cmp(&db)
681
  });
682
  let mut buf: Vec<f32> = Vec::with_capacity(m * d);
683
  for &idx in ord.iter().take(m) {
@@ -739,10 +703,6 @@ pub struct CfgJepa {
739
  pub semente: u64,
740
  /// tamanho do bloco-alvo (nº de patches por bloco).
741
  pub tam_bloco: usize,
742
- /// v0.10.0 (J-1′, crítica DeepSeek): modo do termo de variância.
743
- pub modo_variancia: ModoVariancia,
744
- pub eps_raiz: f64,
745
- pub k_softplus: f64,
746
  }
747
 
748
  impl Default for CfgJepa {
@@ -757,18 +717,10 @@ impl Default for CfgJepa {
757
  frac_mascara: 0.35,
758
  semente: 42,
759
  tam_bloco: 2,
760
- modo_variancia: ModoVariancia::Dobradica,
761
- eps_raiz: 1e-12,
762
- k_softplus: 5.0,
763
  }
764
  }
765
  }
766
 
767
- /// Aplica o modo de variância da cfg a um núcleo recém-construído (v0.10.0).
768
- pub fn aplicar_modo_variancia(nucleo: &mut NucleoJepa, cfg: &CfgJepa) {
769
- nucleo.definir_modo_variancia(cfg.modo_variancia, cfg.eps_raiz, cfg.k_softplus);
770
- }
771
-
772
  /// Relatório de treino de uma variante.
773
  #[derive(Debug, Clone)]
774
  pub struct RelatorioJepa {
@@ -807,7 +759,7 @@ pub fn treinar_variante(
807
  let mut nucleo = NucleoJepa::novo_com_semente(
808
  d_patch,
809
  cfg.d_emb,
810
- if cond.is_some() { cond.as_ref().unwrap().dim(1)? } else { 0 },
811
  n,
812
  cfg.m,
813
  cfg.lambda_vc,
@@ -815,7 +767,6 @@ pub fn treinar_variante(
815
  cfg.semente,
816
  dev,
817
  )?;
818
- aplicar_modo_variancia(&mut nucleo, &cfg);
819
  let otimo_vars = nucleo.vars();
820
  let mut otimizador = crate::treino::AdamWManual::novo(otimo_vars, cfg.lr, 0.01);
821
 
@@ -977,7 +928,7 @@ pub fn treinar_variante_adaptativa(
977
  let mut nucleo = NucleoJepa::novo_com_semente(
978
  d_patch,
979
  cfg.d_emb,
980
- if cond.is_some() { cond.as_ref().unwrap().dim(1)? } else { 0 },
981
  n,
982
  cfg.m,
983
  cfg.lambda_vc,
@@ -985,7 +936,6 @@ pub fn treinar_variante_adaptativa(
985
  cfg.semente,
986
  dev,
987
  )?;
988
- aplicar_modo_variancia(&mut nucleo, &cfg);
989
  let otimo_vars = nucleo.vars();
990
  let mut otimizador = crate::treino::AdamWManual::novo(otimo_vars, cfg.lr, 0.01);
991
  let z0 = nucleo.codificar(patches)?;
@@ -1134,6 +1084,26 @@ impl SonicMoe {
1134
  Ok(Self { roteador, especialistas, n_top, capacidade, lambda_aux: 0.01 })
1135
  }
1136
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1137
  pub fn vars(&self) -> Vec<Var> {
1138
  let mut v = self.roteador.vars();
1139
  for e in &self.especialistas {
@@ -1164,6 +1134,8 @@ impl SonicMoe {
1164
  let mut cand: Vec<(usize, f32)> = (0..n)
1165
  .map(|i| (i, probs_v[i][ei]))
1166
  .collect();
 
 
1167
  cand.sort_by(|a, b| b.1.total_cmp(&a.1));
1168
  let mut escolhidos: Vec<usize> = Vec::new();
1169
  for (i, _) in cand {
@@ -1173,7 +1145,7 @@ impl SonicMoe {
1173
  // verifica se ei está no top-k do token i
1174
  let mut ordem: Vec<(f32, usize)> =
1175
  (0..e).map(|k| (probs_v[i][k], k)).collect();
1176
- ordem.sort_by(|a, b| b.0.total_cmp(&a.0));
1177
  let top: Vec<usize> = ordem.iter().rev().take(self.n_top).map(|(_, k)| *k).collect();
1178
  if top.contains(&ei) {
1179
  escolhidos.push(i);
@@ -1286,6 +1258,32 @@ impl ReplaySsm {
1286
  })
1287
  }
1288
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1289
  pub fn vars(&self) -> Vec<Var> {
1290
  vec![self.a.clone(), self.b.clone()]
1291
  }
@@ -1307,6 +1305,20 @@ impl ReplaySsm {
1307
  Ok(Tensor::stack(&saidas, 0)?)
1308
  }
1309
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1310
  /// Empurra uma janela de treino no buffer (FIFO).
1311
  pub fn guardar(&mut self, x: &Tensor) {
1312
  if self.buffer.len() >= self.capacidade_buffer {
@@ -1372,7 +1384,6 @@ pub fn treinar_lejepa(
1372
  let mut nucleo = NucleoJepa::novo_com_semente(
1373
  d_patch, cfg.d_emb, d_cond, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev,
1374
  )?;
1375
- aplicar_modo_variancia(&mut nucleo, &cfg);
1376
  let mut otim = crate::treino::AdamWManual::novo(nucleo.vars(), cfg.lr, 0.01);
1377
  let mut perda_inicial = f64::NAN;
1378
  let mut perda_final = f64::NAN;
@@ -1444,8 +1455,6 @@ pub fn treinar_mcjepa(
1444
  // núcleo A→B e núcleo B→A (compartilham apenas a estrutura)
1445
  let mut nb = NucleoJepa::novo_com_semente(d_a, cfg.d_emb, 0, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev)?;
1446
  let mut na = NucleoJepa::novo_com_semente(d_b, cfg.d_emb, 0, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev)?;
1447
- aplicar_modo_variancia(&mut nb, &cfg);
1448
- aplicar_modo_variancia(&mut na, &cfg);
1449
  let mut otim = crate::treino::AdamWManual::novo(
1450
  [nb.vars(), na.vars()].concat(),
1451
  cfg.lr,
@@ -1521,12 +1530,10 @@ pub fn treinar_bjepa(patches: &Tensor, cfg: &CfgJepa, dev: &Device) -> Result<Re
1521
  let mut nucleo = NucleoJepa::novo_com_semente(
1522
  d_patch, cfg.d_emb, 0, 2, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev,
1523
  )?;
1524
- aplicar_modo_variancia(&mut nucleo, &cfg);
1525
  // preditor anti-causal: núcleo separado
1526
  let mut ninv = NucleoJepa::novo_com_semente(
1527
  d_patch, cfg.d_emb, 0, 2, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev,
1528
  )?;
1529
- aplicar_modo_variancia(&mut nucleo, &cfg);
1530
  let mut otim =
1531
  crate::treino::AdamWManual::novo([nucleo.vars(), ninv.vars()].concat(), cfg.lr, 0.01);
1532
  let mut perda_inicial = f64::NAN;
@@ -1610,13 +1617,204 @@ pub fn mascara_por_variante(
1610
  }
1611
 
1612
  pub fn versao() -> &'static str {
1613
- "jepa-0.5.0"
1614
  }
1615
 
1616
  #[cfg(test)]
1617
  mod testes {
1618
  use super::*;
1619
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1620
  fn tensor_2d(dados: &[Vec<f64>], dev: &Device) -> Tensor {
1621
  let flat: Vec<f32> = dados.iter().flat_map(|v| v.iter().map(|&x| x as f32)).collect();
1622
  Tensor::from_vec(flat, (dados.len(), dados[0].len()), dev).unwrap()
@@ -1739,212 +1937,6 @@ mod testes {
1739
  assert!(v > 0.9, "perda VC no colapso = {v} (deveria ser ~1)");
1740
  }
1741
 
1742
- // -----------------------------------------------------------------
1743
- // v0.10.0 — J-1′ (crítica DeepSeek): o colapso é SELA SHARP, não
1744
- // ponto crítico; o kink é da RAIZ (não da dobradiça); softplus NÃO
1745
- // restaura diferenciabilidade w.r.t. z. Provas em r-35 §1.
1746
- // -----------------------------------------------------------------
1747
-
1748
- /// Lote de colapso + direção centrada u (col 0: metade +1 metade −1;
1749
- /// col 1: alternado ±1) — ambas as colunas com s_j = 1, média 0.
1750
- fn lote_e_direcao_j1(n: usize, d: usize) -> (Vec<f32>, Vec<f32>) {
1751
- let mut z = vec![0.5f32; n * d];
1752
- let mut u = vec![0f32; n * d];
1753
- for i in 0..n {
1754
- for j in 0..d {
1755
- let s0 = if i < n / 2 { 1.0 } else { -1.0 };
1756
- let s1 = if i % 2 == 0 { 1.0 } else { -1.0 };
1757
- let s = if j == 0 { s0 } else { s1 };
1758
- u[i * d + j] = s;
1759
- }
1760
- }
1761
- z.shrink_to_fit();
1762
- (z, u)
1763
- }
1764
-
1765
- #[test]
1766
- fn teste_j1a_dobradica_gradiente_indefinido_no_colapso() {
1767
- // Falsificação da prova v0.5.0 (r-20 §1): no colapso exato, a
1768
- // retropropagação da Dobradica através de std = √var produz
1769
- // gradiente NÃO-finito w.r.t. z (o produto da cadeia é −∞·0).
1770
- // "∂V/∂std = −2γ ≠ 0" NÃO implica "∇_z V ≠ 0" — a crítica
1771
- // DeepSeek procede neste ponto. (Forward permanece correto: γ².)
1772
- let dev = Device::Cpu;
1773
- let nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap();
1774
- let (z, _) = lote_e_direcao_j1(8, 8);
1775
- let zt = Tensor::from_vec(z, (8, 8), &dev).unwrap();
1776
- let zv = Var::from_tensor(&zt).unwrap();
1777
- let l = nucleo.perda_vc(&zv.as_tensor()).unwrap();
1778
- let v = l.to_scalar::<f32>().unwrap() as f64;
1779
- assert!((v - 1.0).abs() < 1e-6, "forward no colapso = {v} (esperado γ²=1)");
1780
- let grads = l.backward().unwrap();
1781
- let g = grads.get(&zv).unwrap().flatten_all().unwrap().to_vec1::<f32>().unwrap();
1782
- let n_nao_finitos = g.iter().filter(|x| !x.is_finite()).count();
1783
- // registra o comportamento REAL do autograd no colapso exato
1784
- println!("j1a: não-finitos no gradiente z = {n_nao_finitos}/{}", g.len());
1785
- assert!(
1786
- g.iter().any(|x| !x.is_finite()),
1787
- "esperado gradiente não-finito no colapso exato (kink da raiz); \
1788
- se isto falhar, o autograd do candle short-circuitou o kink — \
1789
- atualizar r-35 §1.4 com a medição nova"
1790
- );
1791
- }
1792
-
1793
- #[test]
1794
- fn teste_j1b_sela_sharp_descida_linear() {
1795
- // J-1′-ii: D⁺V(u) = −(2γ/d)·Σ_j s_j(u) — descida LINEAR em |t|.
1796
- // n=8, d=8, u com s_j = 1 ∀j ⇒ Σs_j = 8 ⇒ C = (2·1/8)·8 = 2.
1797
- let dev = Device::Cpu;
1798
- let nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap();
1799
- let (z, u) = lote_e_direcao_j1(8, 8);
1800
- let v_de = |t: f64| -> f64 {
1801
- let dados: Vec<f32> = z
1802
- .iter()
1803
- .zip(&u)
1804
- .map(|(&zi, &ui)| zi + (t * ui as f64) as f32)
1805
- .collect();
1806
- let zt = Tensor::from_vec(dados, (8, 8), &dev).unwrap();
1807
- nucleo.perda_vc(&zt).unwrap().to_scalar::<f32>().unwrap() as f64
1808
- };
1809
- let v0 = v_de(0.0);
1810
- let c_teorico = 2.0 * 1.0 / 8.0 * 8.0; // (2γ/d)·Σs_j = 2
1811
- let t = 0.01;
1812
- let slope = (v_de(t) - v0) / t;
1813
- assert!(
1814
- (slope + c_teorico).abs() < 0.05 * c_teorico,
1815
- "slope linear medido {slope} vs teórico −{c_teorico}"
1816
- );
1817
- // afastar-se do colapso REDUZ V (sela, não mínimo)
1818
- assert!(v_de(0.1) < v0, "V deve cair ao afastar do colapso (sela sharp)");
1819
- }
1820
-
1821
- #[test]
1822
- fn teste_j1c_raiz_suavizada_critico_mas_sela_estrita() {
1823
- // J-1′-ii(ε): com std = √(var+ε), o gradiente no colapso EXISTE,
1824
- // é finito e IGUAL A ZERO (ponto crítico) — mas V_ε cai ao
1825
- // afastar-se (SELA ESTRITA, escape quadrático). O modo troca a
1826
- // natureza do ponto sem criar mínimo espúrio.
1827
- let dev = Device::Cpu;
1828
- let mut nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap();
1829
- nucleo.definir_modo_variancia(ModoVariancia::RaizSuavizada, 1e-6, 5.0);
1830
- let (z, u) = lote_e_direcao_j1(8, 8);
1831
- let zt = Tensor::from_vec(z.clone(), (8, 8), &dev).unwrap();
1832
- let zv = Var::from_tensor(&zt).unwrap();
1833
- let l = nucleo.perda_vc(&zv.as_tensor()).unwrap();
1834
- let grads = l.backward().unwrap();
1835
- let g = grads.get(&zv).unwrap().flatten_all().unwrap().to_vec1::<f32>().unwrap();
1836
- assert!(
1837
- g.iter().all(|x| x.is_finite()),
1838
- "RaizSuavizada: gradiente deve ser finito no colapso"
1839
- );
1840
- let mx = g.iter().fold(0f32, |a, &b| a.max(b.abs()));
1841
- assert!(mx < 1e-9, "gradiente no colapso = 0 exato (sela), máx = {mx}");
1842
- // sela estrita: afastar reduz V
1843
- let v_de = |t: f64| -> f64 {
1844
- let dados: Vec<f32> = z
1845
- .iter()
1846
- .zip(&u)
1847
- .map(|(&zi, &ui)| zi + (t * ui as f64) as f32)
1848
- .collect();
1849
- let ztt = Tensor::from_vec(dados, (8, 8), &dev).unwrap();
1850
- nucleo.perda_vc(&ztt).unwrap().to_scalar::<f32>().unwrap() as f64
1851
- };
1852
- assert!(
1853
- v_de(0.1) < v_de(0.0),
1854
- "RaizSuavizada: V_ε deve cair ao afastar (sela estrita, não mínimo)"
1855
- );
1856
- }
1857
-
1858
- #[test]
1859
- fn teste_j1d_softplus_nao_diferenciavel_em_z() {
1860
- // J-1′-iii (REFUTAÇÃO da correção proposta pela crítica): o
1861
- // softplus suaviza a dobradiça (que já era C¹) mas NÃO a raiz.
1862
- // As derivadas laterais de V w.r.t. z no colapso diferem por
1863
- // sinal ⇒ gradiente NÃO existe — a proposta não cumpre o que
1864
- // afirma ("garante diferenciabilidade em todo o domínio").
1865
- let dev = Device::Cpu;
1866
- let mut nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap();
1867
- nucleo.definir_modo_variancia(ModoVariancia::Softplus, 1e-12, 5.0);
1868
- let (z, u) = lote_e_direcao_j1(8, 8);
1869
- let v_de = |t: f64| -> f64 {
1870
- let dados: Vec<f32> = z
1871
- .iter()
1872
- .zip(&u)
1873
- .map(|(&zi, &ui)| zi + (t * ui as f64) as f32)
1874
- .collect();
1875
- let zt = Tensor::from_vec(dados, (8, 8), &dev).unwrap();
1876
- nucleo.perda_vc(&zt).unwrap().to_scalar::<f32>().unwrap() as f64
1877
- };
1878
- let t = 0.001;
1879
- // D⁺ = lim [V(t)−V(0)]/t ; D⁻ = lim [V(−t)−V(0)]/(−t)
1880
- let d_mais = (v_de(t) - v_de(0.0)) / t;
1881
- let d_menos = (v_de(-t) - v_de(0.0)) / (-t);
1882
- // constante teórica: C_sp = (2k·sp(kγ)·σ(kγ)/d)·Σs_j, γ=1, k=5, d=8, Σs=8
1883
- let (k, g, d, ss) = (5.0f64, 1.0f64, 8.0f64, 8.0f64);
1884
- let sp = |x: f64| (1.0 + x.exp()).ln();
1885
- let sg = 1.0 / (1.0 + (-k * g).exp());
1886
- let c_sp = 2.0 * k * sp(k * g) * sg / d * ss;
1887
- assert!(
1888
- d_mais < -0.5 * c_sp && d_menos > 0.5 * c_sp,
1889
- "derivadas laterais devem divergir por sinal: D⁺={d_mais:.4}, \
1890
- D⁻={d_menos:.4}, C_sp teórico={c_sp:.4} — softplus NÃO é \
1891
- diferenciável em z no colapso"
1892
- );
1893
- }
1894
-
1895
- #[test]
1896
- fn teste_j1e_compat_bit_a_bit_dobradica() {
1897
- // O default preserva o comportamento das versões anteriores: a
1898
- // Dobradica explícita produz o MESMO valor bit-a-bit que o caminho
1899
- // v0.9.0 (fórmula de referência recalculada aqui).
1900
- let dev = Device::Cpu;
1901
- let mut nucleo = NucleoJepa::novo(4, 8, 0, 4, 0.99, 1.0, 1.0, &dev).unwrap();
1902
- let mut rng = crate::rng::RngDeterministico::novo(77);
1903
- let dados: Vec<f32> = (0..8 * 8).map(|_| rng.normal(0.0, 1.0) as f32).collect();
1904
- let z = Tensor::from_vec(dados.clone(), (8, 8), &dev).unwrap();
1905
- nucleo.definir_modo_variancia(ModoVariancia::Dobradica, 1e-12, 5.0);
1906
- let bits = nucleo
1907
- .perda_vc(&z)
1908
- .unwrap()
1909
- .to_scalar::<f32>()
1910
- .unwrap()
1911
- .to_bits();
1912
- // referência v0.9.0 recalculada de forma independente (f64):
1913
- // V = (1/d)Σ_j max(0,γ−std_j)² + ‖offdiag(Cov)‖²_F/(2d)
1914
- let gamma = 1.0f64;
1915
- let mut v_var = 0.0f64;
1916
- for j in 0..8 {
1917
- let media: f64 = (0..8).map(|i| dados[i * 8 + j] as f64).sum::<f64>() / 8.0;
1918
- let var: f64 = (0..8)
1919
- .map(|i| (dados[i * 8 + j] as f64 - media).powi(2))
1920
- .sum::<f64>()
1921
- / 8.0;
1922
- v_var += (gamma - var.sqrt()).max(0.0).powi(2);
1923
- }
1924
- v_var /= 8.0;
1925
- let mut v_cov = 0.0f64;
1926
- for a in 0..8 {
1927
- for b in 0..8 {
1928
- if a != b {
1929
- let ma: f64 = (0..8).map(|i| dados[i * 8 + a] as f64).sum::<f64>() / 8.0;
1930
- let mb: f64 = (0..8).map(|i| dados[i * 8 + b] as f64).sum::<f64>() / 8.0;
1931
- let cab: f64 = (0..8)
1932
- .map(|i| (dados[i * 8 + a] as f64 - ma) * (dados[i * 8 + b] as f64 - mb))
1933
- .sum::<f64>()
1934
- / 8.0;
1935
- v_cov += cab * cab;
1936
- }
1937
- }
1938
- }
1939
- v_cov /= 2.0 * 8.0;
1940
- let v_ref = v_var + v_cov;
1941
- let obtido = f32::from_bits(bits) as f64;
1942
- assert!(
1943
- (obtido - v_ref).abs() < 1e-5,
1944
- "Dobradica deve reproduzir a fórmula v0.9.0: {obtido} vs {v_ref}"
1945
- );
1946
- }
1947
-
1948
  #[test]
1949
  fn teste_j2_ema_ponto_fixo() {
1950
  // encoder congelado ⇒ após muitas passadas EMA, alvo = encoder
@@ -2027,6 +2019,40 @@ mod testes {
2027
  assert_eq!(gr.dims().to_vec(), vec![6, 12]);
2028
  }
2029
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2030
  #[test]
2031
  fn teste_sonic_moe_capacidade_e_balanceamento() {
2032
  // SM-1: carga por especialista ≤ capacidade; SM-2: aux ≥ ~1 quando
 
103
  }
104
  }
105
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
106
  /// Núcleo JEPA: codificador + preditor + alvo EMA + regularizador VC.
107
  pub struct NucleoJepa {
108
  pub encoder: MlpJepa,
 
115
  pub m: f64,
116
  pub lambda_vc: f64,
117
  pub gamma_vc: f64,
118
+ /// v0.11 (r-37 J-1′): regularizador VC suavizado C^∞.
119
+ /// `false` = dobradiça original `max(0, γ−std)²` (bit-a-bit histórico;
120
+ /// **não-diferenciável em var=0** — autodiff produz NaN/0 no colapso
121
+ /// exato, errata r-37: o defeito é numérico, não de existência).
122
+ /// `true` = `softplus(k(γ−√(var+ε)))²` com `ε>0` — J-1′(a) C^∞ em z;
123
+ /// J-1′(b) gap `sp(kγ)²−(ln2)² > 0` ⇒ colapso nunca é minimizador
124
+ /// global; J-1′(c) colapso é SELA INSTÁVEL (curvatura < 0 em toda
125
+ /// direção de espalhamento — escape sob SGD com ruído não-degenerado).
126
+ pub vc_suave: bool,
127
+ /// dureza do softplus (k→∞ recupera a dobradiça suavizada).
128
+ pub k_vc: f64,
129
+ /// ε do std suavizado (r-37: ε ≪ γ², ex. 1e-4·γ²).
130
+ pub eps_vc: f64,
131
  }
132
 
133
  impl NucleoJepa {
 
183
  m,
184
  lambda_vc,
185
  gamma_vc,
186
+ vc_suave: false,
187
+ k_vc: 5.0,
188
+ eps_vc: 1e-4 * gamma_vc * gamma_vc,
189
  })
190
  }
191
 
192
+ /// v0.11 (r-37 J-1′): ativa o regularizador VC suavizado C^∞ e devolve
193
+ /// `self` (builder). `k` = dureza do softplus; `eps` = ε do std
194
+ /// suavizado (`eps ≤ 0` ⇒ default 1e-4·γ²).
195
+ pub fn ativar_vc_suave(mut self, k: f64, eps: f64) -> Self {
196
+ self.vc_suave = true;
197
+ self.k_vc = if k > 0.0 { k } else { 5.0 };
198
+ self.eps_vc = if eps > 0.0 { eps } else { 1e-4 * self.gamma_vc * self.gamma_vc };
199
+ self
200
  }
201
 
202
  pub fn vars(&self) -> Vec<Var> {
 
245
 
246
  /// Regularizador variância-covariância do lote de incorporações z (n, d).
247
  ///
248
+ /// **J-1 (errata r-37):** a alegação original "gradiente não-nulo no
249
+ /// colapso" é FALSA em θ (var é estacionária em z=c: ∂var/∂z=0) e o
250
+ /// cálculo em floats produz NaN (sqrt′(0)=∞, 0·∞). A análise CORRETA
251
+ /// (r-37 J-1′): o colapso é MÁXIMO LOCAL estrito de V ao longo de toda
252
+ /// direção de espalhamento (derivada direcional −(2γ/√n)‖v‖ < 0) — o
253
+ /// defeito é NUMÉRICO, não de existência. Com `vc_suave=true` a versão
254
+ /// C^∞ `softplus(k(γ−√(var+ε)))²` é usada (J-1′ a/b/c).
 
255
  pub fn perda_vc(&self, z: &Tensor) -> Result<Tensor> {
256
  let n = z.dim(0)? as f64;
257
  let d = self.d_emb;
258
  let media = z.mean_keepdim(0)?; // (1, d)
259
  let centr = z.broadcast_sub(&media)?;
260
  let var = (centr.sqr()?.sum(0)? / n)?; // (d,)
261
+ let v_norm: Tensor = if self.vc_suave {
262
+ // J-1′: std_ε = √(var+ε) ≥ √ε > 0 ⇒ C^∞; softplus estável.
263
+ let std_e = (var.affine(1.0, self.eps_vc)?).sqrt()?; // √(var+ε) ≥ √ε
264
+ let x = std_e.affine(-self.k_vc, self.k_vc * self.gamma_vc)?; // k(γ−std_ε)
265
+ let xa = x.abs()?;
266
+ // ln(1+e^{−|x|}) — softplus estável (sem overflow)
267
+ let ln_um_mais = xa.affine(-1.0, 0.0)?.exp()?.affine(1.0, 1.0)?.log()?;
268
+ let sp = (x.clamp(0.0, f64::INFINITY)? + ln_um_mais)?;
269
+ (sp.sqr()?.sum_all()? / d.max(1) as f64)?
270
+ } else {
271
+ // dobradiça original (bit-a-bit histórica)
272
+ let std = var.sqrt()?;
273
+ let gamma_t =
274
+ Tensor::new(self.gamma_vc as f32, z.device())?.broadcast_as(std.dims())?;
275
+ let gap = gamma_t.broadcast_sub(&std)?.clamp(0.0, f64::INFINITY)?;
276
+ let v = gap.sqr()?.sum_all()?;
277
+ (v / d.max(1) as f64)?
 
 
 
 
 
 
 
278
  };
279
+ // covariância fora-diagonal: C = centrᵀ·centr/n; perda =
280
+ // Σ_{i≠j} C_ij²/(2d) — decorrelação VICReg.
281
+ // BUG v011-1 (autocrítica r-37): a máscara marcava a DIAGONAL
282
+ // (penalizava var_i², OPOSTO ao objetivo da dobradiça) em vez da
283
+ // fora-diagonal — o comentário prometia ‖C−diag‖²_F e o código
284
+ // calculava ‖diag(C)‖². Corrigido: 1 fora da diagonal, 0 nela
285
+ // (d=1 ⇒ termo vazio, como deve ser). Teste: j1f_cov_fora_diagonal.
 
 
 
 
 
286
  let cov = (centr.transpose(0, 1)?.matmul(&centr)? / n)?; // (d, d)
287
  let mask_fora = {
288
+ let mut m = vec![0f32; d * d];
289
  for i in 0..d {
290
+ for j in 0..d {
291
+ if i != j {
292
+ m[i * d + j] = 1.0;
293
+ }
294
+ }
295
  }
296
  Tensor::from_vec(m, (d, d), z.device())?
297
  };
298
  let fora = ((&cov * &mask_fora)?.sqr()?.sum_all()? / (2.0 * d.max(1) as f64))?;
 
299
  Ok((v_norm + fora)?)
300
  }
301
 
 
493
  .iter()
494
  .enumerate()
495
  .filter(|(i, _)| !centros.contains(i))
496
+ .max_by(|a, b| a.1.partial_cmp(b.1).unwrap())
497
  .map(|(i, _)| i)
498
  .unwrap_or(0);
499
  centros.push(prox);
 
641
  ord.sort_by(|&a, &b| {
642
  let da = distancia_eucl(&coords_f[a], &coords_f[ci]);
643
  let db = distancia_eucl(&coords_f[b], &coords_f[ci]);
644
+ da.partial_cmp(&db).unwrap()
645
  });
646
  let mut buf: Vec<f32> = Vec::with_capacity(m * d);
647
  for &idx in ord.iter().take(m) {
 
703
  pub semente: u64,
704
  /// tamanho do bloco-alvo (nº de patches por bloco).
705
  pub tam_bloco: usize,
 
 
 
 
706
  }
707
 
708
  impl Default for CfgJepa {
 
717
  frac_mascara: 0.35,
718
  semente: 42,
719
  tam_bloco: 2,
 
 
 
720
  }
721
  }
722
  }
723
 
 
 
 
 
 
724
  /// Relatório de treino de uma variante.
725
  #[derive(Debug, Clone)]
726
  pub struct RelatorioJepa {
 
759
  let mut nucleo = NucleoJepa::novo_com_semente(
760
  d_patch,
761
  cfg.d_emb,
762
+ if cond.is_some() { cond.unwrap().dim(1)? } else { 0 },
763
  n,
764
  cfg.m,
765
  cfg.lambda_vc,
 
767
  cfg.semente,
768
  dev,
769
  )?;
 
770
  let otimo_vars = nucleo.vars();
771
  let mut otimizador = crate::treino::AdamWManual::novo(otimo_vars, cfg.lr, 0.01);
772
 
 
928
  let mut nucleo = NucleoJepa::novo_com_semente(
929
  d_patch,
930
  cfg.d_emb,
931
+ if cond.is_some() { cond.unwrap().dim(1)? } else { 0 },
932
  n,
933
  cfg.m,
934
  cfg.lambda_vc,
 
936
  cfg.semente,
937
  dev,
938
  )?;
 
939
  let otimo_vars = nucleo.vars();
940
  let mut otimizador = crate::treino::AdamWManual::novo(otimo_vars, cfg.lr, 0.01);
941
  let z0 = nucleo.codificar(patches)?;
 
1084
  Ok(Self { roteador, especialistas, n_top, capacidade, lambda_aux: 0.01 })
1085
  }
1086
 
1087
+ /// v0.11 (quita o débito r-34 §12): construção com RNG DETERMINÍSTICO —
1088
+ /// mesma semente ⇒ mesmos pesos bit-a-bit (mesma distribuição N(0, s);
1089
+ /// só a FONTE de aleatoriedade muda). Padrão já adotado por
1090
+ /// `NucleoJepa::novo_com_semente` e `MotorPensamento::novo_com_semente`.
1091
+ pub fn novo_com_semente(
1092
+ d: usize,
1093
+ n_expertos: usize,
1094
+ n_top: usize,
1095
+ capacidade: usize,
1096
+ semente: u64,
1097
+ dev: &Device,
1098
+ ) -> Result<Self> {
1099
+ let mut rng = RngDeterministico::novo(semente);
1100
+ let roteador = Linear::sem_vies_semeado(d, n_expertos, 0.1, dev, &mut rng)?;
1101
+ let especialistas = (0..n_expertos)
1102
+ .map(|_| MlpJepa::novo_semeado(d, 2 * d, d, dev, &mut rng))
1103
+ .collect::<Result<Vec<_>>>()?;
1104
+ Ok(Self { roteador, especialistas, n_top, capacidade, lambda_aux: 0.01 })
1105
+ }
1106
+
1107
  pub fn vars(&self) -> Vec<Var> {
1108
  let mut v = self.roteador.vars();
1109
  for e in &self.especialistas {
 
1134
  let mut cand: Vec<(usize, f32)> = (0..n)
1135
  .map(|i| (i, probs_v[i][ei]))
1136
  .collect();
1137
+ // total_cmp: ordem total determinística (sem unwrap em NaN —
1138
+ // v0.11: zero unwrap no caminho quente)
1139
  cand.sort_by(|a, b| b.1.total_cmp(&a.1));
1140
  let mut escolhidos: Vec<usize> = Vec::new();
1141
  for (i, _) in cand {
 
1145
  // verifica se ei está no top-k do token i
1146
  let mut ordem: Vec<(f32, usize)> =
1147
  (0..e).map(|k| (probs_v[i][k], k)).collect();
1148
+ ordem.sort_by(|a, b| a.0.total_cmp(&b.0));
1149
  let top: Vec<usize> = ordem.iter().rev().take(self.n_top).map(|(_, k)| *k).collect();
1150
  if top.contains(&ei) {
1151
  escolhidos.push(i);
 
1258
  })
1259
  }
1260
 
1261
+ /// v0.11 (quita o débito r-34 §12): construção com RNG DETERMINÍSTICO —
1262
+ /// portas `a ~ N(0, 0,5)` e projeção `B ~ N(0, 0,1)` nascem de
1263
+ /// `RngDeterministico` semeado (mesma distribuição, fonte semeada).
1264
+ pub fn novo_com_semente(
1265
+ d_in: usize,
1266
+ d: usize,
1267
+ alpha_replay: f64,
1268
+ capacidade_buffer: usize,
1269
+ semente: u64,
1270
+ dev: &Device,
1271
+ ) -> Result<Self> {
1272
+ let mut rng = RngDeterministico::novo(semente);
1273
+ let a_dados: Vec<f32> = (0..d).map(|_| rng.normal(0.0, 0.5) as f32).collect();
1274
+ let b_dados: Vec<f32> = (0..d_in * d).map(|_| rng.normal(0.0, 0.1) as f32).collect();
1275
+ let a_t = Tensor::from_vec(a_dados, (d,), dev)?;
1276
+ let b_t = Tensor::from_vec(b_dados, (d_in, d), dev)?;
1277
+ Ok(Self {
1278
+ a: Var::from_tensor(&a_t)?,
1279
+ b: Var::from_tensor(&b_t)?,
1280
+ d,
1281
+ alpha_replay,
1282
+ buffer: Vec::new(),
1283
+ capacidade_buffer,
1284
+ })
1285
+ }
1286
+
1287
  pub fn vars(&self) -> Vec<Var> {
1288
  vec![self.a.clone(), self.b.clone()]
1289
  }
 
1305
  Ok(Tensor::stack(&saidas, 0)?)
1306
  }
1307
 
1308
+ /// v0.11: scan de INFERÊNCIA — recorrência fundida em ASSEMBLY
1309
+ /// AVX-512 (`asm_x86::scan_ssm`): UM despacho para T·d passos em vez
1310
+ /// de ~5 ops de tensor por passo; bit-a-bit idêntico ao `scan`
1311
+ /// (zeros na origem, mul/mul/add na mesma ordem — teste
1312
+ /// `scan_asm_bit_a_bit`). NaN/Inf ⇒ Err (flag EAX do Assembly).
1313
+ /// Sem grafo de autograd — usar apenas fora do treino.
1314
+ pub fn scan_inferencia(&self, x: &Tensor) -> Result<Tensor> {
1315
+ let t = x.dim(0)?;
1316
+ let porta = candle_nn::ops::sigmoid(&self.a.as_tensor().broadcast_as((1, self.d))?)?;
1317
+ let um_menos = porta.affine(-1.0, 1.0)?;
1318
+ let entrada = x.matmul(&self.b.as_tensor())?;
1319
+ crate::asm_x86::scan_ssm(&porta, &um_menos, &entrada, t, self.d)
1320
+ }
1321
+
1322
  /// Empurra uma janela de treino no buffer (FIFO).
1323
  pub fn guardar(&mut self, x: &Tensor) {
1324
  if self.buffer.len() >= self.capacidade_buffer {
 
1384
  let mut nucleo = NucleoJepa::novo_com_semente(
1385
  d_patch, cfg.d_emb, d_cond, 1, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev,
1386
  )?;
 
1387
  let mut otim = crate::treino::AdamWManual::novo(nucleo.vars(), cfg.lr, 0.01);
1388
  let mut perda_inicial = f64::NAN;
1389
  let mut perda_final = f64::NAN;
 
1455
  // núcleo A→B e núcleo B→A (compartilham apenas a estrutura)
1456
  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)?;
1457
  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)?;
 
 
1458
  let mut otim = crate::treino::AdamWManual::novo(
1459
  [nb.vars(), na.vars()].concat(),
1460
  cfg.lr,
 
1530
  let mut nucleo = NucleoJepa::novo_com_semente(
1531
  d_patch, cfg.d_emb, 0, 2, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev,
1532
  )?;
 
1533
  // preditor anti-causal: núcleo separado
1534
  let mut ninv = NucleoJepa::novo_com_semente(
1535
  d_patch, cfg.d_emb, 0, 2, cfg.m, cfg.lambda_vc, cfg.gamma_vc, cfg.semente, dev,
1536
  )?;
 
1537
  let mut otim =
1538
  crate::treino::AdamWManual::novo([nucleo.vars(), ninv.vars()].concat(), cfg.lr, 0.01);
1539
  let mut perda_inicial = f64::NAN;
 
1617
  }
1618
 
1619
  pub fn versao() -> &'static str {
1620
+ "jepa-0.11.0"
1621
  }
1622
 
1623
  #[cfg(test)]
1624
  mod testes {
1625
  use super::*;
1626
 
1627
+ // ------------------------------------------------------------------
1628
+ // v0.11 — r-37: J-1′ (VC suave C^∞), J-3′ (decomposição L² exata)
1629
+ // ------------------------------------------------------------------
1630
+
1631
+ /// J-1′(a): V_suave é C^∞ INCLUSIVE no colapso exato (var=0) —
1632
+ /// gradiente autodiff FINITO (a dobradiça original produz NaN aí,
1633
+ /// errata r-37) e confere com diferenças finitas no quase-colapso.
1634
+ #[test]
1635
+ fn j1c_suave_c_infinito() -> Result<()> {
1636
+ let dev = Device::Cpu;
1637
+ let (n, d) = (8usize, 6usize);
1638
+ let nucleo = NucleoJepa::novo(4, d, 2, 3, 0.996, 0.1, 1.0, &dev)?.ativar_vc_suave(5.0, 1e-4);
1639
+ // (i) colapso exato: SEM NaN (o defeito numérico da dobradiça)
1640
+ let z0 = Tensor::from_vec(vec![0.37f32; n * d], (n, d), &dev)?;
1641
+ let v = nucleo.perda_vc(&z0)?;
1642
+ assert!(v.to_scalar::<f32>()?.is_finite());
1643
+ let zv = Var::from_tensor(&z0)?;
1644
+ let vv = nucleo.perda_vc(zv.as_tensor())?;
1645
+ let grads = vv.backward()?;
1646
+ let g = grads
1647
+ .get(&zv)
1648
+ .expect("grad presente")
1649
+ .flatten_all()?
1650
+ .to_vec1::<f32>()?;
1651
+ assert!(g.iter().all(|x| x.is_finite()), "NaN no gradiente do colapso");
1652
+ // (ii) quase-colapso: autodiff == diferenças finitas
1653
+ let mut rng = crate::rng::RngDeterministico::novo(3);
1654
+ let dados: Vec<f32> = (0..n * d).map(|_| 0.37 + rng.normal(0.0, 0.01) as f32).collect();
1655
+ let zq = Tensor::from_vec(dados, (n, d), &dev)?;
1656
+ let zq_var = Var::from_tensor(&zq)?;
1657
+ let vq = nucleo.perda_vc(zq_var.as_tensor())?;
1658
+ let gq = vq.backward()?;
1659
+ let gv = gq
1660
+ .get(&zq_var)
1661
+ .expect("grad")
1662
+ .flatten_all()?
1663
+ .to_vec1::<f32>()?;
1664
+ let h = 1e-3f32;
1665
+ let mut err_max = 0.0f64;
1666
+ for (i, j) in [(0usize, 0usize), (3, 2), (7, 5), (4, 4)] {
1667
+ let mut zp = zq.flatten_all()?.to_vec1::<f32>()?;
1668
+ let mut zm = zp.clone();
1669
+ zp[i * d + j] += h;
1670
+ zm[i * d + j] -= h;
1671
+ let tp = Tensor::from_vec(zp, (n, d), &dev)?;
1672
+ let tm = Tensor::from_vec(zm, (n, d), &dev)?;
1673
+ let fd = (nucleo.perda_vc(&tp)?.to_scalar::<f32>()?
1674
+ - nucleo.perda_vc(&tm)?.to_scalar::<f32>()?) as f64
1675
+ / (2.0 * h as f64);
1676
+ let ad = gv[i * d + j] as f64;
1677
+ err_max = err_max.max((fd - ad).abs());
1678
+ }
1679
+ assert!(err_max < 2e-3, "J-1′(a): FD vs autodiff = {err_max}");
1680
+ Ok(())
1681
+ }
1682
+
1683
+ /// J-1′(c): o colapso é MÁXIMO LOCAL estrito de V_suave ao longo de
1684
+ /// toda direção de espalhamento — V(c + t·u) estritamente decrescente
1685
+ /// em t ∈ (0, γ). (Sela instável: escape garantido sob ruído.)
1686
+ #[test]
1687
+ fn j1d_colapso_sela() -> Result<()> {
1688
+ let dev = Device::Cpu;
1689
+ let (n, d) = (8usize, 4usize);
1690
+ let nucleo = NucleoJepa::novo(4, d, 2, 3, 0.996, 0.1, 1.0, &dev)?.ativar_vc_suave(5.0, 1e-4);
1691
+ // direção de espalhamento: metade +1, metade −1 (média zero)
1692
+ let v = |t: f64| -> Result<f64> {
1693
+ let mut dados = vec![0.0f32; n * d];
1694
+ for i in 0..n {
1695
+ let sinal = if i < n / 2 { 1.0 } else { -1.0 };
1696
+ for j in 0..d {
1697
+ dados[i * d + j] = (t * sinal) as f32;
1698
+ }
1699
+ }
1700
+ let z = Tensor::from_vec(dados, (n, d), &dev)?;
1701
+ Ok(nucleo.perda_vc(&z)?.to_scalar::<f32>()? as f64)
1702
+ };
1703
+ let mut anterior = v(0.0)?;
1704
+ for t in [0.05f64, 0.1, 0.2, 0.4, 0.8] {
1705
+ let atual = v(t)?;
1706
+ assert!(atual < anterior, "V não decresceu em t={t}: {atual} >= {anterior}");
1707
+ anterior = atual;
1708
+ }
1709
+ Ok(())
1710
+ }
1711
+
1712
+ /// J-1′(b): gap de valor — V(colapso) − V(std=γ) ≥ sp(kγ)² − (ln2)² − δ:
1713
+ /// o colapso NUNCA é minimizador global de L = L_pred + λ·V (λ>0).
1714
+ #[test]
1715
+ fn j1e_gap() -> Result<()> {
1716
+ let dev = Device::Cpu;
1717
+ let (n, d, k) = (8usize, 4usize, 5.0f64);
1718
+ let nucleo = NucleoJepa::novo(4, d, 2, 3, 0.996, 0.1, 1.0, &dev)?.ativar_vc_suave(k, 1e-4);
1719
+ let z_col = Tensor::from_vec(vec![0.37f32; n * d], (n, d), &dev)?;
1720
+ // std_j = γ exato E dimensões ortogonais: colunas de Hadamard-Walsh
1721
+ // h_j(i) = (−1)^{popcount(i & j)}, j = 1..=d (j=0 é constante) —
1722
+ // par duas a duas ⇒ cov amostral EXATAMENTE 0, var_j = 1 = γ².
1723
+ let mut dados = vec![0.0f32; n * d];
1724
+ for i in 0..n {
1725
+ for j in 0..d {
1726
+ let bits = ((i as u32) & ((j + 1) as u32)).count_ones();
1727
+ dados[i * d + j] = if bits % 2 == 0 { 1.0 } else { -1.0 };
1728
+ }
1729
+ }
1730
+ let z_g = Tensor::from_vec(dados, (n, d), &dev)?;
1731
+ let vc = nucleo.perda_vc(&z_col)?.to_scalar::<f32>()? as f64;
1732
+ let vg = nucleo.perda_vc(&z_g)?.to_scalar::<f32>()? as f64;
1733
+ let sp = |x: f64| x.max(0.0) + (1.0 + (-x.abs()).exp()).ln();
1734
+ // gap teórico CONSCIENTE do ε (r-37 limite honesta nº 2: ε enviesa
1735
+ // std para cima em O(ε/2·std) — o gap exato é com std_ε):
1736
+ let (g, eps) = (1.0f64, 1e-4f64);
1737
+ let gap_teorico = sp(k * (g - eps.sqrt())).powi(2)
1738
+ - sp(k * (g - (g * g + eps).sqrt())).powi(2);
1739
+ assert!(vc - vg >= gap_teorico - 1e-3,
1740
+ "gap {vc}-{vg} = {} < teórico {gap_teorico}", vc - vg);
1741
+ assert!(vc > vg, "colapso tem V MAIOR que std=γ (não é minimizador)");
1742
+ Ok(())
1743
+ }
1744
+
1745
+ /// BUG v011-1 (corrigido): o termo de covariância penaliza a
1746
+ /// FORA-diagonal (decorrelação VICReg) — zero para dims independentes,
1747
+ /// positivo para dims correlacionadas, zero no colapso (não opposes hinge).
1748
+ #[test]
1749
+ fn j1f_cov_fora_diagonal() -> Result<()> {
1750
+ let dev = Device::Cpu;
1751
+ let (n, d) = (64usize, 8usize);
1752
+ let nucleo = NucleoJepa::novo(4, d, 2, 3, 0.996, 0.1, 1.0, &dev)?;
1753
+ let mut rng = crate::rng::RngDeterministico::novo(5);
1754
+ // independentes: colunas ruído independente
1755
+ let indep: Vec<f32> = (0..n * d).map(|_| rng.normal(0.0, 1.0) as f32).collect();
1756
+ // correlacionadas: coluna j = coluna 0 (cópia) para j par
1757
+ let mut corr = indep.clone();
1758
+ for i in 0..n {
1759
+ for j in 0..d {
1760
+ if j % 2 == 1 {
1761
+ corr[i * d + j] = indep[i * d];
1762
+ }
1763
+ }
1764
+ }
1765
+ let zi = Tensor::from_vec(indep, (n, d), &dev)?;
1766
+ let zc = Tensor::from_vec(corr, (n, d), &dev)?;
1767
+ let zcol = Tensor::from_vec(vec![0.5f32; n * d], (n, d), &dev)?;
1768
+ let termo = |z: &Tensor| -> Result<f64> {
1769
+ // recalcula APENAS a parte de covariância (mesma fórmula do código)
1770
+ let nn = z.dim(0)? as f64;
1771
+ let centr = z.broadcast_sub(&z.mean_keepdim(0)?)?;
1772
+ let cov = (centr.transpose(0, 1)?.matmul(&centr)? / nn)?;
1773
+ let mut m = vec![0f32; d * d];
1774
+ for i in 0..d {
1775
+ for jj in 0..d {
1776
+ if i != jj {
1777
+ m[i * d + jj] = 1.0;
1778
+ }
1779
+ }
1780
+ }
1781
+ let mask = Tensor::from_vec(m, (d, d), &dev)?;
1782
+ Ok((&cov * &mask)?.sqr()?.sum_all()?.to_scalar::<f32>()? as f64 / (2.0 * d as f64))
1783
+ };
1784
+ let ti = termo(&zi)?;
1785
+ let tc = termo(&zc)?;
1786
+ let tcol = termo(&zcol)?;
1787
+ assert!(ti < 0.05, "independente ⇒ termo ≈ 0 (é {ti})");
1788
+ assert!(tc > 0.3, "correlacionado ⇒ termo grande (é {tc})");
1789
+ assert!(tc > 10.0 * ti, "decorrelação detecta: {tc} vs {ti}");
1790
+ assert!(tcol.abs() < 1e-12, "colapso ⇒ termo 0 (era o comportamento da diagonal errada)");
1791
+ Ok(())
1792
+ }
1793
+
1794
+ /// J-3′: decomposição de informação EXATA em L² —
1795
+ /// E‖P−z_t‖² = E‖P−m*‖² + E‖m*−z_t‖² (torre; m* projeção de L²(σ(ctx))).
1796
+ /// Verificação Monte-Carlo com m*(ctx)=ctx, z_t=ctx+ε, P=2·ctx.
1797
+ #[test]
1798
+ fn j3_decomposicao_exata_l2() {
1799
+ let mut rng = crate::rng::RngDeterministico::novo(31);
1800
+ let (sig, tau) = (1.3f64, 0.7f64);
1801
+ let n = 200_000usize;
1802
+ let (mut lhs, mut t1, mut t2) = (0.0f64, 0.0f64, 0.0f64);
1803
+ for _ in 0..n {
1804
+ let c = rng.normal(0.0, sig);
1805
+ let e = rng.normal(0.0, tau);
1806
+ let p = 2.0 * c;
1807
+ let z = c + e;
1808
+ lhs += (p - z).powi(2);
1809
+ t1 += (p - c).powi(2);
1810
+ t2 += (c - z).powi(2);
1811
+ }
1812
+ let (lhs, t1, t2) = (lhs / n as f64, t1 / n as f64, t2 / n as f64);
1813
+ assert!((lhs - (t1 + t2)).abs() < 2e-2, "LHS {lhs:.4} != {t1:.4}+{t2:.4}");
1814
+ assert!((t1 - sig * sig).abs() < 2e-2, "gap aproximação = σ² ({t1:.4} vs {})", sig * sig);
1815
+ assert!((t2 - tau * tau).abs() < 2e-2, "variância irredutível = τ² ({t2:.4} vs {})", tau * tau);
1816
+ }
1817
+
1818
  fn tensor_2d(dados: &[Vec<f64>], dev: &Device) -> Tensor {
1819
  let flat: Vec<f32> = dados.iter().flat_map(|v| v.iter().map(|&x| x as f32)).collect();
1820
  Tensor::from_vec(flat, (dados.len(), dados[0].len()), dev).unwrap()
 
1937
  assert!(v > 0.9, "perda VC no colapso = {v} (deveria ser ~1)");
1938
  }
1939
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1940
  #[test]
1941
  fn teste_j2_ema_ponto_fixo() {
1942
  // encoder congelado ⇒ após muitas passadas EMA, alvo = encoder
 
2019
  assert_eq!(gr.dims().to_vec(), vec![6, 12]);
2020
  }
2021
 
2022
+
2023
+ /// v0.11 (r-34 §12 quitado): SonicMoE/ReplaySSM SEMEADOS — mesma
2024
+ /// semente ⇒ mesma rede bit-a-bit (sem RNG global do candle).
2025
+ #[test]
2026
+ fn sonic_replay_semeados_deterministicos() -> Result<()> {
2027
+ let dev = Device::Cpu;
2028
+ // SonicMoE: mesmos pesos e mesma saída para a MESMA entrada
2029
+ let extrai = |m: &SonicMoe| -> Vec<Vec<f32>> {
2030
+ m.roteador
2031
+ .vars()
2032
+ .iter()
2033
+ .map(|v| v.as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap())
2034
+ .collect()
2035
+ };
2036
+ let m1 = SonicMoe::novo_com_semente(8, 4, 2, 6, 123, &dev)?;
2037
+ let m2 = SonicMoe::novo_com_semente(8, 4, 2, 6, 123, &dev)?;
2038
+ assert_eq!(extrai(&m1), extrai(&m2), "roteador semeado bit-a-bit");
2039
+ let x = Tensor::randn(0f32, 1.0, (16, 8), &dev)?;
2040
+ let y1 = m1.fwd(&x)?.saida.flatten_all()?.to_vec1::<f32>()?;
2041
+ let y2 = m2.fwd(&x)?.saida.flatten_all()?.to_vec1::<f32>()?;
2042
+ assert_eq!(y1, y2, "saída SonicMoE bit-a-bit com mesma semente");
2043
+ // ReplaySSM: mesmas portas/projeção e mesmo scan
2044
+ let s1 = ReplaySsm::novo_com_semente(4, 6, 0.5, 8, 321, &dev)?;
2045
+ let s2 = ReplaySsm::novo_com_semente(4, 6, 0.5, 8, 321, &dev)?;
2046
+ let av1 = s1.a.as_tensor().flatten_all()?.to_vec1::<f32>()?;
2047
+ let av2 = s2.a.as_tensor().flatten_all()?.to_vec1::<f32>()?;
2048
+ assert_eq!(av1, av2, "porta a bit-a-bit");
2049
+ let xs = Tensor::randn(0f32, 1.0, (12, 4), &dev)?;
2050
+ let h1 = s1.scan(&xs)?.flatten_all()?.to_vec1::<f32>()?;
2051
+ let h2 = s2.scan(&xs)?.flatten_all()?.to_vec1::<f32>()?;
2052
+ assert_eq!(h1, h2, "scan ReplaySSM bit-a-bit com mesma semente");
2053
+ Ok(())
2054
+ }
2055
+
2056
  #[test]
2057
  fn teste_sonic_moe_capacidade_e_balanceamento() {
2058
  // SM-1: carga por especialista ≤ capacidade; SM-2: aux ≥ ~1 quando
src/lib.rs CHANGED
@@ -9,11 +9,10 @@ use pyo3::prelude::*;
9
 
10
  pub mod amostrador;
11
  pub mod arvore_pesos;
12
- pub mod asm;
13
  pub mod atencao;
14
  pub mod acoplador;
15
  pub mod camadas;
16
- pub mod checkpoint;
17
  pub mod config;
18
  pub mod controlador;
19
  pub mod diagnostico;
@@ -31,13 +30,11 @@ pub mod nlp;
31
  pub mod pensamento;
32
  pub mod quantizacao;
33
  pub mod quantizador;
34
- pub mod raciocinio_elastico;
35
  pub mod som4d;
36
  pub mod simd;
37
  pub mod ssd;
38
  pub mod stiefel;
39
  pub mod telemetria;
40
- pub mod tipos;
41
  pub mod tokens;
42
  pub mod tokenizador;
43
  pub mod treino;
@@ -50,42 +47,7 @@ pub mod build_info {
50
 
51
  #[pyfunction]
52
  fn versao() -> &'static str {
53
- concat!("khtst-rust-", env!("CARGO_PKG_VERSION"))
54
- }
55
-
56
- /// **v0.11.0 (tratamento.txt):** relatório do módulo de Assembly (kernels
57
- /// por flags CF/PF/ZF com códigos de erro em registrador → `Result`).
58
- #[pyfunction]
59
- fn asm_relatorio() -> String {
60
- crate::asm::relatorio()
61
- }
62
-
63
- /// **v0.11.0 (r-40 V-2′):** relatório de soundness CONDICIONAL ao aceite —
64
- /// `ece_aceito` (faixas restritas a conf ≥ τ_c), `p_aceite`, cotas limpa e
65
- /// corrigida, e o erro empírico medido — tudo auditável do Python.
66
- #[pyfunction]
67
- fn v2_relatorio_soundness(
68
- confs: Vec<f64>,
69
- corretos: Vec<bool>,
70
- n_faixas: usize,
71
- tau_c: f64,
72
- ) -> PyResult<PyObject> {
73
- Python::with_gil(|py| {
74
- let r = crate::verificador::relatorio_soundness(&confs, &corretos, n_faixas, tau_c)
75
- .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("{e}")))?;
76
- let d_ = serde_json::json!({
77
- "tau_c": r.tau_c,
78
- "p_aceite": r.p_aceite,
79
- "n_aceito": r.n_aceito,
80
- "ece_aceito": r.ece_aceito,
81
- "l1_global": r.l1_global,
82
- "cota_limpa": r.cota_limpa,
83
- "cota_corrigida": r.cota_corrigida,
84
- "p_erro_aceito": r.p_erro_aceito,
85
- "cota_limpa_respeitada": r.cota_limpa_respeitada,
86
- });
87
- Ok(pythonize::pythonize(py, &d_)?.into())
88
- })
89
  }
90
 
91
  #[pyfunction]
@@ -131,22 +93,8 @@ impl BpePy {
131
 
132
  #[staticmethod]
133
  fn carregar(caminho: &str) -> PyResult<Self> {
134
- // v0.11.0 (restaurado da v0.10.0): carrega com VERIFICAÇÃO de
135
- // integridade quando há manifesto (retrocompatível: sem manifesto,
136
- // leitura simples — checkpoints antigos continuam válidos)
137
- let txt = match crate::checkpoint::carregar_verificado(caminho) {
138
- Ok(t) => t,
139
- Err(e) => {
140
- // sem manifesto ou corrompido: se o arquivo existe, é
141
- // legado — ler direto; senão, propagar o erro de I/O
142
- if !std::path::Path::new(caminho).exists() {
143
- return Err(pyo3::exceptions::PyIOError::new_err(format!("{e}")));
144
- }
145
- log::warn!("carregar: sem manifesto válido ({e}) — lendo legado {caminho}");
146
- std::fs::read_to_string(caminho)
147
- .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?
148
- }
149
- };
150
  let v: serde_json::Value = serde_json::from_str(&txt)
151
  .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("JSON inválido: {e}")))?;
152
  let bpe = tokens::Bpe::de_json(&v)
@@ -163,11 +111,12 @@ impl BpePy {
163
  }
164
 
165
  fn salvar(&self, caminho: &str) -> PyResult<()> {
166
- // v0.11.0 (restaurado da v0.10.0): checkpoint ATÔMICO com manifesto
167
- // SHA-256 (Teo CP-1/CP-2 — tmp→fsync→rename→fsync(dir))
168
- let txt = serde_json::to_string(&self.bpe.para_json())
169
- .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?;
170
- crate::checkpoint::salvar_atomico(caminho, &txt)
 
171
  .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?;
172
  Ok(())
173
  }
@@ -254,14 +203,20 @@ impl PonteDuplaPy {
254
  })
255
  .map_err(pyo3::exceptions::PyRuntimeError::new_err)?;
256
  Python::with_gil(|py| {
257
- Ok(pythonize::pythonize(py, &serde_json::to_value(&stats).unwrap())?.into())
 
 
 
258
  })
259
  }
260
 
261
  fn estatisticas(&self) -> PyResult<PyObject> {
262
  let s = self.ponte.estatisticas();
263
  Python::with_gil(|py| {
264
- Ok(pythonize::pythonize(py, &serde_json::to_value(&s).unwrap())?.into())
 
 
 
265
  })
266
  }
267
  }
@@ -319,9 +274,6 @@ fn treinar_fase_a(
319
  "perplexidade_codebook": resumo.perplexidade_codebook,
320
  "monotonia_prefixo": resumo.monotonia_prefixo,
321
  "escore_aprendizado": resumo.escore_aprendizado,
322
- "coerencia_welch_max": resumo.coerencia_max,
323
- "tc_intra_nivel_medio": resumo.tc_intra_nivel_medio,
324
- "tc_resolucao_nats": resumo.tc_resolucao_nats,
325
  },
326
  "telemetria": hub.dump(),
327
  });
@@ -377,8 +329,6 @@ fn treinar_fase_a_np(
377
  "perplexidade_codebook": resumo.perplexidade_codebook,
378
  "monotonia_prefixo": resumo.monotonia_prefixo,
379
  "escore_aprendizado": resumo.escore_aprendizado,
380
- "coerencia_welch_max": resumo.coerencia_max,
381
- "tc_intra_nivel_medio": resumo.tc_intra_nivel_medio,
382
  },
383
  "telemetria": hub.dump(),
384
  "entrada": "numpy",
@@ -415,8 +365,6 @@ fn treinar_fase_b_np(
415
  "passos": resumo.passos, "perda_inicial": resumo.perda_inicial,
416
  "perda_final": resumo.perda_final, "acc_conceitos": resumo.acc_recon,
417
  "escore_aprendizado": resumo.escore_aprendizado,
418
- "coerencia_welch_max": resumo.coerencia_max,
419
- "tc_intra_nivel_medio": resumo.tc_intra_nivel_medio,
420
  },
421
  "telemetria": hub.dump(),
422
  "entrada": "numpy",
@@ -580,18 +528,6 @@ fn treinar_jepa_adaptativa(
580
  frac_mascara: if j.frac_mascara > 0.0 { j.frac_mascara } else { 0.35 },
581
  semente: if j.semente > 0 { j.semente } else { 42 },
582
  tam_bloco: 2,
583
- modo_variancia: match j.modo_variancia.as_deref() {
584
- None | Some("dobradica") => jepa::ModoVariancia::Dobradica,
585
- Some("raiz_suavizada") => jepa::ModoVariancia::RaizSuavizada,
586
- Some("softplus") => jepa::ModoVariancia::Softplus,
587
- Some(outro) => {
588
- return Err(pyo3::exceptions::PyValueError::new_err(format!(
589
- "modo_variancia inválido: {outro} — use \"dobradica\", \"raiz_suavizada\" ou \"softplus\""
590
- )))
591
- }
592
- },
593
- eps_raiz: if j.eps_raiz > 0.0 { j.eps_raiz } else { 1e-12 },
594
- k_softplus: if j.k_softplus > 0.0 { j.k_softplus } else { 5.0 },
595
  };
596
  let var = match variante.as_str() {
597
  "image" => jepa::VarianteJepa::ImageJepa,
@@ -626,6 +562,11 @@ fn treinar_jepa_adaptativa(
626
  }
627
 
628
  /// Relatório do despacho SIMD (kernels AVX-512 usados até agora).
 
 
 
 
 
629
  #[pyfunction]
630
  fn simd_relatorio(py: Python) -> PyResult<PyObject> {
631
  Ok(pythonize::pythonize(py, &simd::relatorio())?.into())
@@ -660,8 +601,6 @@ fn treinar_fase_b(
660
  "passos": resumo.passos, "perda_inicial": resumo.perda_inicial,
661
  "perda_final": resumo.perda_final, "acc_conceitos": resumo.acc_recon,
662
  "escore_aprendizado": resumo.escore_aprendizado,
663
- "coerencia_welch_max": resumo.coerencia_max,
664
- "tc_intra_nivel_medio": resumo.tc_intra_nivel_medio,
665
  },
666
  "telemetria": hub.dump(),
667
  });
@@ -777,7 +716,8 @@ fn verificar_stiefel(k: usize, d: usize) -> PyResult<f64> {
777
  let dev = candle_core::Device::Cpu;
778
  let c = stiefel::init_stiefel(k, d, &dev)
779
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
780
- stiefel::erro_ortogonalidade(&c.transpose(0, 1).unwrap()).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))
 
781
  }
782
 
783
  // ===========================================================================
@@ -810,11 +750,10 @@ struct CfgSom4DJ {
810
  eta0: f64, eta1: f64,
811
  semente: u64,
812
  espalhada: bool,
813
- /// v0.10.0 (S4-′1): "media" (padrão) | "mediana_geometrica"
814
- criterio_lote: Option<String>,
815
- /// v0.10.0 (S4-′1): "distancia" (padrão) | "quadratico"
816
- criterio_qe: Option<String>,
817
- /// v0.10.0: iterações Weiszfeld (modo mediana)
818
  weiszfeld_iters: usize,
819
  }
820
 
@@ -843,10 +782,6 @@ struct CfgJepaJ {
843
  gamma_vc: f64,
844
  frac_mascara: f64,
845
  semente: u64,
846
- /// v0.10.0 (J-1′): "dobradica" (padrão) | "raiz_suavizada" | "softplus"
847
- modo_variancia: Option<String>,
848
- eps_raiz: f64,
849
- k_softplus: f64,
850
  }
851
 
852
  /// Faz o parse tipado; JSON inválido/erro de tipo vira PyValueError (antes:
@@ -882,47 +817,33 @@ fn treinar_som4d(py: Python, dados: Vec<Vec<f64>>, cfg: Option<String>) -> PyRes
882
  } else {
883
  som4d::Inicializacao4D::Dados
884
  },
885
- criterio_lote: match j.criterio_lote.as_deref() {
886
- None | Some("media") => som4d::CriterioLote::Media,
887
- Some("mediana_geometrica") | Some("mediana") => {
888
- som4d::CriterioLote::MedianaGeometrica
889
- }
890
- Some(outro) => {
891
- return Err(pyo3::exceptions::PyValueError::new_err(format!(
892
- "criterio_lote inválido: {outro} — use \"media\" ou \"mediana_geometrica\""
893
- )))
894
- }
895
- },
896
- criterio_qe: match j.criterio_qe.as_deref() {
897
- None | Some("distancia") => som4d::CriterioQe::Distancia,
898
- Some("quadratico") => som4d::CriterioQe::Quadratico,
899
- Some(outro) => {
900
- return Err(pyo3::exceptions::PyValueError::new_err(format!(
901
- "criterio_qe inválido: {outro} — use \"distancia\" ou \"quadratico\""
902
- )))
903
- }
904
  },
905
- weiszfeld_iters: if j.weiszfeld_iters > 0 { j.weiszfeld_iters } else { 8 },
906
  ..Default::default()
907
  };
908
  let som = som4d::treinar_som4d(&t, &c, &dev)
909
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
910
- // S4-1′-a: Φ do kernel não-crescente em TODAS as épocas (gate booleano)
911
- let phi_monotono = som
912
- .historia_phi
913
- .iter()
914
- .all(|(a, d)| *d <= *a + 1e-9);
915
  let d = serde_json::json!({
916
  "versao": som4d::versao(),
917
  "celulas": som.n_celulas(),
918
  "grade": [som.nx, som.ny, som.nz, som.nt],
919
  "eq_inicial": som.eq_inicial,
920
  "eq_final": som.eq_final,
921
- "eqm_final": som.eqm_final,
922
  "te_final": som.te_final,
923
  "historico_eq_te": som.historia,
924
- "phi_monotono": phi_monotono,
925
- "historico_phi": som.historia_phi,
 
 
 
 
 
 
 
926
  "massa_soma": som.massa.iter().sum::<f64>(),
927
  });
928
  Ok(pythonize::pythonize(py, &d)?.into())
@@ -1004,16 +925,18 @@ fn treinar_hsom(py: Python, dados: Vec<Vec<f64>>, cfg: Option<String>) -> PyResu
1004
  if let Some(x) = o.get("epocas_finas") {
1005
  c.epocas_finas = x.as_u64().unwrap_or(20) as usize;
1006
  }
1007
- // v0.10.0 (H-1′-c): slot fino 0 = cópia permanente de q_c
1008
- if let Some(x) = o.get("reservar_grosso") {
1009
- c.reservar_grosso = x.as_bool().unwrap_or(false);
1010
  }
1011
  }
1012
  }
1013
  }
1014
  let h = som4d::treinar_hsom(&t, &c, &dev)
1015
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1016
- let cota = h.eq_grosso + 2.0 * h.r_fino + 2.0 * (h.eq_grosso * h.r_fino).sqrt();
 
 
1017
  let d = serde_json::json!({
1018
  "versao": som4d::versao(),
1019
  "eq_hierarquico": h.eq_hierarquico,
@@ -1021,6 +944,9 @@ fn treinar_hsom(py: Python, dados: Vec<Vec<f64>>, cfg: Option<String>) -> PyResu
1021
  "r_fino": h.r_fino,
1022
  "cota_teo_h1": cota,
1023
  "cota_respeitada": h.eq_hierarquico <= cota + 1e-9,
 
 
 
1024
  });
1025
  Ok(pythonize::pythonize(py, &d)?.into())
1026
  }
@@ -1034,7 +960,6 @@ fn demo_tsom(py: Python, dados_iniciais: Vec<Vec<f64>>, janela: Vec<Vec<f64>>, p
1034
  cfg_grade: som4d::CfgSom4D { nx: 3, ny: 3, nz: 2, nt: 2, epocas: 15, ..Default::default() },
1035
  gamma,
1036
  janela: janela.len(),
1037
- eta_rastreio: 0.1, // T-1′: default = comportamento v0.9.0
1038
  };
1039
  let mut ts = som4d::TSom4D::novo(&t0, &cfg, &dev)
1040
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
@@ -1060,16 +985,6 @@ fn treinar_jepa(py: Python, dados: Vec<Vec<f64>>, grid: Vec<usize>, variante: St
1060
  let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1061
  // v0.9.0: parse tipado — defaults idênticos aos da v0.8.0
1062
  let j: CfgJepaJ = parse_cfg_tipado(&cfg)?;
1063
- let modo_v = match j.modo_variancia.as_deref() {
1064
- None | Some("dobradica") => jepa::ModoVariancia::Dobradica,
1065
- Some("raiz_suavizada") => jepa::ModoVariancia::RaizSuavizada,
1066
- Some("softplus") => jepa::ModoVariancia::Softplus,
1067
- Some(outro) => {
1068
- return Err(pyo3::exceptions::PyValueError::new_err(format!(
1069
- "modo_variancia inválido: {outro}"
1070
- )))
1071
- }
1072
- };
1073
  let c = jepa::CfgJepa {
1074
  d_emb: if j.d_emb > 0 { j.d_emb } else { 32 },
1075
  epocas: if j.epocas > 0 { j.epocas } else { 60 },
@@ -1080,9 +995,6 @@ fn treinar_jepa(py: Python, dados: Vec<Vec<f64>>, grid: Vec<usize>, variante: St
1080
  frac_mascara: if j.frac_mascara > 0.0 { j.frac_mascara } else { 0.35 },
1081
  semente: if j.semente > 0 { j.semente } else { 42 },
1082
  tam_bloco: 2,
1083
- modo_variancia: modo_v,
1084
- eps_raiz: if j.eps_raiz > 0.0 { j.eps_raiz } else { 1e-12 },
1085
- k_softplus: if j.k_softplus > 0.0 { j.k_softplus } else { 5.0 },
1086
  };
1087
  let var = match variante.as_str() {
1088
  "image" => jepa::VarianteJepa::ImageJepa,
@@ -1206,7 +1118,8 @@ fn treinar_bjepa(py: Python, serie: Vec<Vec<f64>>, cfg: Option<String>) -> PyRes
1206
  #[pyfunction]
1207
  fn demo_sonic_moe(py: Python, n: usize, d: usize, n_expertos: usize, top_k: usize, capacidade: usize) -> PyResult<PyObject> {
1208
  let dev = candle_core::Device::Cpu;
1209
- let moe = jepa::SonicMoe::novo(d, n_expertos, top_k, capacidade, &dev)
 
1210
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1211
  let x = candle_core::Tensor::randn(0f32, 1.0, (n, d), &dev)
1212
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
@@ -1227,7 +1140,8 @@ fn demo_sonic_moe(py: Python, n: usize, d: usize, n_expertos: usize, top_k: usiz
1227
  #[pyfunction]
1228
  fn demo_replay_ssm(py: Python, passos: usize, alpha: f64) -> PyResult<PyObject> {
1229
  let dev = candle_core::Device::Cpu;
1230
- let mut ssm = jepa::ReplaySsm::novo(4, 6, alpha, 8, &dev)
 
1231
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1232
  let mut otim = crate::treino::AdamWManual::novo(ssm.vars(), 1e-2, 0.0);
1233
  let x_antigo = candle_core::Tensor::from_vec(vec![1.0f32; 16 * 4], (16, 4), &dev)
@@ -1363,8 +1277,22 @@ fn demo_pensamento(
1363
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1364
  let verifica = |resp: &Tensor| -> f64 {
1365
  // confiança = 1/(1+10·MSE) — medível e causaL (só da resposta)
1366
- let dif = (resp.broadcast_as((1, d_saida)).unwrap() - &alvo_verd.broadcast_as((1, d_saida)).unwrap()).unwrap();
1367
- let mse = dif.sqr().unwrap().mean_all().unwrap().to_scalar::<f32>().unwrap() as f64;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1368
  1.0 / (1.0 + 10.0 * mse)
1369
  };
1370
  let mut rng2 = crate::rng::RngDeterministico::novo(semente + 1);
@@ -1372,7 +1300,7 @@ fn demo_pensamento(
1372
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1373
 
1374
  // linha de base SEM pensamento: uma tentativa isolada, sem agregação
1375
- let base = motor.tentativas[0].fwd(&consulta_t.broadcast_as((1, d_cond)).unwrap())
1376
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1377
  let conf_base = verifica(&base);
1378
  let conf_pensamento = res.confianca;
@@ -1506,7 +1434,10 @@ fn demo_verificador_ncm(n: usize, k: usize, semente: u64) -> PyResult<PyObject>
1506
  l.push((base + rng.normal(0.0, 1.2) as f32 + desloc as f32) as f32);
1507
  }
1508
  }
1509
- let lt = candle_core::Tensor::from_vec(l, (m, k), &dev).unwrap();
 
 
 
1510
  (lt, a)
1511
  };
1512
  let (lt_tre, alvos_tre) = gerar(&mut rng, n, 0.0);
@@ -1521,13 +1452,13 @@ fn demo_verificador_ncm(n: usize, k: usize, semente: u64) -> PyResult<PyObject>
1521
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1522
  let mut otim = treino::AdamWManual::novo(vec![w_var.clone()], 0.05, 0.0);
1523
  for _ in 0..120 {
1524
- let logits = lt_tre.matmul(&w_var.as_tensor().transpose(0, 1).unwrap()).unwrap();
1525
- let ce = candle_nn::loss::cross_entropy(&logits, &at_t).unwrap();
1526
- let g = treino::grads_achatados(&ce, &[w_var.clone()]).unwrap();
1527
  otim.passo(g);
1528
  }
1529
  // logits de validação com o modelo treinado
1530
- let logits_val = lt_val.matmul(&w_var.as_tensor().transpose(0, 1).unwrap()).unwrap();
1531
  let at_v = candle_core::Tensor::from_vec(
1532
  alvos_val.iter().map(|&a| a as u32).collect::<Vec<u32>>(), (n / 2,), &dev)
1533
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
@@ -1535,11 +1466,11 @@ fn demo_verificador_ncm(n: usize, k: usize, semente: u64) -> PyResult<PyObject>
1535
  let mut v = verificador::VerificadorNcm::novo();
1536
  let (ece_antes, ece_depois) = v.ajustar(&logits_val, &at_v)
1537
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1538
- let confs: Vec<f64> = v.confianca(&logits_val).unwrap()
1539
- .flatten_all().unwrap().to_vec1::<f32>().unwrap().iter().map(|x| *x as f64).collect();
1540
- let corretos: Vec<bool> = logits_val.argmax(candle_core::D::Minus1).unwrap()
1541
- .eq(&at_v).unwrap().to_dtype(candle_core::DType::U32).unwrap()
1542
- .flatten_all().unwrap().to_vec1::<u32>().unwrap()
1543
  .iter().map(|x| *x == 1).collect();
1544
  let tau_c = verificador::limiar_por_erro(&confs, 0.25);
1545
  let (mut erro_aceito, mut n_aceito) = (0usize, 0usize);
@@ -1623,7 +1554,6 @@ fn treinar_fase_c(
1623
  "maior_sobreposicao_us": resumo.maior_sobreposicao_us,
1624
  },
1625
  "painel_v060": hub.painel_v060(),
1626
- "painel_v100": hub.painel_v100(),
1627
  "telemetria": hub.dump(),
1628
  });
1629
  Ok(pythonize::pythonize(py, &dados)?.into())
@@ -1646,23 +1576,23 @@ fn demo_moe_redirecionavel(d: usize, n: usize, semente: u64) -> PyResult<PyObjec
1646
  let mut moe = moe_redirecionavel::MoeRedirecionavel::novo(d, 8, 2, n, &dev)
1647
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1648
  // M-R2: neutralidade no nascimento
1649
- let g0 = moe.atencao.gate.as_tensor().to_scalar::<f32>().unwrap();
1650
- let y0 = moe.atencao.fwd(&x).unwrap();
1651
- let dif0 = (&y0 - &x).unwrap().sqr().unwrap().sum_all().unwrap()
1652
- .to_scalar::<f32>().unwrap() as f64;
1653
  // abre o gate (mecanismo ativo)
1654
- moe.atencao.gate.set(&candle_core::Tensor::new(1.0f32, &dev).unwrap()).unwrap();
1655
  // M-R1: invariância sob redirecionamento
1656
- let s_enc = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap();
1657
  let carga_antes: usize = s_enc.carga.iter().sum();
1658
- let perda_antes = s_enc.perda_aux.to_scalar::<f32>().unwrap() as f64;
1659
  let permuta: Vec<usize> = (0..8).map(|i| (i + 1) % 8).collect();
1660
  moe.redirecionar(&permuta);
1661
- let s_enc2 = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap();
1662
  let carga_depois: usize = s_enc2.carga.iter().sum();
1663
- let perda_depois = s_enc2.perda_aux.to_scalar::<f32>().unwrap() as f64;
1664
  // M-R3: paralelismo medido (enc ∥ dec em 2 threads)
1665
- let (_e, _dc, t_par, t_seq, speedup) = moe.fwd_ambos_par(&x).unwrap();
1666
  // M-R5: water-filling vs uniforme (cota analítica)
1667
  let qes: Vec<f64> = vec![0.15, 0.4, 1.0, 0.25, 0.6, 0.1, 0.35, 0.5];
1668
  let c_wf = moe_redirecionavel::alocar_por_qe(&qes, 16);
@@ -1921,8 +1851,8 @@ fn demo_pensamento_ncm(
1921
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1922
  // base: 1 tentativa isolada, mesma verificação NCM
1923
  let base = motor.tentativas[0]
1924
- .fwd(&consulta_t.broadcast_as((1, d_cond)).unwrap()).unwrap();
1925
- let conf_base = verif.confianca_1d(&logits_fn(&base).unwrap()).unwrap();
1926
  confs_base.push(conf_base);
1927
  confs_pens.push(res.confianca);
1928
  iteracoes.push(res.iteracoes);
@@ -1938,8 +1868,8 @@ fn demo_pensamento_ncm(
1938
  let res_ood = motor.raciocinar_ncm(&consulta_ood_t, &verif, &logits_fn, &mut rng3)
1939
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1940
  let base_ood = motor.tentativas[0]
1941
- .fwd(&consulta_ood_t.broadcast_as((1, d_cond)).unwrap()).unwrap();
1942
- let conf_base_ood = verif.confianca_1d(&logits_fn(&base_ood).unwrap()).unwrap();
1943
  let _ = mk;
1944
  let d_ = serde_json::json!({
1945
  "versao": "pensamento-0.6.0-ncm",
@@ -1968,201 +1898,6 @@ fn demo_pensamento_ncm(
1968
  })
1969
  }
1970
 
1971
- /// **Raciocínio elástico (r-42, RE-1..RE-8) — demo:** treina motor +
1972
- /// cabeça verificadora, roda o ciclo elástico com ênfase Hedge e compressão
1973
- /// certificada RE-2, e devolve o certificado completo para auditoria.
1974
- /// v0.11.0: `conds_reais`/`alvos_reais` opcionais permitem AVALIAÇÃO EM
1975
- /// DADOS REAIS (p.ex. latentes da Wikipédia PT-BR) — sem eles, síntese.
1976
- #[pyfunction]
1977
- fn demo_raciocinio_elastico(
1978
- d_cond: usize,
1979
- d_saida: usize,
1980
- n_tentativas: usize,
1981
- passos_treino: usize,
1982
- tau_c: f64,
1983
- b_max: usize,
1984
- semente: u64,
1985
- conds_reais: Option<Vec<Vec<f32>>>,
1986
- alvos_reais: Option<Vec<Vec<f32>>>,
1987
- ) -> PyResult<PyObject> {
1988
- Python::with_gil(|py| {
1989
- use candle_core::Tensor;
1990
- let dev = candle_core::Device::Cpu;
1991
- crate::rng::definir_semente(semente);
1992
- // dados: REAIS quando fornecidos (avaliação qualificada — p.ex.
1993
- // latentes da Wikipédia PT-BR), senão sintéticos (família do
1994
- // demo_pensamento_ncm). Origem reportada na saída (honestidade).
1995
- let (conds, alvos, d_cond, d_saida, origem) = match (conds_reais, alvos_reais) {
1996
- (Some(cs), Some(as_)) if !cs.is_empty() && cs.len() == as_.len() => {
1997
- let dc = cs.first().map(|c| c.len()).unwrap_or(d_cond);
1998
- let ds = as_.first().map(|a| a.len()).unwrap_or(d_saida);
1999
- if cs.iter().any(|c| c.len() != dc) || as_.iter().any(|a| a.len() != ds) {
2000
- return Err(pyo3::exceptions::PyValueError::new_err(
2001
- "conds_reais/alvos_reais: larguras heterogêneas"));
2002
- }
2003
- (cs, as_, dc, ds, "reais")
2004
- }
2005
- (None, None) => {
2006
- let mut rng = crate::rng::RngDeterministico::novo(semente);
2007
- let n_dados = 320usize;
2008
- let conds: Vec<Vec<f32>> = (0..n_dados)
2009
- .map(|_| (0..d_cond).map(|_| rng.normal(0.0, 1.0) as f32).collect())
2010
- .collect();
2011
- let alvos: Vec<Vec<f32>> = conds.iter().map(|c| {
2012
- (0..d_saida).map(|j| {
2013
- let cj = c[j % d_cond];
2014
- let ck = c[(j + 1) % d_cond];
2015
- 0.5 * cj + 0.3 * cj * ck + 0.1
2016
- }).collect()
2017
- }).collect();
2018
- (conds, alvos, d_cond, d_saida, "sinteticos")
2019
- }
2020
- _ => {
2021
- return Err(pyo3::exceptions::PyValueError::new_err(
2022
- "forneça AMBOS conds_reais e alvos_reais (ou nenhum)"))
2023
- }
2024
- };
2025
- let n_dados = conds.len();
2026
- let motor = pensamento::MotorPensamento::novo(
2027
- d_cond, d_saida, n_tentativas, tau_c, b_max, &dev)
2028
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2029
- let cfg = raciocinio_elastico::ConfigElastica {
2030
- tau_c, b_max, semente, ..Default::default()
2031
- };
2032
- let mut re = raciocinio_elastico::RaciocinioElastico::novo(motor, cfg)
2033
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2034
- let mut otim = treino::AdamWManual::novo(re.motor.vars(), 5e-3, 0.0);
2035
- let cond_t = Tensor::from_vec(conds.iter().flatten().cloned().collect(), (n_dados, d_cond), &dev)
2036
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2037
- let alvo_t = Tensor::from_vec(alvos.iter().flatten().cloned().collect(), (n_dados, d_saida), &dev)
2038
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2039
- // cabeça verificadora (backbone treinado) — K classes por faixa do alvo
2040
- let k_classes = 12usize;
2041
- let classes: Vec<u32> = alvos.iter().map(|a| {
2042
- let f = (((a[0] + 2.0) / 4.0) * (k_classes as f32)).floor();
2043
- (f.clamp(0.0, (k_classes - 1) as f32)) as u32
2044
- }).collect();
2045
- let cabeca = crate::jepa::MlpJepa::novo(d_saida, 4 * d_saida, k_classes, &dev)
2046
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2047
- let classe_t = Tensor::from_vec(classes, (n_dados,), &dev)
2048
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2049
- let mut otim_cab = treino::AdamWManual::novo(cabeca.vars(), 1e-2, 0.0);
2050
- for _ in 0..200 {
2051
- let logits = cabeca.fwd(&alvo_t)
2052
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2053
- let ce = candle_nn::loss::cross_entropy(&logits, &classe_t)
2054
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2055
- otim_cab.passo(treino::grads_achatados(&ce, &cabeca.vars())
2056
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?);
2057
- }
2058
- // verificador calibrado em retidos
2059
- let n_ret = n_dados / 2;
2060
- let (alvo_ret, clas_ret) = (
2061
- alvo_t.narrow(0, n_ret, n_dados - n_ret)
2062
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?,
2063
- classe_t.narrow(0, n_ret, n_dados - n_ret)
2064
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?,
2065
- );
2066
- let logits_ret = cabeca.fwd(&alvo_ret)
2067
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2068
- let mut verif = verificador::VerificadorNcm::novo();
2069
- let (ece_antes, ece_depois) = verif.ajustar(&logits_ret, &clas_ret)
2070
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2071
- let logits_fn = |resp: &Tensor| -> candle_core::Result<Tensor> { cabeca.fwd(resp) };
2072
- // treino cooperativo do motor
2073
- let (cond_tr, alvo_tr) = (
2074
- cond_t.narrow(0, 0, n_ret)
2075
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?,
2076
- alvo_t.narrow(0, 0, n_ret)
2077
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?,
2078
- );
2079
- let mut hist = Vec::new();
2080
- for _ in 0..passos_treino {
2081
- let perda = re.motor.perda_treino(&cond_tr, &alvo_tr)
2082
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2083
- let pv = perda.to_scalar::<f32>()
2084
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))? as f64;
2085
- hist.push(pv);
2086
- otim.passo(treino::grads_achatados(&perda, &re.motor.vars())
2087
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?);
2088
- }
2089
- // ciclo elástico em consultas retidas
2090
- let n_consultas = 8usize;
2091
- let (mut confs, mut iters, mut certs, mut rolls) = (Vec::new(), Vec::new(), Vec::new(), 0usize);
2092
- let mut hub = telemetria::TelemetryHub::novo(None);
2093
- for qi in 0..n_consultas {
2094
- let consulta_t = Tensor::from_vec(conds[n_ret + qi].clone(), (d_cond,), &dev)
2095
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2096
- let mut rng2 = crate::rng::RngDeterministico::novo(semente + 1 + qi as u64);
2097
- let res = re.raciocinar(&consulta_t, &verif, &logits_fn, None, None, &mut hub, &mut rng2)
2098
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2099
- confs.push(res.base.confianca);
2100
- iters.push(res.base.iteracoes);
2101
- if let Some(c) = res.certificados.last() {
2102
- certs.push(serde_json::json!({
2103
- "epsilon_safe": c.epsilon_safe,
2104
- "massa_removida": c.massa_removida,
2105
- "bound_delta_conf": c.bound_delta_conf,
2106
- "delta_conf_medido": c.delta_conf_medido,
2107
- "violado": c.violado,
2108
- "rollback": c.rollback,
2109
- "valido": c.valido,
2110
- }));
2111
- if c.rollback { rolls += 1; }
2112
- }
2113
- }
2114
- let media = |v: &[f64]| v.iter().sum::<f64>() / v.len().max(1) as f64;
2115
- // pares de calibração retidos (V-2′ em dados reais): confs com T*
2116
- // calibrada + corretos por argmax — auditáveis do Python
2117
- let logits_ret2 = cabeca
2118
- .fwd(&alvo_ret)
2119
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2120
- let escalado2 = logits_ret2
2121
- .affine(1.0 / verif.temperatura.max(1e-9), 0.0)
2122
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2123
- let confs_cal: Vec<f64> = verificador::confianca_por_linha(&escalado2)
2124
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
2125
- .flatten_all().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
2126
- .to_vec1::<f32>().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
2127
- .iter().map(|x| *x as f64).collect();
2128
- let preds2 = escalado2
2129
- .argmax(candle_core::D::Minus1)
2130
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
2131
- let corretos_cal: Vec<bool> = preds2
2132
- .eq(&clas_ret)
2133
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
2134
- .to_dtype(candle_core::DType::U32)
2135
- .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
2136
- .flatten_all().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
2137
- .to_vec1::<u32>().map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?
2138
- .iter().map(|x| *x == 1).collect();
2139
- let d_ = serde_json::json!({
2140
- "versao": raciocinio_elastico::versao(),
2141
- "origem_dados": origem,
2142
- "tau_c": tau_c, "b_max": b_max,
2143
- "perda_treino_inicial": hist.first(), "perda_treino_final": hist.last(),
2144
- "treino_aprendeu": hist.last().copied() < hist.first().map(|p| p * 0.5),
2145
- "ece_verificador_antes": ece_antes, "ece_verificador_depois": ece_depois,
2146
- "temperatura_calibrada": verif.temperatura,
2147
- "confianca_media": media(&confs),
2148
- "iteracoes_media": iters.iter().sum::<usize>() as f64 / iters.len().max(1) as f64,
2149
- "orcamento_esgotado": confs.iter().filter(|c| **c < tau_c).count(),
2150
- "certificados": certs,
2151
- "rollbacks": rolls,
2152
- "confs_calibracao": confs_cal,
2153
- "corretos_calibracao": corretos_cal,
2154
- "teoremas": ["RE-1", "RE-2", "RE-3", "RE-4", "RE-5", "RE-6", "RE-7", "RE-8"],
2155
- "gates": {
2156
- "gate_calibrado": ece_depois <= ece_antes,
2157
- "gate_terminou_elastico": iters.iter().all(|i| *i <= b_max),
2158
- "gate_sem_violacoes": certs.iter().all(|c| !c["violado"].as_bool().unwrap_or(true)),
2159
- "gate_rollback_so_se_violado": true,
2160
- },
2161
- });
2162
- Ok(pythonize::pythonize(py, &d_)?.into())
2163
- })
2164
- }
2165
-
2166
 
2167
  /// **Autoajuste do Pensamento por telemetria (A-1..A-5) — demo:** alimenta
2168
  /// o controlador com sinais sintéticos medidos e verifica cada regra.
@@ -2203,7 +1938,7 @@ fn demo_autoajuste(semente: u64) -> PyResult<PyObject> {
2203
  u.registrar(braco, r);
2204
  }
2205
  let medias = u.medias();
2206
- let melhor = medias.iter().enumerate().max_by(|a, b| a.1.total_cmp(b.1)).map(|(i, _)| i).unwrap_or(0);
2207
  let d_ = serde_json::json!({
2208
  "versao": "autoajuste-0.6.0",
2209
  "tau_c_final": tau, "n_tentativas_final": n_ajustado,
@@ -2405,6 +2140,22 @@ fn py_err(e: candle_core::Error) -> pyo3::PyErr {
2405
  pyo3::exceptions::PyRuntimeError::new_err(format!("{e}"))
2406
  }
2407
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2408
  /// **Quebra-cabeça sobre o conhecimento TREINADO REAL** (script 63):
2409
  /// carrega o tokenizador (codebook do nível `nivel` — o conhecimento
2410
  /// aprendido dos dados reais) e o gerador (a cabeça real como logits_fn
@@ -2675,36 +2426,36 @@ fn demo_qwen_v080(py: Python) -> PyResult<PyObject> {
2675
  lv.push(base + rng.normal(0.0, 1.0) as f32);
2676
  }
2677
  }
2678
- let lt = Tensor::from_vec(lv, (n, k), &dev).unwrap();
2679
- let at = Tensor::from_vec(av, (n,), &dev).unwrap();
2680
  let t0 = Instant::now();
2681
- let (t_g, _, nll_g) = verificador::calibrar_temperatura(&lt, &at).unwrap();
2682
  let tempo_golden = t0.elapsed().as_secs_f64();
2683
  let t0 = Instant::now();
2684
  let (t_n, _, nll_n, n_aval) =
2685
- verificador::calibrar_temperatura_newton(&lt, &at, 40).unwrap();
2686
  let tempo_newton = t0.elapsed().as_secs_f64();
2687
 
2688
  // ---------- (2) Cayley vs polar (FNH) ----------
2689
  let n_rot = 16usize;
2690
- let r = fnh::RotacaoSkew::nova(n_rot, &dev).unwrap();
2691
  let th: Vec<f32> = (0..n_rot * (n_rot - 1) / 2)
2692
  .map(|i| ((i as f32) * 0.11) % 0.5)
2693
  .collect();
2694
  r.theta
2695
- .set(&Tensor::from_vec(th, (n_rot * (n_rot - 1) / 2,), &dev).unwrap())
2696
- .unwrap();
2697
  let rep = 25usize;
2698
  let t0 = Instant::now();
2699
  let mut delta_polar = 0.0;
2700
  for _ in 0..rep {
2701
- delta_polar = crate::stiefel::erro_ortogonalidade(&r.rotacao_polar().unwrap()).unwrap();
2702
  }
2703
  let tempo_polar = t0.elapsed().as_secs_f64() / rep as f64;
2704
  let t0 = Instant::now();
2705
  let mut delta_cayley = 0.0;
2706
  for _ in 0..rep {
2707
- delta_cayley = crate::stiefel::erro_ortogonalidade(&r.rotacao_cayley().unwrap()).unwrap();
2708
  }
2709
  let tempo_cayley = t0.elapsed().as_secs_f64() / rep as f64;
2710
 
@@ -2732,49 +2483,58 @@ fn demo_qwen_v080(py: Python) -> PyResult<PyObject> {
2732
  // ---------- (4) MoE vetorizada: valores + gradiente + custo ----------
2733
  let (nm, dm, em) = (256usize, 32usize, 8usize);
2734
  let xv: Vec<f32> = (0..nm * dm).map(|_| rng.normal(0.0, 1.0) as f32).collect();
2735
- let x = Tensor::from_vec(xv, (nm, dm), &dev).unwrap();
2736
- let moe = moe_redirecionavel::MoeRedirecionavel::novo(dm, em, 2, nm, &dev).unwrap();
2737
- let s_ref = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap();
2738
- let s_vet = moe.fwd_vetorizado(&x, moe_redirecionavel::Papel::Codificador).unwrap();
2739
  let dif_moe = (&s_ref.saida - &s_vet.saida)
2740
- .unwrap()
2741
  .abs()
2742
- .unwrap()
2743
  .max_all()
2744
- .unwrap()
2745
  .to_scalar::<f32>()
2746
- .unwrap() as f64;
2747
  let rep_moe = 10usize;
2748
  let t0 = Instant::now();
2749
  for _ in 0..rep_moe {
2750
- let _ = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap();
2751
  }
2752
  let tempo_moe_ref = t0.elapsed().as_secs_f64() / rep_moe as f64;
2753
  let t0 = Instant::now();
2754
  for _ in 0..rep_moe {
2755
- let _ = moe.fwd_vetorizado(&x, moe_redirecionavel::Papel::Codificador).unwrap();
2756
  }
2757
  let tempo_moe_vet = t0.elapsed().as_secs_f64() / rep_moe as f64;
2758
  // normas de gradiente (bug v080-1: fwd = 0; vetorizada > 0)
 
 
2759
  let norma = |vet: bool| -> (f64, f64) {
2760
  let s = if vet {
2761
- moe.fwd_vetorizado(&x, moe_redirecionavel::Papel::Codificador).unwrap()
2762
  } else {
2763
- moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap()
2764
  };
2765
- let perda = s.saida.sqr().unwrap().sum_all().unwrap();
2766
- let gs = perda.backward().unwrap();
 
 
 
2767
  let mut nr = 0.0;
2768
  for v in moe.roteador.vars() {
2769
  if let Some(g) = gs.get(&v) {
2770
- nr += g.sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap() as f64;
 
 
2771
  }
2772
  }
2773
  let mut ne = 0.0;
2774
  for e in &moe.especialistas {
2775
  for v in e.vars() {
2776
  if let Some(g) = gs.get(&v) {
2777
- ne += g.sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap() as f64;
 
 
2778
  }
2779
  }
2780
  }
@@ -2785,10 +2545,10 @@ fn demo_qwen_v080(py: Python) -> PyResult<PyObject> {
2785
 
2786
  // ---------- (5) re-ablação JEPA 3 braços (gradiente restaurado) ----------
2787
  let xv: Vec<f32> = (0..64 * 12).map(|_| rng.normal(0.0, 1.0) as f32).collect();
2788
- let xj = Tensor::from_vec(xv, (64, 12), &dev).unwrap();
2789
  let mut ablac = serde_json::Map::new();
2790
  for modo in ["pequena", "densa", "moe"] {
2791
- let rj = moe_redirecionavel::treinar_jepa_com_moe(&xj, modo, 120, 0.5, 42).unwrap();
2792
  ablac.insert(
2793
  modo.into(),
2794
  serde_json::json!({
@@ -2846,23 +2606,318 @@ fn demo_qwen_v080(py: Python) -> PyResult<PyObject> {
2846
  Ok(pythonize::pythonize(py, &d_)?.into())
2847
  }
2848
 
2849
- /// **v0.11.0 (restaurado da v0.10.0 — módulo `checkpoint` portado):**
2850
- /// valida um checkpoint pelo manifesto SHA-256 lado-a-lado (Teo CP-1/CP-2).
 
 
 
 
 
 
 
 
 
 
 
 
2851
  #[pyfunction]
2852
- fn checkpoint_valido(caminho: &str) -> bool {
2853
- crate::checkpoint::validar(caminho)
2854
- }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2855
 
2856
- /// **v0.11.0 (restaurado):** manifesto JSON do checkpoint (hash + tamanho).
2857
- #[pyfunction]
2858
- fn checkpoint_manifesto(caminho: &str) -> Option<String> {
2859
- std::fs::read_to_string(crate::checkpoint::caminho_manifesto(caminho)).ok()
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2860
  }
2861
 
2862
- /// **v0.11.0 (restaurado):** SHA-256 puro Rust (FIPS 180-4) de um arquivo.
2863
- #[pyfunction]
2864
- fn sha256_arquivo(caminho: &str) -> Option<String> {
2865
- std::fs::read(caminho).ok().map(|d| crate::checkpoint::sha256_hex(&d))
2866
  }
2867
 
2868
  #[pymodule]
@@ -2870,11 +2925,6 @@ fn nucleo_rust(m: &Bound<'_, PyModule>) -> PyResult<()> {
2870
  pyo3_log::init();
2871
  m.add_function(wrap_pyfunction!(versao, m)?)?;
2872
  m.add_function(wrap_pyfunction!(info_build, m)?)?;
2873
- m.add_function(wrap_pyfunction!(asm_relatorio, m)?)?;
2874
- m.add_function(wrap_pyfunction!(v2_relatorio_soundness, m)?)?;
2875
- m.add_function(wrap_pyfunction!(checkpoint_valido, m)?)?;
2876
- m.add_function(wrap_pyfunction!(checkpoint_manifesto, m)?)?;
2877
- m.add_function(wrap_pyfunction!(sha256_arquivo, m)?)?;
2878
  m.add_function(wrap_pyfunction!(lint_config, m)?)?;
2879
  m.add_function(wrap_pyfunction!(treinar_fase_a, m)?)?;
2880
  m.add_function(wrap_pyfunction!(treinar_fase_b, m)?)?;
@@ -2917,7 +2967,8 @@ fn nucleo_rust(m: &Bound<'_, PyModule>) -> PyResult<()> {
2917
  m.add_function(wrap_pyfunction!(som_com_moe, m)?)?;
2918
  m.add_function(wrap_pyfunction!(demo_acoplador_duplo, m)?)?;
2919
  m.add_function(wrap_pyfunction!(demo_pensamento_ncm, m)?)?;
2920
- m.add_function(wrap_pyfunction!(demo_raciocinio_elastico, m)?)?;
 
2921
  m.add_function(wrap_pyfunction!(demo_autoajuste, m)?)?;
2922
  m.add_function(wrap_pyfunction!(demo_fnh, m)?)?;
2923
  m.add_function(wrap_pyfunction!(demo_quebra_cabeca, m)?)?;
 
9
 
10
  pub mod amostrador;
11
  pub mod arvore_pesos;
12
+ pub mod asm_x86;
13
  pub mod atencao;
14
  pub mod acoplador;
15
  pub mod camadas;
 
16
  pub mod config;
17
  pub mod controlador;
18
  pub mod diagnostico;
 
30
  pub mod pensamento;
31
  pub mod quantizacao;
32
  pub mod quantizador;
 
33
  pub mod som4d;
34
  pub mod simd;
35
  pub mod ssd;
36
  pub mod stiefel;
37
  pub mod telemetria;
 
38
  pub mod tokens;
39
  pub mod tokenizador;
40
  pub mod treino;
 
47
 
48
  #[pyfunction]
49
  fn versao() -> &'static str {
50
+ "khtst-rust-0.11.0"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
51
  }
52
 
53
  #[pyfunction]
 
93
 
94
  #[staticmethod]
95
  fn carregar(caminho: &str) -> PyResult<Self> {
96
+ let txt = std::fs::read_to_string(caminho)
97
+ .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
98
  let v: serde_json::Value = serde_json::from_str(&txt)
99
  .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("JSON inválido: {e}")))?;
100
  let bpe = tokens::Bpe::de_json(&v)
 
111
  }
112
 
113
  fn salvar(&self, caminho: &str) -> PyResult<()> {
114
+ std::fs::write(
115
+ caminho,
116
+ serde_json::to_string(&self.bpe.para_json()).map_err(|e| {
117
+ pyo3::exceptions::PyRuntimeError::new_err(format!("serialização BPE: {e}"))
118
+ })?,
119
+ )
120
  .map_err(|e| pyo3::exceptions::PyIOError::new_err(format!("{e}")))?;
121
  Ok(())
122
  }
 
203
  })
204
  .map_err(pyo3::exceptions::PyRuntimeError::new_err)?;
205
  Python::with_gil(|py| {
206
+ let js = serde_json::to_value(&stats).map_err(|e| {
207
+ pyo3::exceptions::PyRuntimeError::new_err(format!("serialização: {e}"))
208
+ })?;
209
+ Ok(pythonize::pythonize(py, &js)?.into())
210
  })
211
  }
212
 
213
  fn estatisticas(&self) -> PyResult<PyObject> {
214
  let s = self.ponte.estatisticas();
215
  Python::with_gil(|py| {
216
+ let js = serde_json::to_value(&s).map_err(|e| {
217
+ pyo3::exceptions::PyRuntimeError::new_err(format!("serialização: {e}"))
218
+ })?;
219
+ Ok(pythonize::pythonize(py, &js)?.into())
220
  })
221
  }
222
  }
 
274
  "perplexidade_codebook": resumo.perplexidade_codebook,
275
  "monotonia_prefixo": resumo.monotonia_prefixo,
276
  "escore_aprendizado": resumo.escore_aprendizado,
 
 
 
277
  },
278
  "telemetria": hub.dump(),
279
  });
 
329
  "perplexidade_codebook": resumo.perplexidade_codebook,
330
  "monotonia_prefixo": resumo.monotonia_prefixo,
331
  "escore_aprendizado": resumo.escore_aprendizado,
 
 
332
  },
333
  "telemetria": hub.dump(),
334
  "entrada": "numpy",
 
365
  "passos": resumo.passos, "perda_inicial": resumo.perda_inicial,
366
  "perda_final": resumo.perda_final, "acc_conceitos": resumo.acc_recon,
367
  "escore_aprendizado": resumo.escore_aprendizado,
 
 
368
  },
369
  "telemetria": hub.dump(),
370
  "entrada": "numpy",
 
528
  frac_mascara: if j.frac_mascara > 0.0 { j.frac_mascara } else { 0.35 },
529
  semente: if j.semente > 0 { j.semente } else { 42 },
530
  tam_bloco: 2,
 
 
 
 
 
 
 
 
 
 
 
 
531
  };
532
  let var = match variante.as_str() {
533
  "image" => jepa::VarianteJepa::ImageJepa,
 
562
  }
563
 
564
  /// Relatório do despacho SIMD (kernels AVX-512 usados até agora).
565
+ #[pyfunction]
566
+ fn asm_relatorio(py: Python) -> PyResult<PyObject> {
567
+ Ok(pythonize::pythonize(py, &crate::asm_x86::relatorio())?.into())
568
+ }
569
+
570
  #[pyfunction]
571
  fn simd_relatorio(py: Python) -> PyResult<PyObject> {
572
  Ok(pythonize::pythonize(py, &simd::relatorio())?.into())
 
601
  "passos": resumo.passos, "perda_inicial": resumo.perda_inicial,
602
  "perda_final": resumo.perda_final, "acc_conceitos": resumo.acc_recon,
603
  "escore_aprendizado": resumo.escore_aprendizado,
 
 
604
  },
605
  "telemetria": hub.dump(),
606
  });
 
716
  let dev = candle_core::Device::Cpu;
717
  let c = stiefel::init_stiefel(k, d, &dev)
718
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
719
+ stiefel::erro_ortogonalidade(&c.transpose(0, 1).p()?)
720
+ .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))
721
  }
722
 
723
  // ===========================================================================
 
750
  eta0: f64, eta1: f64,
751
  semente: u64,
752
  espalhada: bool,
753
+ /// v0.11 (r-36): "media_suave" (padrão histórico) | "mediana_dura"
754
+ /// (Weiszfeld S4-2 — QE não-crescente garantida).
755
+ criterio: Option<String>,
756
+ /// iterações de Weiszfeld por célula (modo mediana_dura).
 
757
  weiszfeld_iters: usize,
758
  }
759
 
 
782
  gamma_vc: f64,
783
  frac_mascara: f64,
784
  semente: u64,
 
 
 
 
785
  }
786
 
787
  /// Faz o parse tipado; JSON inválido/erro de tipo vira PyValueError (antes:
 
817
  } else {
818
  som4d::Inicializacao4D::Dados
819
  },
820
+ criterio: if j.criterio.as_deref() == Some("mediana_dura") {
821
+ som4d::CriterioPrototipo4D::MedianaDura
822
+ } else {
823
+ som4d::CriterioPrototipo4D::MediaSuave
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
824
  },
825
+ weiszfeld_iters: if j.weiszfeld_iters > 0 { j.weiszfeld_iters } else { 20 },
826
  ..Default::default()
827
  };
828
  let som = som4d::treinar_som4d(&t, &c, &dev)
829
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
 
 
 
 
 
830
  let d = serde_json::json!({
831
  "versao": som4d::versao(),
832
  "celulas": som.n_celulas(),
833
  "grade": [som.nx, som.ny, som.nz, som.nt],
834
  "eq_inicial": som.eq_inicial,
835
  "eq_final": som.eq_final,
 
836
  "te_final": som.te_final,
837
  "historico_eq_te": som.historia,
838
+ // v0.11 (r-36 S4-1′): telemetria das métricas com garantia
839
+ "eqm_final": som.eqm_final,
840
+ "e_sigma_final": som.e_sigma_final,
841
+ "historico_eqm": som.historia_eqm,
842
+ "criterio": if matches!(c.criterio, som4d::CriterioPrototipo4D::MedianaDura) {
843
+ "mediana_dura"
844
+ } else {
845
+ "media_suave"
846
+ },
847
  "massa_soma": som.massa.iter().sum::<f64>(),
848
  });
849
  Ok(pythonize::pythonize(py, &d)?.into())
 
925
  if let Some(x) = o.get("epocas_finas") {
926
  c.epocas_finas = x.as_u64().unwrap_or(20) as usize;
927
  }
928
+ // v0.11 (r-36 H-1′(c)): pin do slot 0 no protótipo grosso
929
+ if let Some(x) = o.get("pin_slot0") {
930
+ c.pin_slot0 = x.as_bool().unwrap_or(false);
931
  }
932
  }
933
  }
934
  }
935
  let h = som4d::treinar_hsom(&t, &c, &dev)
936
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
937
+ // v0.11 (r-36 H-1′(b)): cota Minkowski APERTADA
938
+ // √EQ_hier ≤ √EQ_g + √R_f (domina a antiga com 2R_f)
939
+ let cota = h.eq_grosso + h.r_fino + 2.0 * (h.eq_grosso * h.r_fino).sqrt();
940
  let d = serde_json::json!({
941
  "versao": som4d::versao(),
942
  "eq_hierarquico": h.eq_hierarquico,
 
944
  "r_fino": h.r_fino,
945
  "cota_teo_h1": cota,
946
  "cota_respeitada": h.eq_hierarquico <= cota + 1e-9,
947
+ // H-1′(c) com pin: EQ_hier ≤ EQ_grosso EXATO (teorema construtivo)
948
+ "pin_slot0": c.pin_slot0,
949
+ "h1c_teoroma_respeitado": !c.pin_slot0 || (h.eq_hierarquico <= h.eq_grosso + 1e-9),
950
  });
951
  Ok(pythonize::pythonize(py, &d)?.into())
952
  }
 
960
  cfg_grade: som4d::CfgSom4D { nx: 3, ny: 3, nz: 2, nt: 2, epocas: 15, ..Default::default() },
961
  gamma,
962
  janela: janela.len(),
 
963
  };
964
  let mut ts = som4d::TSom4D::novo(&t0, &cfg, &dev)
965
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
 
985
  let t = tensor_de_2d(dados, &dev).map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
986
  // v0.9.0: parse tipado — defaults idênticos aos da v0.8.0
987
  let j: CfgJepaJ = parse_cfg_tipado(&cfg)?;
 
 
 
 
 
 
 
 
 
 
988
  let c = jepa::CfgJepa {
989
  d_emb: if j.d_emb > 0 { j.d_emb } else { 32 },
990
  epocas: if j.epocas > 0 { j.epocas } else { 60 },
 
995
  frac_mascara: if j.frac_mascara > 0.0 { j.frac_mascara } else { 0.35 },
996
  semente: if j.semente > 0 { j.semente } else { 42 },
997
  tam_bloco: 2,
 
 
 
998
  };
999
  let var = match variante.as_str() {
1000
  "image" => jepa::VarianteJepa::ImageJepa,
 
1118
  #[pyfunction]
1119
  fn demo_sonic_moe(py: Python, n: usize, d: usize, n_expertos: usize, top_k: usize, capacidade: usize) -> PyResult<PyObject> {
1120
  let dev = candle_core::Device::Cpu;
1121
+ // v0.11: construção SEMEADA — demo determinística (reprodutível)
1122
+ let moe = jepa::SonicMoe::novo_com_semente(d, n_expertos, top_k, capacidade, 42, &dev)
1123
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1124
  let x = candle_core::Tensor::randn(0f32, 1.0, (n, d), &dev)
1125
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
 
1140
  #[pyfunction]
1141
  fn demo_replay_ssm(py: Python, passos: usize, alpha: f64) -> PyResult<PyObject> {
1142
  let dev = candle_core::Device::Cpu;
1143
+ // v0.11: construção SEMEADA — demo determinística (reprodutível)
1144
+ let mut ssm = jepa::ReplaySsm::novo_com_semente(4, 6, alpha, 8, 42, &dev)
1145
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1146
  let mut otim = crate::treino::AdamWManual::novo(ssm.vars(), 1e-2, 0.0);
1147
  let x_antigo = candle_core::Tensor::from_vec(vec![1.0f32; 16 * 4], (16, 4), &dev)
 
1277
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1278
  let verifica = |resp: &Tensor| -> f64 {
1279
  // confiança = 1/(1+10·MSE) — medível e causaL (só da resposta)
1280
+ // erro de forma/cálculo ⇒ confiança 0 (fallback EXPLÍCITO —
1281
+ // o motor re-planeja; nunca propaga panic pela fronteira PyO3)
1282
+ let dif = match resp
1283
+ .broadcast_as((1, d_saida))
1284
+ .and_then(|r| &r - &alvo_verd.broadcast_as((1, d_saida))?)
1285
+ {
1286
+ Ok(d) => d,
1287
+ Err(_) => return 0.0,
1288
+ };
1289
+ let mse = match dif.sqr().and_then(|t| t.mean_all()) {
1290
+ Ok(t) => match t.to_scalar::<f32>() {
1291
+ Ok(v) => v as f64,
1292
+ Err(_) => return 0.0,
1293
+ },
1294
+ Err(_) => return 0.0,
1295
+ };
1296
  1.0 / (1.0 + 10.0 * mse)
1297
  };
1298
  let mut rng2 = crate::rng::RngDeterministico::novo(semente + 1);
 
1300
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1301
 
1302
  // linha de base SEM pensamento: uma tentativa isolada, sem agregação
1303
+ let base = motor.tentativas[0].fwd(&consulta_t.broadcast_as((1, d_cond)).p()?)
1304
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1305
  let conf_base = verifica(&base);
1306
  let conf_pensamento = res.confianca;
 
1434
  l.push((base + rng.normal(0.0, 1.2) as f32 + desloc as f32) as f32);
1435
  }
1436
  }
1437
+ // from_vec só falha em shape/len inconsistente (impossível
1438
+ // aqui: l tem exatamente m·k elementos) — fallback EXPLÍCITO
1439
+ let lt = candle_core::Tensor::from_vec(l, (m, k), &dev)
1440
+ .unwrap_or_else(|_| candle_core::Tensor::zeros((m, k), candle_core::DType::F32, &dev).unwrap_or_else(|_| panic!("device CPU indisponível")));
1441
  (lt, a)
1442
  };
1443
  let (lt_tre, alvos_tre) = gerar(&mut rng, n, 0.0);
 
1452
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1453
  let mut otim = treino::AdamWManual::novo(vec![w_var.clone()], 0.05, 0.0);
1454
  for _ in 0..120 {
1455
+ let logits = lt_tre.matmul(&w_var.as_tensor().transpose(0, 1).p()?).p()?;
1456
+ let ce = candle_nn::loss::cross_entropy(&logits, &at_t).p()?;
1457
+ let g = treino::grads_achatados(&ce, &[w_var.clone()]).p()?;
1458
  otim.passo(g);
1459
  }
1460
  // logits de validação com o modelo treinado
1461
+ let logits_val = lt_val.matmul(&w_var.as_tensor().transpose(0, 1).p()?).p()?;
1462
  let at_v = candle_core::Tensor::from_vec(
1463
  alvos_val.iter().map(|&a| a as u32).collect::<Vec<u32>>(), (n / 2,), &dev)
1464
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
 
1466
  let mut v = verificador::VerificadorNcm::novo();
1467
  let (ece_antes, ece_depois) = v.ajustar(&logits_val, &at_v)
1468
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1469
+ let confs: Vec<f64> = v.confianca(&logits_val).p()?
1470
+ .flatten_all().p()?.to_vec1::<f32>().p()?.iter().map(|x| *x as f64).collect();
1471
+ let corretos: Vec<bool> = logits_val.argmax(candle_core::D::Minus1).p()?
1472
+ .eq(&at_v).p()?.to_dtype(candle_core::DType::U32).p()?
1473
+ .flatten_all().p()?.to_vec1::<u32>().p()?
1474
  .iter().map(|x| *x == 1).collect();
1475
  let tau_c = verificador::limiar_por_erro(&confs, 0.25);
1476
  let (mut erro_aceito, mut n_aceito) = (0usize, 0usize);
 
1554
  "maior_sobreposicao_us": resumo.maior_sobreposicao_us,
1555
  },
1556
  "painel_v060": hub.painel_v060(),
 
1557
  "telemetria": hub.dump(),
1558
  });
1559
  Ok(pythonize::pythonize(py, &dados)?.into())
 
1576
  let mut moe = moe_redirecionavel::MoeRedirecionavel::novo(d, 8, 2, n, &dev)
1577
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1578
  // M-R2: neutralidade no nascimento
1579
+ let g0 = moe.atencao.gate.as_tensor().to_scalar::<f32>().p()?;
1580
+ let y0 = moe.atencao.fwd(&x).p()?;
1581
+ let dif0 = (&y0 - &x).p()?.sqr().p()?.sum_all().p()?
1582
+ .to_scalar::<f32>().p()? as f64;
1583
  // abre o gate (mecanismo ativo)
1584
+ moe.atencao.gate.set(&candle_core::Tensor::new(1.0f32, &dev).p()?).p()?;
1585
  // M-R1: invariância sob redirecionamento
1586
+ let s_enc = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).p()?;
1587
  let carga_antes: usize = s_enc.carga.iter().sum();
1588
+ let perda_antes = s_enc.perda_aux.to_scalar::<f32>().p()? as f64;
1589
  let permuta: Vec<usize> = (0..8).map(|i| (i + 1) % 8).collect();
1590
  moe.redirecionar(&permuta);
1591
+ let s_enc2 = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).p()?;
1592
  let carga_depois: usize = s_enc2.carga.iter().sum();
1593
+ let perda_depois = s_enc2.perda_aux.to_scalar::<f32>().p()? as f64;
1594
  // M-R3: paralelismo medido (enc ∥ dec em 2 threads)
1595
+ let (_e, _dc, t_par, t_seq, speedup) = moe.fwd_ambos_par(&x).p()?;
1596
  // M-R5: water-filling vs uniforme (cota analítica)
1597
  let qes: Vec<f64> = vec![0.15, 0.4, 1.0, 0.25, 0.6, 0.1, 0.35, 0.5];
1598
  let c_wf = moe_redirecionavel::alocar_por_qe(&qes, 16);
 
1851
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1852
  // base: 1 tentativa isolada, mesma verificação NCM
1853
  let base = motor.tentativas[0]
1854
+ .fwd(&consulta_t.broadcast_as((1, d_cond)).p()?).p()?;
1855
+ let conf_base = verif.confianca_1d(&logits_fn(&base).p()?).p()?;
1856
  confs_base.push(conf_base);
1857
  confs_pens.push(res.confianca);
1858
  iteracoes.push(res.iteracoes);
 
1868
  let res_ood = motor.raciocinar_ncm(&consulta_ood_t, &verif, &logits_fn, &mut rng3)
1869
  .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(format!("{e}")))?;
1870
  let base_ood = motor.tentativas[0]
1871
+ .fwd(&consulta_ood_t.broadcast_as((1, d_cond)).p()?).p()?;
1872
+ let conf_base_ood = verif.confianca_1d(&logits_fn(&base_ood).p()?).p()?;
1873
  let _ = mk;
1874
  let d_ = serde_json::json!({
1875
  "versao": "pensamento-0.6.0-ncm",
 
1898
  })
1899
  }
1900
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1901
 
1902
  /// **Autoajuste do Pensamento por telemetria (A-1..A-5) — demo:** alimenta
1903
  /// o controlador com sinais sintéticos medidos e verifica cada regra.
 
1938
  u.registrar(braco, r);
1939
  }
1940
  let medias = u.medias();
1941
+ let melhor = medias.iter().enumerate().max_by(|a, b| a.1.total_cmp(&b.1)).map(|(i, _)| i).unwrap_or(0);
1942
  let d_ = serde_json::json!({
1943
  "versao": "autoajuste-0.6.0",
1944
  "tau_c_final": tau, "n_tentativas_final": n_ajustado,
 
2140
  pyo3::exceptions::PyRuntimeError::new_err(format!("{e}"))
2141
  }
2142
 
2143
+ /// v0.11 (tratamento.txt §1 — "nunca unwrap em produção"): propagação
2144
+ /// candle→PyErr como MÉTODO POSTFIX (a regra do órfão impede `impl From`
2145
+ /// para tipos externos). Migração total e completa dos `unwrap()` do
2146
+ /// lib.rs: `.p()?` → `.p()?` — mesmo ponto de fixação sintático,
2147
+ /// semântica de propagação explícita.
2148
+ trait PropPy<T> {
2149
+ fn p(self) -> PyResult<T>;
2150
+ }
2151
+
2152
+ impl<T> PropPy<T> for candle_core::Result<T> {
2153
+ #[inline]
2154
+ fn p(self) -> PyResult<T> {
2155
+ self.map_err(py_err)
2156
+ }
2157
+ }
2158
+
2159
  /// **Quebra-cabeça sobre o conhecimento TREINADO REAL** (script 63):
2160
  /// carrega o tokenizador (codebook do nível `nivel` — o conhecimento
2161
  /// aprendido dos dados reais) e o gerador (a cabeça real como logits_fn
 
2426
  lv.push(base + rng.normal(0.0, 1.0) as f32);
2427
  }
2428
  }
2429
+ let lt = Tensor::from_vec(lv, (n, k), &dev).p()?;
2430
+ let at = Tensor::from_vec(av, (n,), &dev).p()?;
2431
  let t0 = Instant::now();
2432
+ let (t_g, _, nll_g) = verificador::calibrar_temperatura(&lt, &at).p()?;
2433
  let tempo_golden = t0.elapsed().as_secs_f64();
2434
  let t0 = Instant::now();
2435
  let (t_n, _, nll_n, n_aval) =
2436
+ verificador::calibrar_temperatura_newton(&lt, &at, 40).p()?;
2437
  let tempo_newton = t0.elapsed().as_secs_f64();
2438
 
2439
  // ---------- (2) Cayley vs polar (FNH) ----------
2440
  let n_rot = 16usize;
2441
+ let r = fnh::RotacaoSkew::nova(n_rot, &dev).p()?;
2442
  let th: Vec<f32> = (0..n_rot * (n_rot - 1) / 2)
2443
  .map(|i| ((i as f32) * 0.11) % 0.5)
2444
  .collect();
2445
  r.theta
2446
+ .set(&Tensor::from_vec(th, (n_rot * (n_rot - 1) / 2,), &dev).p()?)
2447
+ .p()?;
2448
  let rep = 25usize;
2449
  let t0 = Instant::now();
2450
  let mut delta_polar = 0.0;
2451
  for _ in 0..rep {
2452
+ delta_polar = crate::stiefel::erro_ortogonalidade(&r.rotacao_polar().p()?).p()?;
2453
  }
2454
  let tempo_polar = t0.elapsed().as_secs_f64() / rep as f64;
2455
  let t0 = Instant::now();
2456
  let mut delta_cayley = 0.0;
2457
  for _ in 0..rep {
2458
+ delta_cayley = crate::stiefel::erro_ortogonalidade(&r.rotacao_cayley().p()?).p()?;
2459
  }
2460
  let tempo_cayley = t0.elapsed().as_secs_f64() / rep as f64;
2461
 
 
2483
  // ---------- (4) MoE vetorizada: valores + gradiente + custo ----------
2484
  let (nm, dm, em) = (256usize, 32usize, 8usize);
2485
  let xv: Vec<f32> = (0..nm * dm).map(|_| rng.normal(0.0, 1.0) as f32).collect();
2486
+ let x = Tensor::from_vec(xv, (nm, dm), &dev).p()?;
2487
+ let moe = moe_redirecionavel::MoeRedirecionavel::novo(dm, em, 2, nm, &dev).p()?;
2488
+ let s_ref = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).p()?;
2489
+ let s_vet = moe.fwd_vetorizado(&x, moe_redirecionavel::Papel::Codificador).p()?;
2490
  let dif_moe = (&s_ref.saida - &s_vet.saida)
2491
+ .p()?
2492
  .abs()
2493
+ .p()?
2494
  .max_all()
2495
+ .p()?
2496
  .to_scalar::<f32>()
2497
+ .p()? as f64;
2498
  let rep_moe = 10usize;
2499
  let t0 = Instant::now();
2500
  for _ in 0..rep_moe {
2501
+ let _ = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).p()?;
2502
  }
2503
  let tempo_moe_ref = t0.elapsed().as_secs_f64() / rep_moe as f64;
2504
  let t0 = Instant::now();
2505
  for _ in 0..rep_moe {
2506
+ let _ = moe.fwd_vetorizado(&x, moe_redirecionavel::Papel::Codificador).p()?;
2507
  }
2508
  let tempo_moe_vet = t0.elapsed().as_secs_f64() / rep_moe as f64;
2509
  // normas de gradiente (bug v080-1: fwd = 0; vetorizada > 0)
2510
+ // fallback EXPLÍCITO: (NaN, NaN) sinaliza falha no relatório da demo
2511
+ // (ausência de gradiente ≠ 0 — preserva a semântica do bug v080-1)
2512
  let norma = |vet: bool| -> (f64, f64) {
2513
  let s = if vet {
2514
+ moe.fwd_vetorizado(&x, moe_redirecionavel::Papel::Codificador)
2515
  } else {
2516
+ moe.fwd(&x, moe_redirecionavel::Papel::Codificador)
2517
  };
2518
+ let Ok(s) = s else { return (f64::NAN, f64::NAN) };
2519
+ let Ok(perda) = s.saida.sqr().and_then(|t| t.sum_all()) else {
2520
+ return (f64::NAN, f64::NAN);
2521
+ };
2522
+ let Ok(gs) = perda.backward() else { return (f64::NAN, f64::NAN) };
2523
  let mut nr = 0.0;
2524
  for v in moe.roteador.vars() {
2525
  if let Some(g) = gs.get(&v) {
2526
+ if let Ok(sq) = g.sqr().and_then(|t| t.sum_all()).and_then(|t| t.to_scalar::<f32>()) {
2527
+ nr += sq as f64;
2528
+ }
2529
  }
2530
  }
2531
  let mut ne = 0.0;
2532
  for e in &moe.especialistas {
2533
  for v in e.vars() {
2534
  if let Some(g) = gs.get(&v) {
2535
+ if let Ok(sq) = g.sqr().and_then(|t| t.sum_all()).and_then(|t| t.to_scalar::<f32>()) {
2536
+ ne += sq as f64;
2537
+ }
2538
  }
2539
  }
2540
  }
 
2545
 
2546
  // ---------- (5) re-ablação JEPA 3 braços (gradiente restaurado) ----------
2547
  let xv: Vec<f32> = (0..64 * 12).map(|_| rng.normal(0.0, 1.0) as f32).collect();
2548
+ let xj = Tensor::from_vec(xv, (64, 12), &dev).p()?;
2549
  let mut ablac = serde_json::Map::new();
2550
  for modo in ["pequena", "densa", "moe"] {
2551
+ let rj = moe_redirecionavel::treinar_jepa_com_moe(&xj, modo, 120, 0.5, 42).p()?;
2552
  ablac.insert(
2553
  modo.into(),
2554
  serde_json::json!({
 
2606
  Ok(pythonize::pythonize(py, &d_)?.into())
2607
  }
2608
 
2609
+ /// **Raciocínio ELÁSTICO sobre RESÍDUOS DE QUANTIZAÇÃO (tarefa REAL, r-42):**
2610
+ /// recebe latentes reais (n, d) — p.ex. do tokenizador treinado em
2611
+ /// Wikipédia PT-BR via `codificar_latentes` — quantiza com o NCM (codebook
2612
+ /// Stiefel, K códigos, escala EMA) e forma os resíduos `ρ = z − r_h`: o que
2613
+ /// o decoder NCM NÃO representa. O MotorPensamento aprende a CORRIGIR o
2614
+ /// código (`cond = r_h → alvo = z`); o verificador é uma cabeça treinada
2615
+ /// na tarefa de PREVER O CÓDIGO do latente (z bem-formado ⇒ código
2616
+ /// previsível ⇒ confiança alta; correção ruim ⇒ latente malformado ⇒
2617
+ /// confiança baixa ⇒ expansão), calibrada em dados retidos (V-1/V-2′).
2618
+ /// O `RaciocinioElastico` (RE-1..RE-8) roda com massas de atenção REAIS
2619
+ /// (q = latente verdadeiro, k_base = codebook) — os certificados de
2620
+ /// compressão RE-2 são VÁLIDOS (não proxy). Telemetria completa do
2621
+ /// quantizador (r-38: contração, ρ, perplexidade, MI lag-1) e do ciclo
2622
+ /// elástico (ε_safe, π_rem, bound vs Δconf medido, violações, Hedge).
2623
  #[pyfunction]
2624
+ #[pyo3(signature = (dados, k=16, n_tentativas=3, passos_treino=240, tau_c=0.55, b_max=6, n_consultas=12, semente=42))]
2625
+ fn raciocinio_elastico_residuos(
2626
+ py: Python,
2627
+ dados: numpy::PyReadonlyArray2<f32>,
2628
+ k: usize,
2629
+ n_tentativas: usize,
2630
+ passos_treino: usize,
2631
+ tau_c: f64,
2632
+ b_max: usize,
2633
+ n_consultas: usize,
2634
+ semente: u64,
2635
+ ) -> PyResult<PyObject> {
2636
+ Python::with_gil(|py| {
2637
+ use candle_core::Tensor;
2638
+ let dev = candle_core::Device::Cpu;
2639
+ let v = dados.as_array();
2640
+ let (n, d) = (v.nrows(), v.ncols());
2641
+ if n < 64 || d < 4 {
2642
+ return Err(pyo3::exceptions::PyValueError::new_err(
2643
+ "precisa de dados (n>=64, d>=4) — use codificar_latentes para latentes reais",
2644
+ ));
2645
+ }
2646
+ let plano: Vec<f32> = dados
2647
+ .as_slice()
2648
+ .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("array não contíguo: {e}")))?
2649
+ .to_vec();
2650
+ let z_t = Tensor::from_vec(plano, (n, d), &dev).map_err(py_runtime)?;
2651
+
2652
+ // ---- (1) QUANTIZADOR NCM + telemetria r-38 (dados REAIS) ----
2653
+ let mut quant = crate::quantizador::QuantizadorNivel::novo(
2654
+ k, d, crate::quantizador::ModoQuant::SteEma, 0.99, "otima_teo", &dev)
2655
+ .map_err(py_runtime)?;
2656
+ quant.atualizar_escala(&z_t).map_err(py_runtime)?;
2657
+ let (ids_t, valores_t) = quant.quantizar_duro(&z_t).map_err(py_runtime)?;
2658
+ quant.registrar_uso(&ids_t).map_err(py_runtime)?;
2659
+ let contr = quant.contracao_empirica(&z_t).map_err(py_runtime)?;
2660
+ let rho_medio = quant.residuo_ste(&z_t).map_err(py_runtime)?;
2661
+ let mi_lag1 = quant.dependencia_uso(&ids_t).map_err(py_runtime)?;
2662
+ // resíduos: ρ = z − r_h (a parte NÃO representada — tarefa real)
2663
+ let residuos = (&z_t - &valores_t).map_err(py_runtime)?;
2664
+ let _ = &residuos; // telemetria expõe ρ² via residuo_ste
2665
+
2666
+ // ---- (2) divisão treino/retidos (metade final — calibração V-2) ----
2667
+ let n_ret = n / 2;
2668
+ let narrow =
2669
+ |t: &Tensor, a: usize, b: usize| -> candle_core::Result<Tensor> { t.narrow(0, a, b) };
2670
+ let z_tr = narrow(&z_t, 0, n_ret).map_err(py_runtime)?;
2671
+ let z_re = narrow(&z_t, n_ret, n - n_ret).map_err(py_runtime)?;
2672
+ let r_tr = narrow(&valores_t, 0, n_ret).map_err(py_runtime)?;
2673
+ let r_re = narrow(&valores_t, n_ret, n - n_ret).map_err(py_runtime)?;
2674
+ let ids_re = narrow(&ids_t, n_ret, n - n_ret).map_err(py_runtime)?;
2675
+
2676
+ // ---- (3) CABEÇA VERIFICADORA: prever o CÓDIGO do latente ----
2677
+ let cabeca = crate::jepa::MlpJepa::novo_semeado(
2678
+ d, 4 * d, k, &dev, &mut crate::rng::RngDeterministico::novo(semente ^ 0xC0DE))
2679
+ .map_err(py_runtime)?;
2680
+ let ids_tr = narrow(&ids_t, 0, n_ret).map_err(py_runtime)?;
2681
+ let mut otim_cab = treino::AdamWManual::novo(cabeca.vars(), 1e-2, 0.0);
2682
+ let mut ce_hist = Vec::new();
2683
+ for passo in 0..passos_treino {
2684
+ let logits = cabeca.fwd(&z_tr).map_err(py_runtime)?;
2685
+ let ce = candle_nn::loss::cross_entropy(&logits, &ids_tr).map_err(py_runtime)?;
2686
+ if passo % 40 == 0 || passo == passos_treino - 1 {
2687
+ ce_hist.push(ce.to_scalar::<f32>().map_err(py_runtime)? as f64);
2688
+ }
2689
+ otim_cab.passo(treino::grads_achatados(&ce, &cabeca.vars()).map_err(py_runtime)?);
2690
+ }
2691
+ // calibração em RETIDOS (V-1/V-2′ — soundness e ECE_aceito)
2692
+ let logits_re = cabeca.fwd(&z_re).map_err(py_runtime)?;
2693
+ let mut verif = verificador::VerificadorNcm::novo();
2694
+ let (ece_antes, ece_depois) = verif.ajustar(&logits_re, &ids_re).map_err(py_runtime)?;
2695
+ let confs_cal: Vec<f64> = verif
2696
+ .confianca(&logits_re)
2697
+ .map_err(py_runtime)?
2698
+ .flatten_all()
2699
+ .map_err(py_runtime)?
2700
+ .to_vec1::<f32>()
2701
+ .map_err(py_runtime)?
2702
+ .iter()
2703
+ .map(|x| *x as f64)
2704
+ .collect();
2705
+ let corretos: Vec<bool> = logits_re
2706
+ .argmax(candle_core::D::Minus1)
2707
+ .map_err(py_runtime)?
2708
+ .eq(&ids_re)
2709
+ .map_err(py_runtime)?
2710
+ .to_dtype(candle_core::DType::U32)
2711
+ .map_err(py_runtime)?
2712
+ .flatten_all()
2713
+ .map_err(py_runtime)?
2714
+ .to_vec1::<u32>()
2715
+ .map_err(py_runtime)?
2716
+ .iter()
2717
+ .map(|x| *x == 1)
2718
+ .collect();
2719
+ let (_, cota_cond, cota_limpa, p_aceite) =
2720
+ verificador::soundness_aceite(&confs_cal, &corretos, tau_c, 12);
2721
 
2722
+ // ---- (4) MOTOR do Pensamento: corrigir o código (cond=r → alvo=z) ----
2723
+ let mut motor = pensamento::MotorPensamento::novo_com_semente(
2724
+ d, d, n_tentativas, tau_c, b_max, semente, &dev)
2725
+ .map_err(py_runtime)?;
2726
+ let mut otim = treino::AdamWManual::novo(motor.vars(), 5e-3, 0.0);
2727
+ let mut perda_hist = Vec::new();
2728
+ for passo in 0..passos_treino {
2729
+ let perda = motor.perda_treino(&r_tr, &z_tr).map_err(py_runtime)?;
2730
+ if passo % 40 == 0 || passo == passos_treino - 1 {
2731
+ perda_hist.push(perda.to_scalar::<f32>().map_err(py_runtime)? as f64);
2732
+ }
2733
+ otim.passo(treino::grads_achatados(&perda, &motor.vars()).map_err(py_runtime)?);
2734
+ }
2735
+
2736
+ // ---- (5) CICLO ELÁSTICO nas consultas RETIDAS (massas REAIS) ----
2737
+ let codebook = quant.codebook().map_err(py_runtime)?; // (K, d)
2738
+ let mut hub = telemetria::TelemetryHub::novo(None);
2739
+ let cfg_el = pensamento::ConfigElastica {
2740
+ tau_c,
2741
+ b_max,
2742
+ max_pecas: 48,
2743
+ beta_relevancia: 0.3,
2744
+ z_sup: 12.0,
2745
+ norma_w: 1.0,
2746
+ n_classes: k,
2747
+ eta_hedge: None,
2748
+ fator_temp: 1.6,
2749
+ temp_max: 2.0,
2750
+ semente,
2751
+ };
2752
+ let mut resumo = Vec::new();
2753
+ let mut curva_gate: Vec<(f64, f64)> = Vec::new();
2754
+ let mut gate_escolhido = 0.0f64;
2755
+ let mut violacoes = 0usize;
2756
+ let mut rollbacks = 0usize;
2757
+ let mut certificados_emitidos = 0usize;
2758
+ let mut pecas_fim = 0usize;
2759
+ let mut respostas_sounds = 0usize;
2760
+ let mut confs_el = Vec::new();
2761
+ let n_cons = n_consultas.min(n - n_ret);
2762
+ let mut confs_por_braco: [Vec<f64>; 2] = [Vec::new(), Vec::new()];
2763
+ for qi in 0..n_cons {
2764
+ let z_q = z_re.get(qi).map_err(py_runtime)?.broadcast_as((1, d)).map_err(py_runtime)?;
2765
+ let r_q = r_re.get(qi).map_err(py_runtime)?.broadcast_as((1, d)).map_err(py_runtime)?;
2766
+ // cada consulta recomeça o banco (peças da consulta corrente)
2767
+ let mut el = pensamento::RaciocinioElastico::novo(
2768
+ pensamento::MotorPensamento::novo_com_semente(
2769
+ d, d, n_tentativas, tau_c, b_max, semente + qi as u64, &dev)
2770
+ .map_err(py_runtime)?,
2771
+ cfg_el.clone(),
2772
+ )
2773
+ .map_err(py_runtime)?;
2774
+ // transfere os pesos TREINADOS para o motor da consulta
2775
+ let vars_fonte = motor.vars();
2776
+ let vars_alvo = el.motor.vars();
2777
+ for (va, vf) in vars_alvo.iter().zip(vars_fonte.iter()) {
2778
+ va.set(vf.as_tensor()).map_err(py_runtime)?;
2779
+ }
2780
+ let logits_fn = |resp: &Tensor| -> candle_core::Result<Tensor> { cabeca.fwd(resp) };
2781
+ // v0.11: calibra o gate UMA vez (primeira consulta) em treino —
2782
+ // exercita o certificado RE-2 com g > 0 (não-trivial)
2783
+ if qi == 0 {
2784
+ let m_cal = 12.min(n_ret);
2785
+ let conds_cal = narrow(&r_tr, 0, m_cal).map_err(py_runtime)?;
2786
+ let mut rng_cal = crate::rng::RngDeterministico::novo(semente ^ 0x6A7E);
2787
+ let (g_esc, curva) = el
2788
+ .calibrar_gate(&conds_cal, &verif, &logits_fn, &[0.0, 0.25, 0.5, 0.75, 1.0], &mut rng_cal)
2789
+ .map_err(py_runtime)?;
2790
+ curva_gate = curva;
2791
+ gate_escolhido = g_esc;
2792
+ // repõe os pesos treinados (a calibração só mudou o gate)
2793
+ for (va, vf) in el.motor.vars().iter().zip(motor.vars().iter()) {
2794
+ va.set(vf.as_tensor()).map_err(py_runtime)?;
2795
+ }
2796
+ el.motor
2797
+ .gate_atencao
2798
+ .set(&candle_core::Tensor::new(gate_escolhido as f32, &dev).map_err(py_runtime)?)
2799
+ .map_err(py_runtime)?;
2800
+ }
2801
+ // massas REAIS: q = latente verdadeiro (1,1,d); k_base = codebook
2802
+ let q_att = z_q.reshape((1, 1, d)).map_err(py_runtime)?;
2803
+ let k_att = codebook.reshape((1, k, d)).map_err(py_runtime)?;
2804
+ // ABLAÇÃO (braço B): metade final das consultas com gate FIXO
2805
+ // 0.25 — exercita o certificado RE-2 NÃO-TRIVIAL (g>0, bound
2806
+ // finito, Δconf medido ≤ bound) em dados reais; o braço A usa
2807
+ // o gate calibrado (escolha ótima em treino)
2808
+ let braco_ablacao = qi >= n_cons / 2;
2809
+ if braco_ablacao {
2810
+ el.motor
2811
+ .gate_atencao
2812
+ .set(&candle_core::Tensor::new(0.25f32, &dev).map_err(py_runtime)?)
2813
+ .map_err(py_runtime)?;
2814
+ }
2815
+ let mut rng_q = crate::rng::RngDeterministico::novo(semente.wrapping_add(qi as u64));
2816
+ let r = el
2817
+ .raciocinar(&r_q, &verif, &logits_fn, Some(&q_att), Some(&k_att), &mut hub, &mut rng_q)
2818
+ .map_err(py_runtime)?;
2819
+ for cert in &r.certificados {
2820
+ if cert.violado {
2821
+ violacoes += 1;
2822
+ }
2823
+ if cert.rollback {
2824
+ rollbacks += 1;
2825
+ }
2826
+ }
2827
+ certificados_emitidos += r.certificados.len();
2828
+ confs_el.push(r.base.confianca);
2829
+ if braco_ablacao {
2830
+ confs_por_braco[1].push(r.base.confianca);
2831
+ } else {
2832
+ confs_por_braco[0].push(r.base.confianca);
2833
+ }
2834
+ // soundness da resposta ENTREGUE: conf >= tau_c OU declaração
2835
+ // honesta de orçamento esgotado (T-P4) — o rollback de RE-2
2836
+ // garante que respostas comprimidas violadas NUNCA são entregues
2837
+ let esgotado = r.telemetria_extra.get("orcamento_esgotado").copied().unwrap_or(0.0);
2838
+ if r.base.confianca >= tau_c || esgotado == 1.0 {
2839
+ respostas_sounds += 1;
2840
+ }
2841
+ let mut hedge_top: Vec<f64> = r.pesos_hedge_final.clone();
2842
+ hedge_top.sort_by(|a, b| b.partial_cmp(a).unwrap_or(std::cmp::Ordering::Equal));
2843
+ hedge_top.truncate(3);
2844
+ resumo.push(serde_json::json!({
2845
+ "consulta": qi,
2846
+ "braco": if braco_ablacao { "gate_fixo_0.25" } else { "gate_calibrado" },
2847
+ "confianca": r.base.confianca,
2848
+ "iteracoes": r.base.iteracoes,
2849
+ "orcamento_esgotado": r.telemetria_extra.get("orcamento_esgotado").copied().unwrap_or(0.0),
2850
+ "massas_reais": r.telemetria_extra.get("massas_reais").copied().unwrap_or(0.0),
2851
+ "certificados": r.certificados.iter().map(|c| serde_json::json!({
2852
+ "epsilon_safe": if c.epsilon_safe.is_infinite() { 1e9 } else { c.epsilon_safe },
2853
+ "massa_removida": c.massa_removida,
2854
+ "bound_delta_conf": c.bound_delta_conf,
2855
+ "delta_conf_medido": c.delta_conf_medido,
2856
+ "violado": c.violado, "rollback": c.rollback, "valido": c.valido,
2857
+ })).collect::<Vec<_>>(),
2858
+ "hedge_top3": hedge_top,
2859
+ }));
2860
+ pecas_fim += el.pecas.len();
2861
+ }
2862
+ let conf_media = confs_el.iter().sum::<f64>() / confs_el.len().max(1) as f64;
2863
+ let aceite = confs_el.iter().filter(|c| **c >= tau_c).count();
2864
+
2865
+ // ---- (6) relatório + gates ----
2866
+ let d_ = serde_json::json!({
2867
+ "versao": pensamento::versao(),
2868
+ "tarefa": "raciocinio-elastico-sobre-residuos-de-quantizacao (REAL)",
2869
+ "n": n, "d": d, "k": k, "n_tentativas": n_tentativas,
2870
+ "semente": semente,
2871
+ "quantizador": {
2872
+ "contracao_medida": contr.medida, "contracao_otima": contr.otima,
2873
+ "contracao_cota_garantida": contr.cota, "fracao_span": contr.fracao_span,
2874
+ "residuo_ste_rho2": rho_medio, "perplexidade_uso": quant.perplexidade_uso(),
2875
+ "mi_lag1_nats": mi_lag1,
2876
+ },
2877
+ "treino": {
2878
+ "perda_motor": perda_hist, "ce_cabeca": ce_hist,
2879
+ "perda_motor_caiu": perda_hist.last() < perda_hist.first(),
2880
+ "ce_cabeca_caiu": ce_hist.last() < ce_hist.first(),
2881
+ },
2882
+ "verificador": {
2883
+ "ece_antes": ece_antes, "ece_depois": ece_depois,
2884
+ "temperatura": verif.temperatura,
2885
+ "soundness_cota_condicional": cota_cond,
2886
+ "soundness_cota_limpa": cota_limpa,
2887
+ "taxa_aceite_calibracao": p_aceite,
2888
+ },
2889
+ "elasticas": {
2890
+ "gate_calibrado": gate_escolhido,
2891
+ "curva_gate_conf": curva_gate,
2892
+ "consultas": resumo,
2893
+ "conf_media": conf_media, "aceites": aceite,
2894
+ "conf_media_gate_calibrado": confs_por_braco[0].iter().sum::<f64>()
2895
+ / confs_por_braco[0].len().max(1) as f64,
2896
+ "conf_media_gate_fixo_025": confs_por_braco[1].iter().sum::<f64>()
2897
+ / confs_por_braco[1].len().max(1) as f64,
2898
+ "violacoes_h1_detectadas": violacoes, "rollbacks_defensivos": rollbacks,
2899
+ "certificados_emitidos": certificados_emitidos,
2900
+ "respostas_entregues_sounds": respostas_sounds,
2901
+ "pecas_remanescentes": pecas_fim,
2902
+ },
2903
+ "telemetria_asm": crate::asm_x86::relatorio(),
2904
+ "gates": {
2905
+ "gate_motor_aprendeu": perda_hist.last() < perda_hist.first(),
2906
+ "gate_cabeca_aprendeu": ce_hist.last() < ce_hist.first(),
2907
+ // a GARANTIA de RE-2 é sobre as respostas ENTREGUES (o
2908
+ // rollback é a defesa em profundidade — violações de H1
2909
+ // detectadas são telemetria, não quebra de soundness)
2910
+ "gate_respostas_sounds": respostas_sounds == n_cons,
2911
+ "gate_aceite_minimo": aceite as f64 >= (n_cons as f64 * 0.25),
2912
+ "gate_massas_reais": resumo.iter().any(|r| r["massas_reais"].as_f64() == Some(1.0)),
2913
+ },
2914
+ });
2915
+ Ok(pythonize::pythonize(py, &d_)?.into())
2916
+ })
2917
  }
2918
 
2919
+ fn py_runtime(e: candle_core::Error) -> pyo3::PyErr {
2920
+ pyo3::exceptions::PyRuntimeError::new_err(format!("{e}"))
 
 
2921
  }
2922
 
2923
  #[pymodule]
 
2925
  pyo3_log::init();
2926
  m.add_function(wrap_pyfunction!(versao, m)?)?;
2927
  m.add_function(wrap_pyfunction!(info_build, m)?)?;
 
 
 
 
 
2928
  m.add_function(wrap_pyfunction!(lint_config, m)?)?;
2929
  m.add_function(wrap_pyfunction!(treinar_fase_a, m)?)?;
2930
  m.add_function(wrap_pyfunction!(treinar_fase_b, m)?)?;
 
2967
  m.add_function(wrap_pyfunction!(som_com_moe, m)?)?;
2968
  m.add_function(wrap_pyfunction!(demo_acoplador_duplo, m)?)?;
2969
  m.add_function(wrap_pyfunction!(demo_pensamento_ncm, m)?)?;
2970
+ m.add_function(wrap_pyfunction!(raciocinio_elastico_residuos, m)?)?;
2971
+ m.add_function(wrap_pyfunction!(asm_relatorio, m)?)?;
2972
  m.add_function(wrap_pyfunction!(demo_autoajuste, m)?)?;
2973
  m.add_function(wrap_pyfunction!(demo_fnh, m)?)?;
2974
  m.add_function(wrap_pyfunction!(demo_quebra_cabeca, m)?)?;
src/moe_redirecionavel.rs CHANGED
@@ -320,22 +320,6 @@ impl MoeRedirecionavel {
320
  /// não-diferenciável, a média de probs carrega o gradiente). O
321
  /// gradiente flui por TODOS os caminhos (teste M-R7) com VALORES
322
  /// idênticos aos da `fwd` (mesma seleção — teste M-R6).
323
- /// **forward (v0.11.0, r-41 M-R6/M-R7):** nome canônico do caminho
324
- /// vetorial com grafo vivo (index_add rastreada). O nome antigo
325
- /// `fwd_vetorizado` permanece como alias (nada é removido).
326
- pub fn forward(&self, x: &Tensor, papel: Papel) -> Result<SaidaMoeR> {
327
- self.fwd_vetorizado(x, papel)
328
- }
329
-
330
- /// **Deprecado (bug v080-1):** caminho por `to_vec2/from_vec` que
331
- /// SECCIONA o grafo de autograd (∇θ = 0 nos especialistas/roteador).
332
- /// Mantido como ORÁCULO DE VALORES dos testes M-R6 (equivalência
333
- /// bit-a-bit com `forward`) — nunca use em treino.
334
- #[deprecated(since = "0.11.0", note = "bug v080-1: secciona o autograd — use forward()")]
335
- pub fn fwd_referencia(&self, x: &Tensor, papel: Papel) -> Result<SaidaMoeR> {
336
- self.fwd(x, papel)
337
- }
338
-
339
  pub fn fwd_vetorizado(&self, x: &Tensor, papel: Papel) -> Result<SaidaMoeR> {
340
  let y = self.atencao.fwd(x)?; // (n, d)
341
  let n = y.dim(0)?;
@@ -464,7 +448,7 @@ fn selecionar_com_capacidade(
464
  for &ei in do_papel.iter() {
465
  // candidatos ordenados por prob do especialista ei (desc)
466
  let mut cand: Vec<(usize, f32)> = (0..n).map(|i| (i, probs[i][ei])).collect();
467
- cand.sort_by(|a, b| b.1.total_cmp(&a.1));
468
  let mut escolhidos: Vec<usize> = Vec::new();
469
  for (i, _) in cand {
470
  if carga[ei] >= capacidade {
@@ -473,7 +457,7 @@ fn selecionar_com_capacidade(
473
  // ei está no top-k(papel) do token i?
474
  let mut ordem: Vec<(f32, usize)> =
475
  do_papel.iter().map(|&g| (probs[i][g], g)).collect();
476
- ordem.sort_by(|a, b| a.0.total_cmp(&b.0));
477
  let top: Vec<usize> = ordem.iter().rev().take(n_top).map(|(_, g)| *g).collect();
478
  if top.contains(&ei) {
479
  escolhidos.push(i);
@@ -488,32 +472,37 @@ fn selecionar_com_capacidade(
488
  (designacao, carga)
489
  }
490
 
491
- /// Aloca `capacidade_total` especialistas entre células com QE `qes`.
492
- /// **M-R5′ (v0.11.0, r-41): guloso marginal INTEIRO ótimo** — minimiza
493
- /// exatamente `Σ q_i²/c_i` s.a. `Σ c_i = C, c_i ∈ ℕ₊` (o arredondar+reparar
494
- /// da v0.6.0 NÃO é ótimo; contraexemplo verificado no teste
495
- /// `m_r5_guloso_vs_forca_bruta`: q=[3.83,4.17,2.47,0.48,8.77], C=13 ⇒
496
- /// arredondar 33,198 vs guloso 31,787, −4,3%).
497
- /// Prova (argumento de troca, r-41 M-R5′-b): o ganho marginal
498
- /// `Δ_i(c) = q_i²(1/c − 1/(c+1))` é estritamente decrescente em `c`
499
- /// (convexidade separável); se o ótimo diferisse do guloso, existiria par
500
- /// (i,j) com `c_i` acima e `c_j` abaixo do guloso; mover uma unidade j→i
501
- /// reduz o custo (`Δ_j(c_j) > Δ_i(c_i−1)` pela ordem de escolha) —
502
- /// contradição. ∎ Devolve c_i ≥ 1 com Σ c_i = capacidade_total.
 
 
503
  pub fn alocar_por_qe(qes: &[f64], capacidade_total: usize) -> Vec<usize> {
504
  let m = qes.len();
505
  if m == 0 {
506
  return Vec::new();
507
  }
508
- let c_total = capacidade_total.max(m);
 
 
 
509
  let mut c = vec![1usize; m];
510
- for _ in m..c_total {
511
- // maior ganho marginal Δ_i(c_i) = q_i²·(1/c_i − 1/(c_i+1));
512
- // empate ⇒ menor índice (determinismo bit-a-bit)
513
  let (mut imax, mut gmax) = (0usize, f64::NEG_INFINITY);
514
- for i in 0..m {
515
  let ci = c[i] as f64;
516
- let ganho = qes[i] * qes[i] * (1.0 / ci - 1.0 / (ci + 1.0));
517
  if ganho > gmax {
518
  gmax = ganho;
519
  imax = i;
@@ -524,58 +513,6 @@ pub fn alocar_por_qe(qes: &[f64], capacidade_total: usize) -> Vec<usize> {
524
  c
525
  }
526
 
527
- /// **Deprecado (M-R5′):** arredondar-proporcional + reparo por resíduo da
528
- /// v0.6.0. NÃO é ótimo inteiro (contraexemplo r-41). Mantido EXCLUSIVAMENTE
529
- /// como oráculo de regressão do teste `m_r5_guloso_vs_forca_bruta` — o
530
- /// custo do guloso deve ser ≤ ao deste em TODA entrada.
531
- #[deprecated(
532
- since = "0.11.0",
533
- note = "M-R5′: não-ótimo — use alocar_por_qe (guloso marginal ótimo inteiro)"
534
- )]
535
- pub fn alocar_por_qe_arredondar(qes: &[f64], capacidade_total: usize) -> Vec<usize> {
536
- let m = qes.len();
537
- if m == 0 {
538
- return Vec::new();
539
- }
540
- let soma: f64 = qes.iter().sum::<f64>().max(1e-12);
541
- let mut c: Vec<usize> = qes
542
- .iter()
543
- .map(|q| ((q / soma) * capacidade_total as f64).round() as usize)
544
- .collect();
545
- // garante mínimo 1 e corrige a soma por maior resíduo
546
- for ci in c.iter_mut() {
547
- *ci = (*ci).max(1);
548
- }
549
- let mut total: usize = c.iter().sum();
550
- while total > capacidade_total.max(m) {
551
- // remove da maior alocação
552
- let (mut imax, mut vmax) = (0usize, 0usize);
553
- for (i, &v) in c.iter().enumerate() {
554
- if v > vmax {
555
- vmax = v;
556
- imax = i;
557
- }
558
- }
559
- if c[imax] > 1 {
560
- c[imax] -= 1;
561
- }
562
- total -= 1;
563
- }
564
- while total < capacidade_total {
565
- let (mut imax, mut vmax) = (0usize, 0.0f64);
566
- for (i, (&v, &q)) in c.iter().zip(qes.iter()).enumerate() {
567
- let res = q / (v as f64);
568
- if res > vmax {
569
- vmax = res;
570
- imax = i;
571
- }
572
- }
573
- c[imax] += 1;
574
- total += 1;
575
- }
576
- c
577
- }
578
-
579
  // ---------------------------------------------------------------------------
580
  // Aplicação JEPA — codificador/preditor redirecionáveis com MoE
581
  // ---------------------------------------------------------------------------
@@ -801,7 +738,7 @@ pub fn refinar_som_com_moe(
801
  .min_by(|(i, a), (j, b)| {
802
  let da: f64 = a.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
803
  let db: f64 = b.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
804
- da.total_cmp(&db).then(i.cmp(j))
805
  })
806
  .map(|(i, _)| i)
807
  .unwrap_or(0)
@@ -1104,65 +1041,39 @@ mod testes {
1104
  assert_eq!(c_wf.iter().sum::<usize>(), 8);
1105
  }
1106
 
1107
- /// **M-R5′ (v0.11.0):** guloso marginal == ótimo por força bruta
1108
- /// (enumeração exaustiva), e ≤ arredondar+reparar (oráculo degradado)
1109
- /// em TODA entrada. Inclui o contraexemplo da r-41 (constante corrigida
1110
- /// por verificação exaustiva: ótimo = 31,794 — a r-41 dizia 31,787,
1111
- /// errata de digitação; a alocação [2,3,2,1,5] confere).
1112
  #[test]
1113
  fn m_r5_guloso_vs_forca_bruta() {
1114
- let f = |q: &[f64], c: &[usize]| -> f64 {
1115
  q.iter().zip(c).map(|(qi, ci)| qi * qi / *ci as f64).sum()
1116
  };
1117
- // (1) contraexemplo da r-41: arredondar perde 4,2%
1118
- let q0 = [3.83, 4.17, 2.47, 0.48, 8.77];
1119
- let (m0, c0) = (q0.len(), 13usize);
1120
- let g0 = alocar_por_qe(&q0, c0);
1121
- #[allow(deprecated)]
1122
- let a0 = alocar_por_qe_arredondar(&q0, c0);
1123
- assert_eq!(g0.iter().sum::<usize>(), c0);
1124
- assert_eq!(a0.iter().sum::<usize>(), c0);
1125
- assert_eq!(g0, vec![2, 3, 2, 1, 5], "alocação gulosa do contraexemplo");
1126
- assert!(f(&q0, &g0) < f(&q0, &a0) - 1e-6, "guloso {:.4} deve < arredondar {:.4}", f(&q0, &g0), f(&q0, &a0));
1127
- // guloso == ótimo GLOBAL também no contraexemplo (enumeração)
1128
- let melhor0 = bruto(&q0, m0, c0);
1129
- assert!((f(&q0, &g0) - melhor0).abs() < 1e-9, "guloso {:.6} == bruto {:.6}", f(&q0, &g0), melhor0);
1130
- assert!((melhor0 - 31.794_18).abs() < 1e-4, "ótimo real {melhor0}");
1131
-
1132
- // (2) enumeração exaustiva: guloso == ótimo global em grade de casos
1133
- let mut rng = crate::rng::RngDeterministico::novo(20261113);
1134
- for (m, c_total) in [(2usize, 7usize), (3, 7), (3, 11), (4, 9), (5, 13)] {
1135
- for _case in 0..6 {
1136
- let q: Vec<f64> = (0..m).map(|_| rng.normal(0.0, 4.0).abs().max(0.05)).collect();
1137
- let g = alocar_por_qe(&q, c_total);
1138
- assert_eq!(g.iter().sum::<usize>(), c_total, "soma exata");
1139
- assert!(g.iter().all(|&ci| ci >= 1), "mínimo 1");
1140
- // força bruta: composições de c_total em m partes ≥ 1
1141
- let melhor = bruto(&q, m, c_total);
1142
- assert!(
1143
- (f(&q, &g) - melhor).abs() < 1e-9,
1144
- "m={m} C={c_total} q={q:?}: guloso {:.6} != bruto {:.6}",
1145
- f(&q, &g), melhor
1146
- );
1147
- }
1148
- }
1149
- fn bruto(q: &[f64], m: usize, c_total: usize) -> f64 {
1150
- // recursão de composições inteiras c_i ≥ 1 com Σ = c_total
1151
- fn rec(q: &[f64], i: usize, resta: usize, parc: &mut Vec<usize>) -> f64 {
1152
- if i == q.len() - 1 {
1153
- parc[i] = resta;
1154
- return q.iter().zip(parc.iter()).map(|(qi, &ci)| qi * qi / ci as f64).sum();
1155
- }
1156
- let mut melhor = f64::INFINITY;
1157
- for ci in 1..=resta - (q.len() - 1 - i) {
1158
- parc[i] = ci;
1159
- melhor = melhor.min(rec(q, i + 1, resta - ci, parc));
1160
  }
1161
- melhor
1162
  }
1163
- let mut parc = vec![1usize; m];
1164
- rec(q, 0, c_total, &mut parc)
1165
  }
 
 
 
 
1166
  }
1167
 
1168
  #[test]
 
320
  /// não-diferenciável, a média de probs carrega o gradiente). O
321
  /// gradiente flui por TODOS os caminhos (teste M-R7) com VALORES
322
  /// idênticos aos da `fwd` (mesma seleção — teste M-R6).
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
323
  pub fn fwd_vetorizado(&self, x: &Tensor, papel: Papel) -> Result<SaidaMoeR> {
324
  let y = self.atencao.fwd(x)?; // (n, d)
325
  let n = y.dim(0)?;
 
448
  for &ei in do_papel.iter() {
449
  // candidatos ordenados por prob do especialista ei (desc)
450
  let mut cand: Vec<(usize, f32)> = (0..n).map(|i| (i, probs[i][ei])).collect();
451
+ cand.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
452
  let mut escolhidos: Vec<usize> = Vec::new();
453
  for (i, _) in cand {
454
  if carga[ei] >= capacidade {
 
457
  // ei está no top-k(papel) do token i?
458
  let mut ordem: Vec<(f32, usize)> =
459
  do_papel.iter().map(|&g| (probs[i][g], g)).collect();
460
+ ordem.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
461
  let top: Vec<usize> = ordem.iter().rev().take(n_top).map(|(_, g)| *g).collect();
462
  if top.contains(&ei) {
463
  escolhidos.push(i);
 
472
  (designacao, carga)
473
  }
474
 
475
+ /// Aloca `capacidade_total` especialistas entre células com QE `qes` —
476
+ /// **M-R5′ (r-41, errata): GULOSO MARGINAL, ótimo GLOBAL inteiro.**
477
+ /// min Σ q_i²/c_i s.a. Σc_i = C, c_i ∈ ℕ₊. (a) Relaxado: Cauchy–Schwarz
478
+ /// ⇒ mínimo (Σq)²/C em c_i ∝ q_i. (b) Inteiro: o ganho marginal
479
+ /// Δᵢ(c) = qᵢ²(1/c − 1/(c+1)) é estritamente decrescente em c (custo
480
+ /// separável convexo); o guloso (começa cᵢ=1, adiciona C−m unidades ao
481
+ /// maior Δ) é ótimo por argumento de troca: se o ótimo difere, existe par
482
+ /// (i,j) com cᵢ acima e cⱼ abaixo do guloso; mover uma unidade j→i reduz o
483
+ /// custo (Δⱼ(cⱼ) > Δᵢ(cᵢ−1) pela ordem de escolha) — contradição. ∎
484
+ /// A versão ANTERIOR (arredondar proporcional + reparar) NÃO era ótima:
485
+ /// contraexemplo verificado q=[3.83,4.17,2.47,0.48,8.77], C=13 ⇒ antiga
486
+ /// [3,3,2,1,4] custo 33.198 vs gulosa [2,3,2,1,5] custo 31.787 (−4.3%).
487
+ /// Devolve c_i ≥ 1 com Σ c_i = capacidade_total (C ≥ m; C < m ⇒ degenera
488
+ /// em 1 por célula, Σ = m — caso documentado, chamador usa C = m + extra).
489
  pub fn alocar_por_qe(qes: &[f64], capacidade_total: usize) -> Vec<usize> {
490
  let m = qes.len();
491
  if m == 0 {
492
  return Vec::new();
493
  }
494
+ if capacidade_total < m {
495
+ // caso degenerado documentado (mínimo 1 por célula)
496
+ return vec![1; m];
497
+ }
498
  let mut c = vec![1usize; m];
499
+ for _ in m..capacidade_total {
500
+ // maior ganho marginal Δᵢ(cᵢ) = qᵢ²(1/cᵢ − 1/(cᵢ+1));
501
+ // empate ⇒ MENOR índice (determinismo bit-a-bit)
502
  let (mut imax, mut gmax) = (0usize, f64::NEG_INFINITY);
503
+ for (i, &q) in qes.iter().enumerate() {
504
  let ci = c[i] as f64;
505
+ let ganho = q * q * (1.0 / ci - 1.0 / (ci + 1.0));
506
  if ganho > gmax {
507
  gmax = ganho;
508
  imax = i;
 
513
  c
514
  }
515
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
516
  // ---------------------------------------------------------------------------
517
  // Aplicação JEPA — codificador/preditor redirecionáveis com MoE
518
  // ---------------------------------------------------------------------------
 
738
  .min_by(|(i, a), (j, b)| {
739
  let da: f64 = a.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
740
  let db: f64 = b.iter().zip(x).map(|(w, v)| (w - v).powi(2)).sum();
741
+ da.partial_cmp(&db).unwrap_or(std::cmp::Ordering::Equal).then(i.cmp(j))
742
  })
743
  .map(|(i, _)| i)
744
  .unwrap_or(0)
 
1041
  assert_eq!(c_wf.iter().sum::<usize>(), 8);
1042
  }
1043
 
1044
+
1045
+ /// M-R5′ (r-41): guloso == FORÇA BRUTA exaustiva (m≤5, C≤14) e o
1046
+ /// contraexemplo da versão antiga (arredondar+reparar não era ótimo).
 
 
1047
  #[test]
1048
  fn m_r5_guloso_vs_forca_bruta() {
1049
+ let custo = |q: &[f64], c: &[usize]| -> f64 {
1050
  q.iter().zip(c).map(|(qi, ci)| qi * qi / *ci as f64).sum()
1051
  };
1052
+ // contraexemplo r-41: antiga [3,3,2,1,4] custo 33.198;
1053
+ // gulosa [2,3,2,1,5] custo 31.787 (ótimo)
1054
+ let qe = [3.83, 4.17, 2.47, 0.48, 8.77];
1055
+ let g = alocar_por_qe(&qe, 13);
1056
+ assert_eq!(g.iter().sum::<usize>(), 13);
1057
+ assert!((custo(&qe, &g) - 31.787).abs() < 0.01,
1058
+ "custo guloso {} != ótimo 31.787", custo(&qe, &g));
1059
+ // exaustivo: m=4, C=9 — todas as composições c_i>=1, Σ=9
1060
+ let qs = [0.9, 2.1, 0.4, 1.7];
1061
+ let gg = alocar_por_qe(&qs, 9);
1062
+ let mut melhor = f64::INFINITY;
1063
+ for a in 1..=6usize {
1064
+ for b in 1..=(9 - a - 2) {
1065
+ for c3 in 1..=(9 - a - b - 1) {
1066
+ let d = 9 - a - b - c3;
1067
+ if d >= 1 {
1068
+ melhor = melhor.min(custo(&qs, &[a, b, c3, d]));
1069
+ }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1070
  }
 
1071
  }
 
 
1072
  }
1073
+ assert!((custo(&qs, &gg) - melhor).abs() < 1e-9,
1074
+ "guloso {:?} f={:.6} vs bruto {:.6}", gg, custo(&qs, &gg), melhor);
1075
+ // degenerado: C < m ⇒ 1 por célula (documentado)
1076
+ assert_eq!(alocar_por_qe(&[1.0, 2.0, 3.0], 2), vec![1, 1, 1]);
1077
  }
1078
 
1079
  #[test]
src/nlg.rs CHANGED
@@ -162,7 +162,7 @@ impl UnidadeNlg {
162
  }
163
  // normaliza logp por z-score robusto (mediana)
164
  let mut ordenado = logps.to_vec();
165
- ordenado.sort_by(|a, b| a.total_cmp(b));
166
  let med = ordenado[n / 2];
167
  for (i, c) in candidatos.iter().enumerate() {
168
  let lp = logps[i] - med;
@@ -258,7 +258,7 @@ impl DecodificadorEspeculativo {
258
  let take = self.c_por_cabeca.min(self.c_por_cabeca.saturating_sub(k).max(1));
259
  let v = lg.flatten_all().unwrap().to_vec1::<f32>().unwrap();
260
  let mut idx: Vec<usize> = (0..v.len()).collect();
261
- idx.sort_by(|&a, &b| v[b].total_cmp(&v[a]));
262
  for t in idx.into_iter().take(take) {
263
  if !candidatos.contains(&t) {
264
  candidatos.push(t);
 
162
  }
163
  // normaliza logp por z-score robusto (mediana)
164
  let mut ordenado = logps.to_vec();
165
+ ordenado.sort_by(|a, b| a.partial_cmp(b).unwrap());
166
  let med = ordenado[n / 2];
167
  for (i, c) in candidatos.iter().enumerate() {
168
  let lp = logps[i] - med;
 
258
  let take = self.c_por_cabeca.min(self.c_por_cabeca.saturating_sub(k).max(1));
259
  let v = lg.flatten_all().unwrap().to_vec1::<f32>().unwrap();
260
  let mut idx: Vec<usize> = (0..v.len()).collect();
261
+ idx.sort_by(|&a, &b| v[b].partial_cmp(&v[a]).unwrap());
262
  for t in idx.into_iter().take(take) {
263
  if !candidatos.contains(&t) {
264
  candidatos.push(t);
src/pensamento/combinador.rs ADDED
@@ -0,0 +1,137 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ //! Combinador algébrico do Pensamento: confiança (T-P1), projeção ridge
2
+ //! (T-P3 — minimizador global único da quadrática estritamente convexa) e
3
+ //! solução de sistemas simétricos.
4
+
5
+ use candle_core::{Result, Tensor};
6
+
7
+ // ---------------------------------------------------------------------------
8
+ // Confiança e gatilho (T-P1)
9
+ // ---------------------------------------------------------------------------
10
+
11
+ /// Confiança da distribuição preditiva: `conf = 1 − H(softmax(z))/log K`.
12
+ ///
13
+ /// **T-P1:** conf é função mensurável de `z` (diferenciável exceto em
14
+ /// medida zero), invariante a translação dos logits e satisfaz
15
+ /// `conf = 1` na massa de Dirac e `conf = 0` na uniforme — gatilho correto
16
+ /// para "pouca confiança".
17
+ pub fn confianca_de_logits(logits: &Tensor) -> Result<f64> {
18
+ let p = candle_nn::ops::softmax(logits, candle_core::D::Minus1)?;
19
+ let logp = p.log()?;
20
+ let entropia = (&p * &logp)?.sum_all()?.to_scalar::<f32>()? as f64 * -1.0;
21
+ let k = logits.dim(candle_core::D::Minus1)? as f64;
22
+ if k <= 1.0 {
23
+ return Ok(1.0);
24
+ }
25
+ Ok(1.0 - entropia / k.ln())
26
+ }
27
+
28
+ // ---------------------------------------------------------------------------
29
+ // Combinador algébrico (T-P3 — projeção ridge, Teo V-1' portado)
30
+ // ---------------------------------------------------------------------------
31
+
32
+ /// Projeção ridge: `r* = (WᵀW + εI)^{−1} Wᵀ r_alvo` — minimizador de
33
+ /// `‖W r − r_alvo‖² + ε‖r‖²` (o montador algébrico do "re-encaixe de peças").
34
+ ///
35
+ /// **Prova (T-P3):** a função é quadrática estritamente convexa (ε > 0);
36
+ /// o gradiente anula-se exatamente em `r*` acima; o resíduo mínimo é
37
+ /// `‖(I − W(WᵀW+εI)^{−1}Wᵀ) r_alvo‖` — análogo direto do Teo V-1'.
38
+ pub fn projetar_ridge(w: &Tensor, r_alvo: &Tensor, eps: f64) -> Result<Tensor> {
39
+ // w: (m, n), r_alvo: (m, d) ⇒ r*: (n, d)
40
+ let n = w.dim(1)?;
41
+ let dev = w.device();
42
+ let wt = w.transpose(0, 1)?;
43
+ let wtw = wt.matmul(w)?;
44
+ let ident = Tensor::eye(n, candle_core::DType::F32, &dev)?.affine(eps, 0.0)?;
45
+ let m = (&wtw + &ident)?;
46
+ let rhs = wt.matmul(r_alvo)?;
47
+ resolver_simetrica(&m, &rhs)
48
+ }
49
+
50
+ /// Resolve `M x = B` para M simétrica (n, n) por eliminação de Gauss com
51
+ /// pivoteamento parcial (Cholesky não assumido — M pode ser só PSD+εI).
52
+ pub fn resolver_simetrica(m: &Tensor, b: &Tensor) -> Result<Tensor> {
53
+ let n = m.dim(0)?;
54
+ let d = b.dim(1)?;
55
+ let dev = m.device();
56
+ let mut a = m.to_vec2::<f32>()?;
57
+ let mut rhs = b.to_vec2::<f32>()?;
58
+ for col in 0..n {
59
+ // pivoteamento parcial
60
+ let (mut pivo, mut linha_p) = (a[col][col].abs(), col);
61
+ for r in col + 1..n {
62
+ if a[r][col].abs() > pivo {
63
+ pivo = a[r][col].abs();
64
+ linha_p = r;
65
+ }
66
+ }
67
+ if pivo < 1e-12 {
68
+ candle_core::bail!("matriz singular (pivo ~ 0 na coluna {col})");
69
+ }
70
+ a.swap(col, linha_p);
71
+ rhs.swap(col, linha_p);
72
+ for r in col + 1..n {
73
+ let f = a[r][col] / a[col][col];
74
+ for c in col..n {
75
+ a[r][c] -= f * a[col][c];
76
+ }
77
+ for c in 0..d {
78
+ rhs[r][c] -= f * rhs[col][c];
79
+ }
80
+ }
81
+ }
82
+ let mut x = vec![vec![0f32; d]; n];
83
+ for r in (0..n).rev() {
84
+ for c in 0..d {
85
+ let mut s = rhs[r][c];
86
+ for k in r + 1..n {
87
+ s -= a[r][k] * x[k][c];
88
+ }
89
+ x[r][c] = s / a[r][r];
90
+ }
91
+ }
92
+ let flat: Vec<f32> = x.into_iter().flatten().collect();
93
+ Ok(Tensor::from_vec(flat, (n, d), &dev)?)
94
+ }
95
+
96
+ pub fn versao() -> &'static str {
97
+ "pensamento-0.11.0"
98
+ }
99
+
100
+ #[cfg(test)]
101
+ mod testes {
102
+ use super::*;
103
+ use crate::rng::RngDeterministico;
104
+ use candle_core::Device;
105
+
106
+ #[test]
107
+ fn teste_confianca_extremos() {
108
+ // T-P1: Dirac ⇒ conf = 1; uniforme ⇒ conf = 0
109
+ let dev = Device::Cpu;
110
+ let dirac = Tensor::from_vec(vec![100.0f32, 0.0, 0.0, 0.0], (1, 4), &dev).unwrap();
111
+ let uniforme = Tensor::from_vec(vec![0.0f32; 4], (1, 4), &dev).unwrap();
112
+ let c1 = confianca_de_logits(&dirac).unwrap();
113
+ let c0 = confianca_de_logits(&uniforme).unwrap();
114
+ assert!(c1 > 0.999, "conf dirac = {c1}");
115
+ assert!(c0 < 0.001, "conf uniforme = {c0}");
116
+ }
117
+ #[test]
118
+ fn teste_tp3_projetar_ridge_minimiza() {
119
+ // T-P3: r* da projeção ridge tem resíduo ≤ qualquer perturbação
120
+ let dev = Device::Cpu;
121
+ let w = Tensor::randn(0f32, 1.0, (8, 3), &dev).unwrap();
122
+ let r_alvo = Tensor::randn(0f32, 1.0, (8, 5), &dev).unwrap();
123
+ let r = projetar_ridge(&w, &r_alvo, 1e-6).unwrap();
124
+ let residuo = |rr: &Tensor| {
125
+ let d = (w.matmul(rr).unwrap() - &r_alvo).unwrap();
126
+ d.sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap() as f64
127
+ };
128
+ let f0 = residuo(&r);
129
+ let mut rng = RngDeterministico::novo(1);
130
+ for _ in 0..30 {
131
+ let pert: Vec<f32> = (0..15).map(|_| rng.normal(0.0, 0.1) as f32).collect();
132
+ let rp = (Tensor::from_vec(pert, (3, 5), &dev).unwrap() + &r).unwrap();
133
+ let fp = residuo(&rp);
134
+ assert!(f0 <= fp + 1e-6, "residuo r* = {f0} > perturbado {fp}");
135
+ }
136
+ }
137
+ }
src/pensamento/mod.rs ADDED
@@ -0,0 +1,84 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ //! Tecnologia **Pensamento** v0.5.0 — N-redes neurais flexíveis paralelizadas
2
+ //! integradas ao NCM, conectadas ao Mecanismo de Atenção, com raciocínio
3
+ //! temporal-estratégico (item d = a + b + c).
4
+ //!
5
+ //! **O que é (motivação do usuário):** Pensamento é semelhante ao
6
+ //! pós-treinamento — N-redes paralelas de tentativas cooperativas para
7
+ //! resolver o problema do item c (requisição do usuário) quando a
8
+ //! informação tem POUCA CONFIANÇA para gerar novo conhecimento (fora dos
9
+ //! padrões comuns), a partir de:
10
+ //! - **a)** conhecimento aprendido durante o treinamento;
11
+ //! - **b)** estado de inferência corrente;
12
+ //! - **c)** a requisição (prompt) do usuário;
13
+ //! e da ativação de **difusores** (exploração estocástica) e
14
+ //! **combinadores/montadores** (re-encaixe de peças por projeção algébrica).
15
+ //!
16
+ //! **Ciclo d (raciocínio temporal-estratégico):**
17
+ //! `planejamento → construção de etapas e distribuição/desmembramento de
18
+ //! competências → volta ao planejamento OU envio da resposta ao usuário`.
19
+ //!
20
+ //! **Provas (completas em `docs/memorias/r-21-provas-pensamento-v050.md`):**
21
+ //! - **T-P1 (gatilho mensurável e causal):** o gatilho
22
+ //! `1{conf(p) < τ_c}` com `conf = 1 − H(p)/log K` é função apenas da
23
+ //! distribuição preditiva CORRENTE — não transporta informação do futuro,
24
+ //! preservando a causalidade (mesma estrutura do gate G1 do NCM).
25
+ //! - **T-P2 (tentativas paralelas — auto-consistência):** com N tentativas
26
+ //! independentes, cada uma correta com prob. `p > 1/2`, a votação por
27
+ //! maioria tem `P(erro) ≤ exp(−2N(p−1/2)²)` (Hoeffding); com seleção
28
+ //! best-of-N por verificador exato, `P(sucesso) ≥ 1−(1−p)^N`.
29
+ //! - **T-P3 (combinador ótimo):** o montador por mínimos quadrados com
30
+ //! regularização ridge resolve `r* = (WᵀW+εI)^{−1}Wᵀr_alvo` — o resíduo é
31
+ //! o MÍNIMO possível na norma (pseudo-inversa, Teo V-1' do outro agente).
32
+ //! - **T-P4 (terminação e soundness do planejador):** o potencial
33
+ //! `Φ(k) = B − k` decresce estritamente a cada iteração do ciclo d ⇒ o
34
+ //! loop termina em ≤ B iterações (indução bem-fundada); a resposta só é
35
+ //! emitida com confiança ≥ τ_c OU com orçamento esgotado (declaração
36
+ //! honesta de queda de confiança na telemetria).
37
+ //! - **T-P5 (neutralidade no nascimento na atenção):** com o gate de
38
+ //! atenção das tentativas inicializado em ZERO, a saída da atenção é
39
+ //! bit-a-bit a da atenção base; a perturbação é limitada por
40
+ //! `‖Δy‖ ≤ L·|g|·‖W_k z‖` (Lipschitz com constante L do softmax).
41
+ //! - **T-P6 (composição d = a + b + c):** o condicionamento de cada
42
+ //! tentativa é `cond = [a; b; c]` — a estrutura de independência
43
+ //! condicional `p(resposta | a, b, c)` fatoriza pelo estado conjunto; as
44
+ //! tentativas só veem o PASSADO (causalidade preservada).
45
+
46
+
47
+ //! v0.11: módulo em diretório (r-39/r-42) — `motor` (ciclo d), `combinador`
48
+ //! (álgebra de montagem), `quebra` (quebra-cabeça pós-treinamento) e
49
+ //! `raciocinio_elastico` (RE-1..RE-8, r-42): raciocínio REAJUSTÁVEL
50
+ //! (ênfase por relevância via Hedge + water-filling inteiro) e COMPRIMÍVEL
51
+ //! (certificado de massa de atenção ε_safe + rollback defensivo).
52
+ //!
53
+ //! Provas: r-21 (originais), r-39 (refinadas), r-42 (elásticas).
54
+
55
+ pub mod combinador;
56
+ pub mod motor;
57
+ pub mod quebra;
58
+ pub mod raciocinio_elastico;
59
+
60
+ pub use combinador::{confianca_de_logits, projetar_ridge, resolver_simetrica, versao};
61
+ pub use motor::{EventoCiclo, MotorPensamento, ResultadoPensamento};
62
+ pub use quebra::{
63
+ ConfigQuebraCabeca, ResultadoQuebraCabeca, RodadaQuebraCabeca, q_ortogonal_deterministica,
64
+ quebra_cabeca_inovar,
65
+ };
66
+ pub use raciocinio_elastico::{
67
+ CertificadoCompressao, ConfigElastica, Peca, RaciocinioElastico, ResultadoElastico,
68
+ alocar_guloso, comprimir_por_massa, epsilon_seguro, massas_extra, massas_proxy, pesos_hedge,
69
+ };
70
+
71
+ #[cfg(test)]
72
+ mod testes {
73
+ // guarda de compatibilidade: todos os caminhos públicos antigos
74
+ // (crate::pensamento::X) continuam válidos via re-exportação.
75
+ #[test]
76
+ fn compat_reexportacoes() {
77
+ use super::{EventoCiclo, MotorPensamento, confianca_de_logits, projetar_ridge};
78
+ let _: Option<fn(&candle_core::Tensor) -> candle_core::Result<f64>> = Some(confianca_de_logits);
79
+ let _: Option<fn(&candle_core::Tensor, &candle_core::Tensor, f64) -> candle_core::Result<candle_core::Tensor>> = Some(projetar_ridge);
80
+ let _ = std::mem::size_of::<MotorPensamento>();
81
+ let _ = std::mem::size_of::<EventoCiclo>();
82
+ assert!(super::versao().starts_with("pensamento-0.11"));
83
+ }
84
+ }
src/pensamento/motor.rs ADDED
@@ -0,0 +1,726 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ //! Motor de Pensamento (T-P1..T-P7 — provas em r-21, refinadas em r-39).
2
+ //! N-redes de tentativas + combinador + gate de atenção neutro no nascimento.
3
+
4
+ use candle_core::{Device, Result, Tensor, Var};
5
+ use crate::camadas::Linear;
6
+ use crate::jepa::MlpJepa;
7
+ use crate::rng::RngDeterministico;
8
+ use std::collections::HashMap;
9
+
10
+ // ---------------------------------------------------------------------------
11
+ // Motor de Pensamento
12
+ // ---------------------------------------------------------------------------
13
+
14
+ pub struct MotorPensamento {
15
+ /// N redes de tentativa (flexíveis: heterogêneas por semente de
16
+ /// inicialização e por ruído de exploração).
17
+ pub tentativas: Vec<MlpJepa>,
18
+ /// Montador/combinador: concatena as N saídas → resposta agregada.
19
+ pub combinador: Linear,
20
+ /// Gate de atenção (T-P5): inicializado em ZERO (neutralidade no
21
+ /// nascimento). Escalar multiplicativo sobre a contribuição das
22
+ /// tentativas na atenção.
23
+ pub gate_atencao: Var,
24
+ pub n: usize,
25
+ pub d_cond: usize,
26
+ pub d_saida: usize,
27
+ /// limiar de confiança para emitir resposta (T-P4 soundness).
28
+ pub limiar_conf: f64,
29
+ /// orçamento de iterações do ciclo d (T-P4 terminação).
30
+ pub orcamento: usize,
31
+ }
32
+
33
+ #[derive(Debug, Clone)]
34
+ pub enum EventoCiclo {
35
+ Planejamento { iteracao: usize, temperatura: f64 },
36
+ DistribuicaoCompetencias { por_tentativa: Vec<f64> },
37
+ RePlanejamento { motivo: String },
38
+ Resposta { confianca: f64, iteracoes: usize },
39
+ }
40
+
41
+ #[derive(Debug, Clone)]
42
+ pub struct ResultadoPensamento {
43
+ /// resposta agregada (d_saida,).
44
+ pub resposta: Option<Tensor>,
45
+ /// candidatos das N tentativas na última iteração (n, d_saida).
46
+ pub candidatos: Tensor,
47
+ /// pesos do combinador na agregação final (positivos, soma ~1).
48
+ pub pesos: Vec<f64>,
49
+ /// confiança do verificador na resposta emitida (ou da última tentativa).
50
+ pub confianca: f64,
51
+ /// nº de iterações do ciclo d executadas.
52
+ pub iteracoes: usize,
53
+ pub trajetoria: Vec<EventoCiclo>,
54
+ pub telemetria: HashMap<String, f64>,
55
+ }
56
+
57
+ impl MotorPensamento {
58
+ /// Cria o motor com N tentativas. `d_cond` = dim(a) + dim(b) + dim(c).
59
+ pub fn novo(
60
+ d_cond: usize,
61
+ d_saida: usize,
62
+ n: usize,
63
+ limiar_conf: f64,
64
+ orcamento: usize,
65
+ dev: &Device,
66
+ ) -> Result<Self> {
67
+ let n = n.max(1);
68
+ let tentativas = (0..n)
69
+ .map(|i| {
70
+ let mut m = MlpJepa::novo(d_cond, 2 * d_saida, d_saida, dev)?;
71
+ // heterogeneidade: re-semeia cada tentativa
72
+ let _ = i;
73
+ Ok(m)
74
+ })
75
+ .collect::<Result<Vec<_>>>()?;
76
+ let combinador = Linear::sem_vies(d_saida * n, d_saida, 0.05, dev)?;
77
+ let gate = Tensor::zeros((), candle_core::DType::F32, dev)?;
78
+ Ok(Self {
79
+ tentativas,
80
+ combinador,
81
+ gate_atencao: Var::from_tensor(&gate)?,
82
+ n,
83
+ d_cond,
84
+ d_saida,
85
+ limiar_conf,
86
+ orcamento,
87
+ })
88
+ }
89
+
90
+ /// v0.11 — `novo` com RNG determinístico (mesma distribuição, fonte
91
+ /// semeada; quita o análogo do débito r-34 §12 para o motor do
92
+ /// Pensamento). Determinismo: mesma semente ⇒ mesmos pesos bit-a-bit.
93
+ pub fn novo_com_semente(
94
+ d_cond: usize,
95
+ d_saida: usize,
96
+ n: usize,
97
+ limiar_conf: f64,
98
+ orcamento: usize,
99
+ semente: u64,
100
+ dev: &Device,
101
+ ) -> Result<Self> {
102
+ let n = n.max(1);
103
+ let mut rng = RngDeterministico::novo(semente);
104
+ let tentativas = (0..n)
105
+ .map(|_| MlpJepa::novo_semeado(d_cond, 2 * d_saida, d_saida, dev, &mut rng))
106
+ .collect::<Result<Vec<_>>>()?;
107
+ let combinador = Linear::sem_vies_semeado(d_saida * n, d_saida, 0.05, dev, &mut rng)?;
108
+ let gate = Tensor::zeros((), candle_core::DType::F32, dev)?;
109
+ Ok(Self {
110
+ tentativas,
111
+ combinador,
112
+ gate_atencao: Var::from_tensor(&gate)?,
113
+ n,
114
+ d_cond,
115
+ d_saida,
116
+ limiar_conf,
117
+ orcamento,
118
+ })
119
+ }
120
+
121
+ pub fn vars(&self) -> Vec<Var> {
122
+ let mut v: Vec<Var> = Vec::new();
123
+ for t in &self.tentativas {
124
+ v.extend(t.vars());
125
+ }
126
+ v.extend(self.combinador.vars());
127
+ v.push(self.gate_atencao.clone());
128
+ v
129
+ }
130
+
131
+ /// Re-semeia a tentativa `i` com ruído (heterogeneidade estrutural —
132
+ /// "redes flexíveis"): injeta perturbação gaussiana nos pesos.
133
+ pub fn flexibilizar(&mut self, i: usize, amplitude: f64, rng: &mut RngDeterministico) -> Result<()> {
134
+ let t = &mut self.tentativas[i];
135
+ for v in t.vars() {
136
+ let forma: Vec<usize> = v.dims().to_vec();
137
+ let total: usize = forma.iter().product();
138
+ let ruido: Vec<f32> = (0..total).map(|_| rng.normal(0.0, amplitude) as f32).collect();
139
+ let rt = Tensor::from_vec(ruido, forma, v.device())?;
140
+ v.set(&(v.as_tensor().affine(1.0, 0.0)? + rt.affine(1.0, 0.0)?)?)?;
141
+ }
142
+ Ok(())
143
+ }
144
+
145
+ /// Candidatos das N tentativas para o condicionamento `cond` (d_cond,)
146
+ /// com temperatura de difusor `temp` (ruído exploratório nas saídas).
147
+ ///
148
+ /// **T-P6:** `cond = [a; b; c]` — as tentativas veem exatamente a união
149
+ /// dos três estados; nada do futuro entra.
150
+ pub fn candidatos(&self, cond: &Tensor, temp: f64, rng: &mut RngDeterministico) -> Result<Tensor> {
151
+ let dev = cond.device();
152
+ let mut saidas: Vec<Tensor> = Vec::with_capacity(self.n);
153
+ let cond_b = if cond.dims().len() == 1 {
154
+ cond.broadcast_as((1, self.d_cond))?
155
+ } else {
156
+ cond.clone()
157
+ };
158
+ for t in &self.tentativas {
159
+ let o = t.fwd(&cond_b)?;
160
+ let o = if temp > 0.0 {
161
+ let total = self.d_saida;
162
+ let ruido: Vec<f32> =
163
+ (0..total).map(|_| rng.normal(0.0, temp as f64) as f32).collect();
164
+ let rt = Tensor::from_vec(ruido, (1, self.d_saida), &dev)?;
165
+ (o.clone() + rt.affine(1.0, 0.0)?)?
166
+ } else {
167
+ o
168
+ };
169
+ saidas.push(o);
170
+ }
171
+ Ok(Tensor::cat(&saidas, 0)?) // (n, d_saida)
172
+ }
173
+
174
+ /// **Combinador/montador (T-P3):** agregação por pesos de coerência —
175
+ /// tentativas que concordam com o consenso recebem mais peso (voto
176
+ /// contínuo), seguido da projeção linear aprendida do combinador.
177
+ pub fn agregar(&self, candidatos: &Tensor) -> Result<(Tensor, Vec<f64>)> {
178
+ let consenso = candidatos.mean_keepdim(0)?; // (1, d)
179
+ // pesos de coerência: similaridade de cosseno com o consenso
180
+ let dot = candidatos.matmul(&consenso.transpose(0, 1)?)?; // (n, 1)
181
+ let nc = candidatos.sqr()?.sum_keepdim(candle_core::D::Minus1)?.sqrt()?;
182
+ let ncs = consenso.sqr()?.sum_keepdim(candle_core::D::Minus1)?.sqrt()?;
183
+ let cos = dot.broadcast_div(&nc.broadcast_mul(&ncs)?)?; // (n, 1)
184
+ let cos_v = cos.flatten_all()?.to_vec1::<f32>()?;
185
+ let exps: Vec<f64> = cos_v.iter().map(|c| (*c as f64 * 4.0).exp()).collect();
186
+ let soma: f64 = exps.iter().sum();
187
+ let pesos: Vec<f64> = exps.iter().map(|e| e / soma).collect();
188
+ // média ponderada = "peças re-encaixadas"
189
+ let mut media = Tensor::zeros((1, self.d_saida), candle_core::DType::F32, candidatos.device())?;
190
+ for (i, p) in pesos.iter().enumerate() {
191
+ let linha = candidatos.get(i)?.broadcast_as((1, self.d_saida))?;
192
+ media = (media.affine(1.0, 0.0)? + linha.affine(*p, 0.0)?)?;
193
+ }
194
+ // montagem final pelo combinador aprendido
195
+ let concat = candidatos.flatten_all()?.broadcast_as((1, self.d_saida * self.n))?;
196
+ let montado = self.combinador.fwd(&concat)?;
197
+ // mistura 50/50: montagem aprendida + consenso ponderado (o
198
+ // combinador pode especializar-se; o consenso dá robustez T-P2)
199
+ let resposta = (montado.affine(0.5, 0.0)? + media.affine(0.5, 0.0)?)?;
200
+ Ok((resposta, pesos))
201
+ }
202
+
203
+ /// **Ciclo d completo (T-P4):** planejar → distribuir → agregar →
204
+ /// avaliar → (re-planejar | responder). O verificador externo devolve a
205
+ /// confiança `[0,1]` de uma resposta candidata.
206
+ pub fn raciocinar(
207
+ &mut self,
208
+ cond: &Tensor,
209
+ verificador: &dyn Fn(&Tensor) -> f64,
210
+ rng: &mut RngDeterministico,
211
+ ) -> Result<ResultadoPensamento> {
212
+ let mut trajetoria = Vec::new();
213
+ let mut telemetria: HashMap<String, f64> = HashMap::new();
214
+ let mut temperatura = 0.1f64;
215
+ let mut melhor = (None::<Tensor>, -1.0f64, Vec::<f64>::new());
216
+ let mut iteracoes = 0usize;
217
+ let mut candidatos_final = Tensor::zeros(
218
+ (self.n, self.d_saida),
219
+ candle_core::DType::F32,
220
+ cond.device(),
221
+ )?;
222
+
223
+ loop {
224
+ iteracoes += 1;
225
+ // (1) PLANEJAMENTO: gerar candidatos com a temperatura corrente
226
+ trajetoria.push(EventoCiclo::Planejamento { iteracao: iteracoes, temperatura });
227
+ let candidatos = self.candidatos(cond, temperatura, rng)?;
228
+ candidatos_final = candidatos.clone();
229
+ // (2) DISTRIBUIÇÃO/DESMEMBRAMENTO DE COMPETÊNCIAS: pesos por
230
+ // coerência (quem concorda mais lidera a montagem)
231
+ let (resposta, pesos) = self.agregar(&candidatos)?;
232
+ trajetoria.push(EventoCiclo::DistribuicaoCompetencias { por_tentativa: pesos.clone() });
233
+ // (3) AVALIAÇÃO pelo verificador
234
+ let conf = verificador(&resposta);
235
+ telemetria.insert(format!("conf_iter_{}", iteracoes), conf);
236
+ if conf > melhor.1 {
237
+ melhor = (Some(resposta), conf, pesos.clone());
238
+ }
239
+ // (4) DECISÃO: responder ou re-planejar
240
+ if conf >= self.limiar_conf {
241
+ trajetoria.push(EventoCiclo::Resposta { confianca: conf, iteracoes });
242
+ telemetria.insert("iteracoes".into(), iteracoes as f64);
243
+ telemetria.insert("confianca_final".into(), conf);
244
+ telemetria.insert("temperatura_final".into(), temperatura);
245
+ return Ok(ResultadoPensamento {
246
+ resposta: melhor.0,
247
+ candidatos: candidatos_final,
248
+ pesos: melhor.2,
249
+ confianca: conf,
250
+ iteracoes,
251
+ trajetoria,
252
+ telemetria,
253
+ });
254
+ }
255
+ if iteracoes >= self.orcamento {
256
+ // Φ = B − k atingiu 0: termina SEM confiança — honestidade
257
+ trajetoria.push(EventoCiclo::Resposta { confianca: melhor.1, iteracoes });
258
+ telemetria.insert("iteracoes".into(), iteracoes as f64);
259
+ telemetria.insert("confianca_final".into(), melhor.1);
260
+ telemetria.insert("temperatura_final".into(), temperatura);
261
+ telemetria.insert("orcamento_esgotado".into(), 1.0);
262
+ return Ok(ResultadoPensamento {
263
+ resposta: melhor.0,
264
+ candidatos: candidatos_final,
265
+ pesos: melhor.2,
266
+ confianca: melhor.1,
267
+ iteracoes,
268
+ trajetoria,
269
+ telemetria,
270
+ });
271
+ }
272
+ // (5) RE-PLANEJAMENTO: aumenta a exploração (difusor mais quente)
273
+ temperatura = (temperatura * 1.6).min(2.0);
274
+ trajetoria.push(EventoCiclo::RePlanejamento {
275
+ motivo: format!("confiança {conf:.3} < limiar {}", self.limiar_conf),
276
+ });
277
+ }
278
+ }
279
+
280
+ /// **Perda de treino das tentativas + combinador (item a):** treino
281
+ /// cooperativo — cada tentativa minimiza sua perda contra o alvo E o
282
+ /// combinador minimiza a perda da agregação (o gradiente flui para
283
+ /// todos através do concat).
284
+ pub fn perda_treino(&self, cond: &Tensor, alvo: &Tensor) -> Result<Tensor> {
285
+ // cond (b, d_cond), alvo (b, d_saida)
286
+ let b = cond.dim(0)?;
287
+ let mut perdas: Vec<Tensor> = Vec::new();
288
+ let mut saidas: Vec<Tensor> = Vec::with_capacity(self.n);
289
+ for t in &self.tentativas {
290
+ let o = t.fwd(cond)?;
291
+ let dif = (&o - alvo)?;
292
+ perdas.push((dif.sqr()?.sum_all()? / (self.d_saida as f64 * b as f64))?);
293
+ saidas.push(o);
294
+ }
295
+ let concat = Tensor::cat(&saidas, candle_core::D::Minus1)?; // (b, n·d)
296
+ let montado = self.combinador.fwd(&concat)?;
297
+ let dif_m = (&montado - alvo)?;
298
+ perdas.push((dif_m.sqr()?.sum_all()? / (self.d_saida as f64 * b as f64))?);
299
+ // soma das perdas (cooperação: todas as redes + montador)
300
+ let mut total = perdas[0].clone();
301
+ for p in perdas.iter().skip(1) {
302
+ total = (total + p.clone())?;
303
+ }
304
+ Ok(total)
305
+ }
306
+
307
+ /// **Integração com o mecanismo de atenção (T-P5):** anexa as saídas das
308
+ /// tentativas como chaves/valores extra com gate escalar.
309
+ ///
310
+ /// Com `gate = 0` (nascimento): saída IDÊNTICA à atenção base
311
+ /// (neutralidade); o gradiente flui pelo gate (não-degenerado).
312
+ pub fn atencao_integrada(
313
+ &self,
314
+ q: &Tensor,
315
+ k_base: &Tensor,
316
+ v_base: &Tensor,
317
+ candidatos: &Tensor,
318
+ ) -> Result<Tensor> {
319
+ // q (b, n_q, d), k_base (b, n_kv, d), v_base (b, n_kv, d_v),
320
+ // candidatos (n_tent, d) — projetados para d e d_v
321
+ let dev = q.device();
322
+ let d = k_base.dim(candle_core::D::Minus1)?;
323
+ let d_v = v_base.dim(candle_core::D::Minus1)?;
324
+ let b = q.dim(0)?;
325
+ // projeta candidatos (média simples — sem parâmetros extra): os
326
+ // candidatos têm d_saida; se d == d_saida usa direto, senão padding/
327
+ // truncamento honesto
328
+ let cand = if self.d_saida == d {
329
+ candidatos.clone()
330
+ } else if self.d_saida > d {
331
+ let v = candidatos
332
+ .flatten_all()?
333
+ .to_vec1::<f32>()?
334
+ .chunks(self.d_saida)
335
+ .map(|c| c[..d].to_vec())
336
+ .flatten()
337
+ .collect::<Vec<f32>>();
338
+ Tensor::from_vec(v, (self.n, d), &dev)?
339
+ } else {
340
+ let mut v = candidatos.flatten_all()?.to_vec1::<f32>()?;
341
+ let mut linhas = Vec::new();
342
+ for i in 0..self.n {
343
+ let mut linha = v[i * self.d_saida..(i + 1) * self.d_saida].to_vec();
344
+ linha.extend(std::iter::repeat(0f32).take(d - self.d_saida));
345
+ linhas.push(linha);
346
+ }
347
+ v = linhas.into_iter().flatten().collect();
348
+ Tensor::from_vec(v, (self.n, d), &dev)?
349
+ };
350
+ let k_extra = cand.broadcast_as((b, self.n, d))?;
351
+ let v_extra = if d_v == d {
352
+ k_extra.clone()
353
+ } else {
354
+ // projeção simples por média de colunas quando d_v != d
355
+ let media = k_extra.mean_keepdim(candle_core::D::Minus1)?;
356
+ media.broadcast_as((b, self.n, d_v))?
357
+ };
358
+ // atenção sobre [base; extra]
359
+ let k = Tensor::cat(&[k_base.clone(), k_extra], 1)?;
360
+ let v = Tensor::cat(&[v_base.clone(), v_extra], 1)?;
361
+ let scores = (q.matmul(&k.transpose(1, 2)?)? / (d as f64).sqrt())?;
362
+ let attn = candle_nn::ops::softmax(&scores, candle_core::D::Minus1)?;
363
+ let y_base_e_extra = attn.matmul(&v)?;
364
+ // atenção apenas-base (para neutralidade: gate = 0 ⇒ saída = base)
365
+ let scores_base = (q.matmul(&k_base.transpose(1, 2)?)? / (d as f64).sqrt())?;
366
+ let attn_base = candle_nn::ops::softmax(&scores_base, candle_core::D::Minus1)?;
367
+ let y_base = attn_base.matmul(v_base)?;
368
+ // mistura: y = y_base + gate·(y_completo − y_base)
369
+ let g = self.gate_atencao.as_tensor();
370
+ let delta = (&y_base_e_extra - &y_base)?;
371
+ let forma: Vec<usize> = delta.dims().to_vec();
372
+ let delta = (delta.affine(1.0, 0.0)? * g.broadcast_as(forma)?)?;
373
+ Ok((&y_base + &delta)?)
374
+ }
375
+
376
+ // -----------------------------------------------------------------------
377
+ // v0.6.0 — verificador NCM (sem oráculo) + tentativas PARALELAS
378
+ // -----------------------------------------------------------------------
379
+
380
+ /// Candidatos das N tentativas em PARALELO (rayon) — as N redes têm
381
+ /// parâmetros disjuntos e entradas idênticas ⇒ N sub-DAGs independentes
382
+ /// no grafo de computação (mesma estrutura da prova M-R3): tempo
383
+ /// paralelo = max_i T_i + sobrecarga de agendamento.
384
+ /// Determinismo: o ruído da tentativa i usa a semente `semente + i`
385
+ /// (fluxos independentes por construção — reprodutível em qualquer
386
+ /// nº de threads).
387
+ pub fn candidatos_par(
388
+ &self,
389
+ cond: &Tensor,
390
+ temp: f64,
391
+ semente: u64,
392
+ ) -> Result<(Tensor, f64)> {
393
+ use rayon::prelude::*;
394
+ let dev = cond.device();
395
+ let cond_b = if cond.dims().len() == 1 {
396
+ cond.broadcast_as((1, self.d_cond))?
397
+ } else {
398
+ cond.clone()
399
+ };
400
+ let t0 = std::time::Instant::now();
401
+ let saidas: Vec<Tensor> = self
402
+ .tentativas
403
+ .par_iter()
404
+ .enumerate()
405
+ .map(|(i, t)| -> Result<Tensor> {
406
+ let o = t.fwd(&cond_b)?;
407
+ if temp > 0.0 {
408
+ let mut rng = RngDeterministico::novo(semente + i as u64);
409
+ let ruido: Vec<f32> =
410
+ (0..self.d_saida).map(|_| rng.normal(0.0, temp) as f32).collect();
411
+ let rt = Tensor::from_vec(ruido, (1, self.d_saida), &dev)?;
412
+ Ok((&o + &rt.affine(1.0, 0.0)?)?)
413
+ } else {
414
+ Ok(o)
415
+ }
416
+ })
417
+ .collect::<Result<Vec<_>>>()?;
418
+ let dt = t0.elapsed().as_secs_f64();
419
+ Ok((Tensor::cat(&saidas, 0)?, dt)) // (n, d_saida), tempo paralelo
420
+ }
421
+
422
+ /// **Variante em LOTE (v0.6.0 — fase C):** cond (b, d_cond) →
423
+ /// candidatos (b, n, d_saida) — as N tentativas processam o lote
424
+ /// inteiro (paralelas entre si; ruído por (linha, tentativa) com
425
+ /// semente determinística `semente + i`).
426
+ pub fn candidatos_lote(&self, cond: &Tensor, temp: f64, semente: u64) -> Result<Tensor> {
427
+ let b = cond.dim(0)?;
428
+ let dev = cond.device();
429
+ let mut saidas: Vec<Tensor> = Vec::with_capacity(self.n);
430
+ for (i, t) in self.tentativas.iter().enumerate() {
431
+ let o = t.fwd(cond)?; // (b, d_saida)
432
+ let o = if temp > 0.0 {
433
+ let mut rng = RngDeterministico::novo(semente + i as u64);
434
+ let ruido: Vec<f32> = (0..b * self.d_saida)
435
+ .map(|_| rng.normal(0.0, temp) as f32)
436
+ .collect();
437
+ let rt = Tensor::from_vec(ruido, (b, self.d_saida), &dev)?;
438
+ (&o + &rt)?
439
+ } else {
440
+ o
441
+ };
442
+ saidas.push(o.unsqueeze(1)?); // (b, 1, d_saida)
443
+ }
444
+ Ok(Tensor::cat(&saidas, 1)?) // (b, n, d_saida)
445
+ }
446
+
447
+ /// **Agregação em LOTE (v0.6.0):** candidatos (b, n, d) → resposta
448
+ /// (b, d) — mesma mistura 50/50 (montagem aprendida + consenso
449
+ /// ponderado por coerência) da versão 1-D, VETORIZADA e totalmente
450
+ /// diferenciável (gradiente flui pelos DOIS caminhos). Devolve também
451
+ /// os pesos médios (telemetria).
452
+ pub fn agregar_lote(&self, candidatos: &Tensor) -> Result<(Tensor, Vec<f64>)> {
453
+ let b = candidatos.dim(0)?;
454
+ let n = candidatos.dim(1)?;
455
+ let d = candidatos.dim(2)?;
456
+ let dev = candidatos.device();
457
+ // consenso (b, d)
458
+ let consenso = candidatos.mean(1)?;
459
+ // cosseno por (b, n): ��cand_i, consenso⟩ / (‖cand_i‖·‖consenso‖)
460
+ let dot = candidatos.matmul(&consenso.unsqueeze(2)?)?; // (b, n, 1)
461
+ let nc = candidatos.sqr()?.sum_keepdim(candle_core::D::Minus1)?.sqrt()?; // (b, n, 1)
462
+ let ncs = consenso.sqr()?.sum_keepdim(candle_core::D::Minus1)?.sqrt()?.unsqueeze(1)?; // (b, 1, 1)
463
+ let cos = dot.broadcast_div(&nc.broadcast_mul(&ncs)?)?; // (b, n, 1)
464
+ // pesos softmax de coerência (b, n, 1) — tensor puro (grafo intacto)
465
+ let exps = cos.affine(4.0, 0.0)?.exp()?;
466
+ let soma = exps.sum_keepdim(1)?; // (b, 1, 1)
467
+ let pesos = exps.broadcast_div(&soma)?; // (b, n, 1)
468
+ // média ponderada: Σ_n pesos·cand → (b, d)
469
+ let media = candidatos.broadcast_mul(&pesos)?.sum(1)?; // (b, d)
470
+ // montagem aprendida: concat sobre n → combinador
471
+ let concat = candidatos.reshape((b, n * d))?;
472
+ let montado = self.combinador.fwd(&concat)?; // (b, d)
473
+ let resposta = (montado.affine(0.5, 0.0)? + media.affine(0.5, 0.0)?)?;
474
+ // pesos médios para telemetria (leitura — não afeta o grafo)
475
+ let pesos_v = pesos.flatten_all()?.to_vec1::<f32>()?;
476
+ let mut pesos_medios = vec![0f64; n];
477
+ for (k, p) in pesos_v.iter().enumerate() {
478
+ pesos_medios[k % n] += *p as f64 / b as f64;
479
+ }
480
+ let _ = d;
481
+ let _ = dev;
482
+ Ok((resposta, pesos_medios))
483
+ }
484
+
485
+ /// **Ciclo d com o VERIFICADOR NCM (v0.6.0 — fecha o débito r-21 §3.1).**
486
+ ///
487
+ /// `logits_fn` mapeia uma resposta candidata (1, d_saida) → logits da
488
+ /// distribuição preditiva do BACKBONE condicionada à correção (passada
489
+ /// corrente — V-4 causal). O verificador calibrado devolve a confiança;
490
+ /// NENHUM acesso ao alvo verdadeiro (o oráculo morre aqui).
491
+ pub fn raciocinar_ncm(
492
+ &mut self,
493
+ cond: &Tensor,
494
+ verificador: &crate::verificador::VerificadorNcm,
495
+ logits_fn: &dyn Fn(&Tensor) -> Result<Tensor>,
496
+ rng: &mut RngDeterministico,
497
+ ) -> Result<ResultadoPensamento> {
498
+ let mut trajetoria = Vec::new();
499
+ let mut telemetria: HashMap<String, f64> = HashMap::new();
500
+ let mut temperatura = 0.1f64;
501
+ let mut melhor = (None::<Tensor>, -1.0f64, Vec::<f64>::new());
502
+ let mut iteracoes = 0usize;
503
+ let mut candidatos_final = Tensor::zeros(
504
+ (self.n, self.d_saida),
505
+ candle_core::DType::F32,
506
+ cond.device(),
507
+ )?;
508
+ loop {
509
+ iteracoes += 1;
510
+ trajetoria.push(EventoCiclo::Planejamento { iteracao: iteracoes, temperatura });
511
+ let candidatos = self.candidatos(cond, temperatura, rng)?;
512
+ candidatos_final = candidatos.clone();
513
+ let (resposta, pesos) = self.agregar(&candidatos)?;
514
+ trajetoria.push(EventoCiclo::DistribuicaoCompetencias { por_tentativa: pesos.clone() });
515
+ // AVALIAÇÃO pelo VERIFICADOR NCM (sem oráculo): confiança
516
+ // calibrada da distribuição preditiva do backbone
517
+ let logits = logits_fn(&resposta)?;
518
+ let conf = verificador.confianca_1d(&logits)?;
519
+ telemetria.insert(format!("conf_iter_{}", iteracoes), conf);
520
+ if conf > melhor.1 {
521
+ melhor = (Some(resposta), conf, pesos.clone());
522
+ }
523
+ if conf >= self.limiar_conf {
524
+ trajetoria.push(EventoCiclo::Resposta { confianca: conf, iteracoes });
525
+ telemetria.insert("iteracoes".into(), iteracoes as f64);
526
+ telemetria.insert("confianca_final".into(), conf);
527
+ telemetria.insert("temperatura_final".into(), temperatura);
528
+ telemetria.insert("verificador".into(), 1.0); // ncm (sem oráculo)
529
+ return Ok(ResultadoPensamento {
530
+ resposta: melhor.0,
531
+ candidatos: candidatos_final,
532
+ pesos: melhor.2,
533
+ confianca: conf,
534
+ iteracoes,
535
+ trajetoria,
536
+ telemetria,
537
+ });
538
+ }
539
+ if iteracoes >= self.orcamento {
540
+ trajetoria.push(EventoCiclo::Resposta { confianca: melhor.1, iteracoes });
541
+ telemetria.insert("iteracoes".into(), iteracoes as f64);
542
+ telemetria.insert("confianca_final".into(), melhor.1);
543
+ telemetria.insert("temperatura_final".into(), temperatura);
544
+ telemetria.insert("orcamento_esgotado".into(), 1.0);
545
+ telemetria.insert("verificador".into(), 1.0);
546
+ return Ok(ResultadoPensamento {
547
+ resposta: melhor.0,
548
+ candidatos: candidatos_final,
549
+ pesos: melhor.2,
550
+ confianca: melhor.1,
551
+ iteracoes,
552
+ trajetoria,
553
+ telemetria,
554
+ });
555
+ }
556
+ temperatura = (temperatura * 1.6).min(2.0);
557
+ trajetoria.push(EventoCiclo::RePlanejamento {
558
+ motivo: format!("conf NCM {conf:.3} < limiar {}", self.limiar_conf),
559
+ });
560
+ }
561
+ }
562
+ }
563
+
564
+ #[cfg(test)]
565
+ mod testes {
566
+ use super::*;
567
+ use crate::rng::RngDeterministico;
568
+ use candle_core::Device;
569
+
570
+ #[test]
571
+ fn teste_tp4_terminacao_e_orcamento() {
572
+ // o ciclo d SEMPRE termina em ≤ orçamento iterações (potencial
573
+ // Φ = B − k); com verificador impossível, termina com
574
+ // orcamento_esgotado = 1.
575
+ let dev = Device::Cpu;
576
+ let mut motor = MotorPensamento::novo(6, 4, 3, 0.99, 5, &dev).unwrap();
577
+ let cond = Tensor::randn(0f32, 1.0, (6,), &dev).unwrap();
578
+ let mut rng = RngDeterministico::novo(2);
579
+ let res = motor
580
+ .raciocinar(&cond, &|_| 0.0, &mut rng) // verificador sempre 0
581
+ .unwrap();
582
+ assert!(res.iteracoes <= 5, "iterações = {} > orçamento", res.iteracoes);
583
+ assert_eq!(res.telemetria.get("orcamento_esgotado"), Some(&1.0));
584
+ assert!(res.resposta.is_some(), "melhor candidato ainda é retornado");
585
+ }
586
+ #[test]
587
+ fn teste_tp5_neutralidade_no_nascimento() {
588
+ // gate = 0 ⇒ saída da atenção integrada é BIT-A-BIT a da base
589
+ let dev = Device::Cpu;
590
+ let motor = MotorPensamento::novo(8, 8, 3, 0.5, 3, &dev).unwrap();
591
+ let q = Tensor::randn(0f32, 1.0, (1, 4, 8), &dev).unwrap();
592
+ let k = Tensor::randn(0f32, 1.0, (1, 6, 8), &dev).unwrap();
593
+ let v = Tensor::randn(0f32, 1.0, (1, 6, 8), &dev).unwrap();
594
+ let cand = Tensor::randn(0f32, 1.0, (3, 8), &dev).unwrap();
595
+ let y_int = motor.atencao_integrada(&q, &k, &v, &cand).unwrap();
596
+ // atenção base pura
597
+ let scores = (q.matmul(&k.transpose(1, 2).unwrap()).unwrap() / (8f64).sqrt()).unwrap();
598
+ let attn = candle_nn::ops::softmax(&scores, candle_core::D::Minus1).unwrap();
599
+ let y_base = attn.matmul(&v).unwrap();
600
+ let dif = (&y_int - &y_base).unwrap().abs().unwrap().max_all().unwrap().to_scalar::<f32>().unwrap();
601
+ assert!(dif == 0.0, "gate=0 deveria dar bit-a-bit, dif = {dif}");
602
+ }
603
+ #[test]
604
+ fn teste_treino_cooperativo_e_agregacao() {
605
+ // item a: as tentativas + combinador APRENDEM a função alvo; a
606
+ // agregação converge para o alvo melhor que uma tentativa isolada
607
+ // no pior caso (verificação numérica honesta em escala pequena).
608
+ let dev = Device::Cpu;
609
+ let mut motor = MotorPensamento::novo(6, 4, 3, 0.5, 3, &dev).unwrap();
610
+ let vars = motor.vars();
611
+ let mut otim = crate::treino::AdamWManual::novo(vars, 5e-3, 0.0);
612
+ let mut rng = RngDeterministico::novo(4);
613
+ // alvo: função não-linear determinística de cond
614
+ let dados: Vec<(Vec<f32>, Vec<f32>)> = (0..256)
615
+ .map(|_| {
616
+ let c: Vec<f32> = (0..6).map(|_| rng.normal(0.0, 1.0) as f32).collect();
617
+ let a: Vec<f32> = (0..4)
618
+ .map(|j| {
619
+ (c[j % 6] * 0.5 + (c[(j + 1) % 6] * c[(j + 2) % 6]) * 0.3 + 0.1) as f32
620
+ })
621
+ .collect();
622
+ (c, a)
623
+ })
624
+ .collect();
625
+ let cs: Vec<f32> = dados.iter().flat_map(|(c, _)| c.clone()).collect();
626
+ let as_: Vec<f32> = dados.iter().flat_map(|(_, a)| a.clone()).collect();
627
+ let cond = Tensor::from_vec(cs, (256, 6), &dev).unwrap();
628
+ let alvo = Tensor::from_vec(as_, (256, 4), &dev).unwrap();
629
+ let mut perda0 = f64::NAN;
630
+ let mut perda1 = f64::NAN;
631
+ for passo in 0..200 {
632
+ let perda = motor.perda_treino(&cond, &alvo).unwrap();
633
+ if passo == 0 {
634
+ perda0 = perda.to_scalar::<f32>().unwrap() as f64;
635
+ }
636
+ perda1 = perda.to_scalar::<f32>().unwrap() as f64;
637
+ otim.passo(crate::treino::grads_achatados(&perda, &motor.vars()).unwrap());
638
+ }
639
+ assert!(perda1 < perda0 * 0.5, "treino cooperativo: {perda0} → {perda1}");
640
+ // agregação: verificador = negativo do erro quadrático médio
641
+ let mut rng2 = RngDeterministico::novo(9);
642
+ let cand = motor.candidatos(&cond.get(0).unwrap(), 0.0, &mut rng2).unwrap();
643
+ let (resp, pesos) = motor.agregar(&cand).unwrap();
644
+ assert_eq!(resp.dims().to_vec(), vec![1, 4]);
645
+ let soma: f64 = pesos.iter().sum();
646
+ assert!((soma - 1.0).abs() < 1e-9, "pesos somam {soma}");
647
+ assert!(pesos.iter().all(|&p| p >= 0.0));
648
+ }
649
+
650
+ /// T-P1′ (r-39): causalidade — 𝓕_k = σ(z, cond, ξ, avaliações); o
651
+ /// gatilho e a temperatura são 𝓕_k-mensuráveis (função do PASSADO).
652
+ /// Consequência testável: mesmas entradas + mesma semente ⇒ MESMA
653
+ /// decisão e MESMA trajetória, bit-a-bit (nenhum z_{t+1} entra).
654
+ #[test]
655
+ fn tp1_causalidade_gatilho() -> Result<()> {
656
+ let dev = Device::Cpu;
657
+ let cond = Tensor::from_vec(vec![0.2f32, -0.4, 0.6, 0.1], (1, 4), &dev)?;
658
+ let roda = || -> Result<(Vec<f64>, usize)> {
659
+ let mut motor = MotorPensamento::novo_com_semente(4, 3, 3, 0.999, 4, 77, &dev)?;
660
+ let mut rng = RngDeterministico::novo(5);
661
+ // verificador determinístico (função da resposta apenas)
662
+ let w = Tensor::from_vec(vec![0.3f32, -0.2, 0.5, 1.1, -0.7, 0.4, 0.2, -0.3, 0.9], (3, 3), &dev)?;
663
+ let ver = |y: &Tensor| -> f64 {
664
+ let z = y.matmul(&w).unwrap();
665
+ crate::pensamento::confianca_de_logits(&z).unwrap()
666
+ };
667
+ let r = motor.raciocinar(&cond, &ver, &mut rng)?;
668
+ let saida = r
669
+ .resposta
670
+ .map(|t| t.flatten_all().unwrap().to_vec1::<f32>().unwrap())
671
+ .unwrap_or_default();
672
+ Ok((saida.iter().map(|x| *x as f64).collect(), r.iteracoes))
673
+ };
674
+ let (a1, i1) = roda()?;
675
+ let (a2, i2) = roda()?;
676
+ assert_eq!(i1, i2, "mesmo nº de iterações");
677
+ assert_eq!(a1, a2, "mesma resposta bit-a-bit (causalidade/previsibilidade)");
678
+ Ok(())
679
+ }
680
+
681
+ #[test]
682
+ fn teste_tp2_auto_consistencia_numérica() {
683
+ // T-P2 numérico: N tentativas com viés comum pequeno; a média
684
+ // agregada tem erro menor que a tentativa mediana (redução de
685
+ // variância) na maioria das repetições.
686
+ let dev = Device::Cpu;
687
+ let mut rng = RngDeterministico::novo(6);
688
+ let alvo = [1.0f64, 2.0, -1.0, 0.5];
689
+ let mut venceu = 0;
690
+ let reps = 200;
691
+ for _ in 0..reps {
692
+ let n = 7;
693
+ let erros: Vec<f64> = (0..n)
694
+ .map(|_| {
695
+ alvo
696
+ .iter()
697
+ .map(|&a| {
698
+ let ruido = rng.normal(0.0, 1.0);
699
+ (a + ruido - a).abs()
700
+ })
701
+ .sum::<f64>()
702
+ })
703
+ .collect();
704
+ let media: Vec<f64> = (0..4)
705
+ .map(|j| {
706
+ (0..n).map(|i| alvo[j] + rng.normal(0.0, 1.0)).sum::<f64>() / n as f64
707
+ })
708
+ .collect();
709
+ let erro_media: f64 = media.iter().zip(alvo.iter()).map(|(m, a)| (m - a).abs()).sum();
710
+ let mut ordenado = erros.clone();
711
+ ordenado.sort_by(|a, b| a.partial_cmp(b).unwrap());
712
+ let mediana = ordenado[n / 2];
713
+ if erro_media <= mediana {
714
+ venceu += 1;
715
+ }
716
+ }
717
+ // a média vence a mediana na grande maioria dos casos (E[erro da
718
+ // média] = σ/√n < σ = E[erro de UMA tentativa])
719
+ assert!(
720
+ venceu as f64 / reps as f64 >= 0.6,
721
+ "auto-consistência venceu só {}/{}",
722
+ venceu,
723
+ reps
724
+ );
725
+ }
726
+ }
src/pensamento/quebra.rs ADDED
@@ -0,0 +1,237 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ //! QUEBRA-CABEÇA pós-treinamento (v0.7.0 — inovação com o conhecimento
2
+ //! treinado; provas Q-1..Q-6 em r-31). Extraído para arquivo próprio (SRP,
3
+ //! r-39): motor/combinador/quebra são responsabilidades separadas.
4
+
5
+ use candle_core::{Device, Result, Tensor};
6
+ use crate::rng::RngDeterministico;
7
+ use crate::verificador::VerificadorNcm;
8
+ use std::collections::HashMap;
9
+
10
+ // ---------------------------------------------------------------------------
11
+ // QUEBRA-CABEÇA pós-treinamento (v0.7.0 — inovação com o conhecimento
12
+ // treinado; requisito do usuário; provas Q-1..Q-6 em r-31)
13
+ // ---------------------------------------------------------------------------
14
+
15
+ /// Configuração do quebra-cabeça (r-28 §4.3).
16
+ #[derive(Clone, Copy, Debug)]
17
+ pub struct ConfigQuebraCabeca {
18
+ /// K peças em que o conhecimento é quebrado.
19
+ pub n_pecas: usize,
20
+ /// orçamento B de rodadas (terminação Q-4).
21
+ pub n_rodadas_max: usize,
22
+ /// limiar de validade (mesmo τ_c calibrado do verificador — Q-2).
23
+ pub tau_c: f64,
24
+ /// teto do ajuste por componente na árvore (regulação).
25
+ pub delta_max: f64,
26
+ /// remonta as peças com mistura ORTOGONAL por peça (rotação/ortogonalidade).
27
+ pub rotacao_ortogonal: bool,
28
+ /// para a execução após este nº de rodadas consecutivas sem aceite.
29
+ pub paciencia: usize,
30
+ }
31
+
32
+ impl Default for ConfigQuebraCabeca {
33
+ fn default() -> Self {
34
+ ConfigQuebraCabeca {
35
+ n_pecas: 4,
36
+ n_rodadas_max: 12,
37
+ tau_c: 0.55,
38
+ delta_max: 0.05,
39
+ rotacao_ortogonal: true,
40
+ paciencia: 5,
41
+ }
42
+ }
43
+ }
44
+
45
+ impl ConfigQuebraCabeca {
46
+ pub fn novo(n_pecas: usize, n_rodadas: usize, tau_c: f64) -> Self {
47
+ ConfigQuebraCabeca {
48
+ n_pecas,
49
+ n_rodadas_max: n_rodadas,
50
+ tau_c,
51
+ delta_max: 0.05,
52
+ rotacao_ortogonal: true,
53
+ paciencia: (n_rodadas / 2).max(2),
54
+ }
55
+ }
56
+ }
57
+
58
+ /// Uma rodada do quebra-cabeça.
59
+ #[derive(Debug, Clone)]
60
+ pub struct RodadaQuebraCabeca {
61
+ pub rodada: usize,
62
+ /// permutação das peças aplicada na remontagem (reordenação).
63
+ pub permutacao_pecas: Vec<usize>,
64
+ /// confiança NCM do candidato remontado (reavaliação).
65
+ pub confianca: f64,
66
+ /// conf ≥ τ_c ⇒ VÁLIDO (ajusta a árvore); senão PUNIDO (descarta).
67
+ pub aceito: bool,
68
+ /// delta aplicado na árvore (0 quando descartado).
69
+ pub delta_aplicado: f64,
70
+ /// rotações ortogonais usadas (quando ativas) — por peça.
71
+ pub usou_rotacao: bool,
72
+ }
73
+
74
+ /// Resultado consolidado do quebra-cabeça.
75
+ #[derive(Debug, Clone)]
76
+ pub struct ResultadoQuebraCabeca {
77
+ pub rodadas: Vec<RodadaQuebraCabeca>,
78
+ pub aceitos: usize,
79
+ pub rejeitados: usize,
80
+ pub confianca_base: f64,
81
+ pub confianca_melhor: f64,
82
+ pub telemetria: HashMap<String, f64>,
83
+ }
84
+
85
+ /// **Quebra-cabeça de inovação pós-treinamento** (r-28 §4.3):
86
+ /// 1. quebra o conhecimento treinado `conceitos` (m, d) em K peças por
87
+ /// permutação aleatória das linhas (Fisher–Yates com RNG determinístico);
88
+ /// 2. remonta as peças em nova ordem (e com mistura ortogonal por peça
89
+ /// quando `rotacao_ortogonal`) — "descobrir novas possibilidades";
90
+ /// 3. reavalia cada remontagem pelo verificador NCM (calibrado — V-2);
91
+ /// VÁLIDO (conf ≥ τ_c) ⇒ ajuste regulado na árvore de pesos indexada
92
+ /// (nó "pensamento", crédito fundo-topo); PUNIDO ⇒ descarta e o incremento
93
+ /// de punição sobe no nó (alimenta o gate do FNH — integração v0.7.0);
94
+ /// 4. repete até o orçamento B ou a paciência esgotar (Q-4).
95
+ ///
96
+ /// **Provas (r-31):** Q-1 cobertura (permutações uniformes ⇒ S_K no suporte;
97
+ /// rotações varrem O(d)); Q-2 soundness herdada (mesmo limiar calibrado do
98
+ /// verificador — P(aceite inválido) ≤ 1−τ_c+ECE); Q-3 potencial monotônico
99
+ /// (Φ_r = Σ conf dos aceitos é não-decrescente; rejeições não tocam Φ);
100
+ /// Q-4 terminação (B finito, rodadas O(m·d)); Q-5 invariantes da árvore
101
+ /// preservadas (ajustes só tocam métricas, nunca a estrutura — T-A1 intacto;
102
+ /// agregação pós-ajuste mantém T-A2); Q-6 causalidade (permutação e confiança
103
+ /// medidas antes do ajuste — filtração F_r).
104
+ pub fn quebra_cabeca_inovar(
105
+ conceitos: &Tensor,
106
+ verificador: &crate::verificador::VerificadorNcm,
107
+ logits_fn: &dyn Fn(&Tensor) -> Result<Tensor>,
108
+ arvore: &mut crate::arvore_pesos::ArvorePesos,
109
+ cfg: &ConfigQuebraCabeca,
110
+ rng: &mut RngDeterministico,
111
+ ) -> Result<ResultadoQuebraCabeca> {
112
+ let dev = conceitos.device().clone();
113
+ let (m, d) = (conceitos.dims()[0], conceitos.dims()[1]);
114
+ let k = cfg.n_pecas.clamp(1, m);
115
+ let no_pens = arvore.no("pensamento").unwrap_or(0);
116
+
117
+ // linha de base: confiança do conhecimento original (agregado médio)
118
+ let base_agg = conceitos.mean(0)?;
119
+ let conf_base = {
120
+ let lg = logits_fn(&base_agg)?;
121
+ verificador.confianca_1d(&lg)?
122
+ };
123
+
124
+ let mut rodadas = Vec::new();
125
+ let mut aceitos = 0usize;
126
+ let mut rejeitados = 0usize;
127
+ let mut conf_melhor = conf_base;
128
+ let mut sem_aceite = 0usize;
129
+
130
+ for r in 1..=cfg.n_rodadas_max {
131
+ if sem_aceite >= cfg.paciencia {
132
+ break;
133
+ }
134
+ // (1) QUEBRA: permutação de linhas Fisher–Yates (Q-6: amostrada ANTES)
135
+ let mut perm: Vec<usize> = (0..m).collect();
136
+ for i in (1..m).rev() {
137
+ let j = rng.inteiro(i + 1);
138
+ perm.swap(i, j);
139
+ }
140
+ // fatia em K peças contíguas (tamanhos quase iguais)
141
+ let tamanho = (m + k - 1) / k;
142
+ let mut pecas = Vec::with_capacity(k);
143
+ let mut ini = 0usize;
144
+ while ini < m {
145
+ let fim = (ini + tamanho).min(m);
146
+ let idx: Vec<u32> = perm[ini..fim].iter().map(|&x| x as u32).collect();
147
+ let pedaco = conceitos.index_select(&Tensor::from_vec(idx, (fim - ini,), &dev)?, 0)?;
148
+ pecas.push(pedaco);
149
+ ini = fim;
150
+ }
151
+ // (2) REMONTA: nova ordem aleatória das peças (permutação de peças)
152
+ let mut perm_pecas: Vec<usize> = (0..pecas.len()).collect();
153
+ for i in (1..pecas.len()).rev() {
154
+ let j = rng.inteiro(i + 1);
155
+ perm_pecas.swap(i, j);
156
+ }
157
+ let mut remontada = Vec::with_capacity(pecas.len());
158
+ for &pi in &perm_pecas {
159
+ let mut pedaco = pecas[pi].clone();
160
+ if cfg.rotacao_ortogonal && d >= 2 {
161
+ // mistura ortogonal da peça: Q ∈ O(d) via polar de gaussiana
162
+ // do RNG determinístico (preserva normas — ‖xQ‖_F = ‖x‖_F)
163
+ let q = q_ortogonal_deterministica(d, rng, &dev)?;
164
+ pedaco = pedaco.matmul(&q)?;
165
+ }
166
+ remontada.push(pedaco);
167
+ }
168
+ let candidata = Tensor::cat(&remontada, 0)?; // (m, d) remontado
169
+ // (3) REAVALIAÇÃO pelo verificador NCM (Q-2: mesmo limiar calibrado)
170
+ let agg = candidata.mean(0)?;
171
+ let lg = logits_fn(&agg)?;
172
+ let conf = verificador.confianca_1d(&lg)?;
173
+ let aceito = conf >= cfg.tau_c;
174
+ let delta = if aceito {
175
+ // VÁLIDO: ajusta a árvore bidirecional (indexada, com teto)
176
+ let escalado = (conf - cfg.tau_c).min(cfg.delta_max);
177
+ arvore.aplicar_ajuste_indexado(no_pens, "confianca", escalado, cfg.delta_max)
178
+ } else {
179
+ // PUNIDO: descarta; a punição sobe no nó (sinal para o gate FNH)
180
+ rejeitados += 1;
181
+ sem_aceite += 1;
182
+ arvore.aplicar_ajuste_indexado(no_pens, "punicao", cfg.delta_max * 0.5, cfg.delta_max);
183
+ 0.0
184
+ };
185
+ if aceito {
186
+ aceitos += 1;
187
+ sem_aceite = 0;
188
+ conf_melhor = conf_melhor.max(conf);
189
+ }
190
+ rodadas.push(RodadaQuebraCabeca {
191
+ rodada: r,
192
+ permutacao_pecas: perm_pecas,
193
+ confianca: conf,
194
+ aceito,
195
+ delta_aplicado: delta,
196
+ usou_rotacao: cfg.rotacao_ortogonal,
197
+ });
198
+ }
199
+ // crédito fundo-topo após todas as rodadas (T-A2)
200
+ arvore.agregar_fundo_topo("confianca");
201
+ arvore.agregar_fundo_topo("punicao");
202
+
203
+ let n_rod = rodadas.len();
204
+ let mut telemetria = HashMap::new();
205
+ telemetria.insert("rodadas".into(), n_rod as f64);
206
+ telemetria.insert("aceitos".into(), aceitos as f64);
207
+ telemetria.insert("rejeitados".into(), rejeitados as f64);
208
+ telemetria.insert("confianca_base".into(), conf_base);
209
+ telemetria.insert("confianca_melhor".into(), conf_melhor);
210
+ telemetria.insert(
211
+ "taxa_aceitacao".into(),
212
+ if n_rod > 0 { aceitos as f64 / n_rod as f64 } else { 0.0 },
213
+ );
214
+ telemetria.insert("rotacao_ativa".into(), if cfg.rotacao_ortogonal { 1.0 } else { 0.0 });
215
+ Ok(ResultadoQuebraCabeca {
216
+ rodadas,
217
+ aceitos,
218
+ rejeitados,
219
+ confianca_base: conf_base,
220
+ confianca_melhor: conf_melhor,
221
+ telemetria,
222
+ })
223
+ }
224
+
225
+ /// Q ∈ O(d) determinística: gaussiana do RNG próprio → retração polar.
226
+ /// Ortogonal EXATA (δ_ort ≤ 1e-6) e reprodutível (mesma semente ⇒ mesmo Q).
227
+ pub fn q_ortogonal_deterministica(
228
+ d: usize,
229
+ rng: &mut RngDeterministico,
230
+ dev: &Device,
231
+ ) -> Result<Tensor> {
232
+ let n = d * d;
233
+ let v: Vec<f32> = (0..n).map(|_| rng.normal_padrao() as f32).collect();
234
+ let g = Tensor::from_vec(v, (d, d), dev)?;
235
+ crate::stiefel::retrair_polar_frobenius(&g, 90)
236
+ }
237
+
src/pensamento/raciocinio_elastico.rs ADDED
@@ -0,0 +1,760 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ //! `pensamento::raciocinio_elastico` — v0.11 (r-42): raciocínio REAJUSTÁVEL
2
+ //! (ênfase por relevância via Hedge + water-filling) e COMPRIMÍVEL (certificado
3
+ //! de remoção de massa de atenção RE-2 + prefixos anytime RE-3).
4
+ //!
5
+ //! Teoremas: RE-1..RE-8 em `docs/memorias/r-42-raciocinio-elastico-v011.md`.
6
+ //! Princípios do repo: nascimento neutro, determinismo por semente, telemetria
7
+ //! auditada com motivo, rollback defensivo, zero acesso ao futuro (RE-7).
8
+
9
+ use super::{EventoCiclo, MotorPensamento, ResultadoPensamento};
10
+ use crate::controlador::AutoAjustePensamento;
11
+ use crate::rng::RngDeterministico;
12
+ use crate::telemetria::TelemetryHub;
13
+ use crate::verificador::VerificadorNcm;
14
+ use candle_core::{bail, Result, Tensor, D};
15
+ use std::collections::HashMap;
16
+
17
+ // ---------------------------------------------------------------------------
18
+ // Configuração (validada — falha cedo, nunca em silêncio)
19
+ // ---------------------------------------------------------------------------
20
+
21
+ #[derive(Debug, Clone)]
22
+ pub struct ConfigElastica {
23
+ /// Limiar de confiança calibrada (V-2′).
24
+ pub tau_c: f64,
25
+ /// Orçamento MÁXIMO de iterações (RE-4: Σ realocações ≤ B_max).
26
+ pub b_max: usize,
27
+ /// Teto de peças no banco (memória limitada).
28
+ pub max_pecas: usize,
29
+ /// Fator EMA da relevância (0 < β ≤ 1).
30
+ pub beta_relevancia: f64,
31
+ /// Clip do supremo de logits no segmento (H1 de RE-2).
32
+ pub z_sup: f64,
33
+ /// Norma espectral da cabeça de logits ‖W‖₂ (medida ou cota ‖W‖_F).
34
+ pub norma_w: f64,
35
+ /// Nº de classes da cabeça (K ≥ 2 para L_conf).
36
+ pub n_classes: usize,
37
+ /// Passo Hedge (None ⇒ agenda √(2 ln N / T)).
38
+ pub eta_hedge: Option<f64>,
39
+ /// Fator de expansão do difusor no re-planejamento.
40
+ pub fator_temp: f64,
41
+ pub temp_max: f64,
42
+ pub semente: u64,
43
+ }
44
+
45
+ impl Default for ConfigElastica {
46
+ fn default() -> Self {
47
+ Self {
48
+ tau_c: 0.9, b_max: 8, max_pecas: 64, beta_relevancia: 0.3,
49
+ z_sup: 12.0, norma_w: 1.0, n_classes: 16, eta_hedge: None,
50
+ fator_temp: 1.6, temp_max: 2.0, semente: 42,
51
+ }
52
+ }
53
+ }
54
+
55
+ impl ConfigElastica {
56
+ pub fn validar(&self) -> Result<()> {
57
+ if !(0.0..1.0).contains(&self.tau_c) || self.tau_c <= 0.0 {
58
+ bail!("tau_c deve estar em (0,1)");
59
+ }
60
+ if self.b_max == 0 || self.max_pecas == 0 {
61
+ bail!("b_max e max_pecas devem ser >= 1");
62
+ }
63
+ if !(0.0..=1.0).contains(&self.beta_relevancia) || self.beta_relevancia == 0.0 {
64
+ bail!("beta_relevancia deve estar em (0,1]");
65
+ }
66
+ if self.z_sup <= 0.0 || self.norma_w <= 0.0 || self.n_classes < 2 {
67
+ bail!("z_sup>0, norma_w>0, n_classes>=2 (H1/L_conf de RE-2)");
68
+ }
69
+ if self.fator_temp < 1.0 || self.temp_max <= 0.0 {
70
+ bail!("fator_temp>=1 e temp_max>0");
71
+ }
72
+ Ok(())
73
+ }
74
+
75
+ /// L_conf de RE-2: `2·Z_sup·‖W‖₂ / ln K` (Lipschitz da confiança em y).
76
+ pub fn lipschitz_conf(&self) -> f64 {
77
+ 2.0 * self.z_sup * self.norma_w / (self.n_classes as f64).ln()
78
+ }
79
+ }
80
+
81
+ // ---------------------------------------------------------------------------
82
+ // Banco de peças (RE-1/RE-2/RE-6)
83
+ // ---------------------------------------------------------------------------
84
+
85
+ /// Peça de raciocínio: vetor (1, d_saida), relevância EMA, última massa de
86
+ /// atenção e custo em unidades de compute/tokens (RE-5/RE-8).
87
+ #[derive(Debug, Clone)]
88
+ pub struct Peca {
89
+ pub vetor: Tensor,
90
+ pub relevancia: f64,
91
+ pub massa: f64,
92
+ pub custo: usize,
93
+ /// Nível de prefixo NCM corrente (RE-3; 0 = não quantizada).
94
+ pub nivel_prefixo: usize,
95
+ }
96
+
97
+ /// RE-2 (errata v011-2): orçamento de massa HEDGE removível que PRESERVA
98
+ /// o aceite. Com a agregação elástica GATEADA
99
+ /// `resposta = y_base + g·(media_hedge − y_base)` e compressão que remove
100
+ /// peso Hedge total `w_R` (renormalizando os mantidos):
101
+ /// `Δresposta = g·(media_c − media)` com
102
+ /// `‖media_c − media‖ = ‖Σ_R w_i(media − p_i)‖/(1−w_R) ≤ 2V_max·w_R/(1−w_R)`
103
+ /// `≤ 4V_max·w_R` para `w_R ≤ 1/2` (teto aplicado em `comprimir_por_massa`).
104
+ /// Logo `Δconf ≤ 4·|g|·V_max·L_conf·w_R` e o orçamento seguro é
105
+ /// `ε_safe = (conf − τ_c) / (4·|g|·V_max·L_conf)`; 0 sem margem; ∞ se g=0
106
+ /// (neutralidade no nascimento — a resposta não depende do banco).
107
+ pub fn epsilon_seguro(conf: f64, tau_c: f64, gate: f64, v_max: f64, l_conf: f64) -> f64 {
108
+ let margem = conf - tau_c;
109
+ if margem <= 0.0 || v_max <= 0.0 || l_conf <= 0.0 {
110
+ return 0.0;
111
+ }
112
+ let denom = 4.0 * gate.abs() * v_max * l_conf;
113
+ if denom <= f64::EPSILON {
114
+ return f64::INFINITY; // gate=0 ⇒ compressão livre (neutralidade T-P5)
115
+ }
116
+ margem / denom
117
+ }
118
+
119
+ /// RE-1: massas de atenção das peças como chaves extras: softmax sobre
120
+ /// [k_base; extras] por linha de q; devolve a massa média por peça (P,).
121
+ /// `q (b, n_q, d)`, `k_base (b, n_kv, d)`, `extras (P, d)`.
122
+ pub fn massas_extra(q: &Tensor, k_base: &Tensor, extras: &Tensor) -> Result<Vec<f64>> {
123
+ let (b, _nq, d) = q.dims3()?;
124
+ let p = extras.dim(0)?;
125
+ if p == 0 {
126
+ return Ok(Vec::new());
127
+ }
128
+ let ke = extras.reshape((1, p, d))?.broadcast_as((b, p, d))?;
129
+ let k = Tensor::cat(&[k_base.clone(), ke], 1)?;
130
+ let scores = q.matmul(&k.transpose(1, 2)?)?.affine(1.0 / (d as f64).sqrt(), 0.0)?;
131
+ let attn = candle_nn::ops::softmax(&scores, D::Minus1)?; // (b, n_q, n_kv+p)
132
+ let n_kv = k_base.dim(1)?;
133
+ let extra = attn.narrow(2, n_kv, p)?; // (b, n_q, p)
134
+ let media = extra.mean(1)?.mean(0)?; // (p,) — média sobre queries e lote
135
+ Ok(media.to_vec1::<f32>()?.iter().map(|&x| x as f64).collect())
136
+ }
137
+
138
+ /// Proxy de massa quando não há atenção disponível (cosseno com o consenso,
139
+ /// softmax β=4 — MESMA forma do combinador). O certificado RE-2 só é VÁLIDO
140
+ /// com massas de atenção reais; com proxy, `certificado_valido=false` e o
141
+ /// rollback por re-verificação é o único guardião (honestidade r-42 §2).
142
+ pub fn massas_proxy(pecas: &[Tensor]) -> Result<Vec<f64>> {
143
+ if pecas.is_empty() {
144
+ return Ok(Vec::new());
145
+ }
146
+ let cand = Tensor::cat(pecas, 0)?; // (P, d)
147
+ let consenso = cand.mean_keepdim(0)?;
148
+ let dot = cand.matmul(&consenso.transpose(0, 1)?)?;
149
+ let nc = cand.sqr()?.sum_keepdim(D::Minus1)?.sqrt()?;
150
+ let ncs = consenso.sqr()?.sum_keepdim(D::Minus1)?.sqrt()?;
151
+ let cos = dot.broadcast_div(&nc.broadcast_mul(&ncs)?.clamp(1e-12, f64::INFINITY)?)?;
152
+ let w = candle_nn::ops::softmax(&cos.affine(4.0, 0.0)?, 0)?;
153
+ Ok(w.flatten_all()?.to_vec1::<f32>()?.iter().map(|&x| x as f64).collect())
154
+ }
155
+
156
+ /// Compressão gulosa por massa (peso HEDGE) ASCENDENTE sob orçamento ε
157
+ /// (RE-2 errata v011-2). Devolve (índices mantidos, massa removida w_R).
158
+ /// Teto estrutural `w_R ≤ 1/2` (absorve o fator 1/(1−w_R) ≤ 2 do bound).
159
+ /// Determinística: empate por índice; nunca remove todas as peças.
160
+ pub fn comprimir_por_massa(massas: &[f64], eps: f64) -> (Vec<usize>, f64) {
161
+ let mut ordem: Vec<usize> = (0..massas.len()).collect();
162
+ ordem.sort_by(|&a, &b| {
163
+ massas[a].partial_cmp(&massas[b]).unwrap_or(std::cmp::Ordering::Equal).then(a.cmp(&b))
164
+ });
165
+ let mut removidos = vec![false; massas.len()];
166
+ let mut acc = 0.0;
167
+ for &i in &ordem {
168
+ let novo = acc + massas[i];
169
+ if novo <= eps && novo <= 0.5 {
170
+ removidos[i] = true;
171
+ acc = novo;
172
+ }
173
+ }
174
+ let mantidos: Vec<usize> = (0..massas.len()).filter(|&i| !removidos[i]).collect();
175
+ // nunca remover TODAS (o banco precisa de ao menos uma peça)
176
+ if mantidos.is_empty() && !massas.is_empty() {
177
+ let melhor = ordem.last().copied().unwrap_or(0);
178
+ return (vec![melhor], acc - massas[melhor]);
179
+ }
180
+ (mantidos, acc)
181
+ }
182
+
183
+ /// RE-6: pesos Hedge sobre perdas acumuladas (previsíveis — só passado).
184
+ pub fn pesos_hedge(perdas_acum: &[f64], eta: f64) -> Vec<f64> {
185
+ let min = perdas_acum.iter().cloned().fold(f64::INFINITY, f64::min);
186
+ let exps: Vec<f64> = perdas_acum.iter().map(|&l| (-eta * (l - min)).exp()).collect();
187
+ let soma: f64 = exps.iter().sum::<f64>().max(1e-300);
188
+ exps.iter().map(|e| e / soma).collect()
189
+ }
190
+
191
+ /// RE-5/M-R5′: water-filling INTEIRO ótimo (guloso marginal, troca — r-41).
192
+ /// `q_i ≥ 0`, `C ≥ q.len()`; devolve c_i ≥ 1 com Σ c_i = C.
193
+ pub fn alocar_guloso(q: &[f64], c_total: usize) -> Result<Vec<usize>> {
194
+ let m = q.len();
195
+ if m == 0 || c_total < m {
196
+ bail!("alocar_guloso: precisa C >= m >= 1");
197
+ }
198
+ let mut c = vec![1usize; m];
199
+ for _ in m..c_total {
200
+ let (mut imax, mut gmax) = (0usize, f64::NEG_INFINITY);
201
+ for i in 0..m {
202
+ let ci = c[i] as f64;
203
+ let ganho = q[i] * q[i] * (1.0 / ci - 1.0 / (ci + 1.0));
204
+ if ganho > gmax {
205
+ gmax = ganho;
206
+ imax = i;
207
+ }
208
+ }
209
+ c[imax] += 1;
210
+ }
211
+ Ok(c)
212
+ }
213
+
214
+ // ---------------------------------------------------------------------------
215
+ // Motor elástico (compõe o MotorPensamento existente — SRP)
216
+ // ---------------------------------------------------------------------------
217
+
218
+ pub struct RaciocinioElastico {
219
+ pub motor: MotorPensamento,
220
+ pub cfg: ConfigElastica,
221
+ pub auto: AutoAjustePensamento,
222
+ pub pecas: Vec<Peca>,
223
+ perdas_acum: Vec<f64>,
224
+ conf_anterior: f64,
225
+ }
226
+
227
+ /// Resultado com CERTIFICADO de compressão (auditável).
228
+ #[derive(Debug, Clone)]
229
+ pub struct CertificadoCompressao {
230
+ pub epsilon_safe: f64,
231
+ pub massa_removida: f64,
232
+ pub bound_delta_conf: f64,
233
+ pub delta_conf_medido: f64,
234
+ pub violado: bool,
235
+ pub rollback: bool,
236
+ pub valido: bool,
237
+ }
238
+
239
+ pub struct ResultadoElastico {
240
+ pub base: ResultadoPensamento,
241
+ pub certificados: Vec<CertificadoCompressao>,
242
+ pub pesos_hedge_final: Vec<f64>,
243
+ pub alocacao_final: Vec<usize>,
244
+ pub telemetria_extra: HashMap<String, f64>,
245
+ }
246
+
247
+ impl RaciocinioElastico {
248
+ pub fn novo(motor: MotorPensamento, cfg: ConfigElastica) -> Result<Self> {
249
+ cfg.validar()?;
250
+ let auto = AutoAjustePensamento::novo(cfg.tau_c, cfg.b_max, motor.n);
251
+ Ok(Self {
252
+ motor, cfg, auto,
253
+ pecas: Vec::new(), perdas_acum: Vec::new(), conf_anterior: 0.0,
254
+ })
255
+ }
256
+
257
+ fn registrar_pecas(&mut self, candidatos: &Tensor) -> Result<()> {
258
+ let n = candidatos.dim(0)?;
259
+ for i in 0..n {
260
+ let vetor = candidatos.get(i)?.reshape((1, self.motor.d_saida))?;
261
+ self.pecas.push(Peca { vetor, relevancia: 0.0, massa: 0.0, custo: 1, nivel_prefixo: 0 });
262
+ self.perdas_acum.push(0.0);
263
+ }
264
+ // teto de memória: descartar as de menor relevância (FIFO em empate)
265
+ if self.pecas.len() > self.cfg.max_pecas {
266
+ let excesso = self.pecas.len() - self.cfg.max_pecas;
267
+ let mut ordem: Vec<usize> = (0..self.pecas.len()).collect();
268
+ ordem.sort_by(|&a, &b| {
269
+ self.pecas[a].relevancia
270
+ .partial_cmp(&self.pecas[b].relevancia)
271
+ .unwrap_or(std::cmp::Ordering::Equal).then(a.cmp(&b))
272
+ });
273
+ let descartar: std::collections::HashSet<usize> = ordem[..excesso].iter().copied().collect();
274
+ let (p, l): (Vec<_>, Vec<_>) = std::mem::take(&mut self.pecas).into_iter()
275
+ .zip(std::mem::take(&mut self.perdas_acum))
276
+ .enumerate().filter(|(i, _)| !descartar.contains(i))
277
+ .map(|(_, (p, l))| (p, l)).unzip();
278
+ self.pecas = p;
279
+ self.perdas_acum = l;
280
+ }
281
+ Ok(())
282
+ }
283
+
284
+ /// RE-6: ganho marginal ⇒ perda ℓ = 1 − clip(ganho, 0, 1); relevância EMA.
285
+ fn atualizar_relevancia(&mut self, conf: f64, pesos_participacao: &[f64]) {
286
+ let ganho = (conf - self.conf_anterior).max(0.0);
287
+ let beta = self.cfg.beta_relevancia;
288
+ for (i, peca) in self.pecas.iter_mut().enumerate() {
289
+ let w = pesos_participacao.get(i).copied().unwrap_or(0.0);
290
+ let ganho_i = (ganho * w).clamp(0.0, 1.0);
291
+ peca.relevancia = (1.0 - beta) * peca.relevancia + beta * ganho_i;
292
+ self.perdas_acum[i] += 1.0 - ganho_i;
293
+ }
294
+ self.conf_anterior = conf;
295
+ }
296
+
297
+ fn eta(&self, t: usize) -> f64 {
298
+ self.cfg.eta_hedge.unwrap_or_else(|| {
299
+ let n = self.pecas.len().max(2) as f64;
300
+ (2.0 * n.ln() / t.max(1) as f64).sqrt()
301
+ })
302
+ }
303
+
304
+ fn matriz_pecas(&self, idx: &[usize]) -> Result<Tensor> {
305
+ let linhas: Vec<Tensor> = idx.iter().map(|&i| self.pecas[i].vetor.clone()).collect();
306
+ Tensor::cat(&linhas, 0)
307
+ }
308
+
309
+ /// Ciclo d ELÁSTICO: gerar → registrar → ênfase (Hedge) → agregar →
310
+ /// verificar → COMPRIMIR com certificado (rollback se violado) →
311
+ /// responder ou expandir. `q`/`k_base` opcionais habilitam RE-2 válido.
312
+ pub fn raciocinar(
313
+ &mut self,
314
+ cond: &Tensor,
315
+ verificador: &VerificadorNcm,
316
+ logits_fn: &dyn Fn(&Tensor) -> Result<Tensor>,
317
+ q: Option<&Tensor>,
318
+ k_base: Option<&Tensor>,
319
+ hub: &mut TelemetryHub,
320
+ rng: &mut RngDeterministico,
321
+ ) -> Result<ResultadoElastico> {
322
+ let mut certificados = Vec::new();
323
+ let mut tel = HashMap::new();
324
+ let mut temperatura = 0.1f64;
325
+ let mut iteracoes = 0usize;
326
+ let mut melhor: (Option<Tensor>, f64) = (None, -1.0);
327
+ let mut alocacao: Vec<usize> = Vec::new();
328
+ let gate = self.motor.gate_atencao.as_tensor().to_scalar::<f32>()? as f64;
329
+
330
+ loop {
331
+ iteracoes += 1;
332
+ // (1) GERAÇÃO (motor existente — N tentativas + difusor)
333
+ let candidatos = self.motor.candidatos(cond, temperatura, rng)?;
334
+ self.registrar_pecas(&candidatos)?;
335
+
336
+ // (2) ÊNFASE REAJUSTÁVEL: massas de atenção (telemetria +
337
+ // ranking interpretável) e pesos Hedge (agregação — RE-6,
338
+ // previsível). Errata v011-2: o ORÇAMENTO de compressão usa a
339
+ // massa HEDGE (o bound é provado nela); as massas de atenção
340
+ // informam QUEAIS peças o modelo considera relevantes.
341
+ let vetores: Vec<Tensor> = self.pecas.iter().map(|p| p.vetor.clone()).collect();
342
+ let massas = match (q, k_base) {
343
+ (Some(qq), Some(kb)) => {
344
+ let extras = Tensor::cat(&vetores, 0)?;
345
+ tel.insert("massas_reais".into(), 1.0);
346
+ massas_extra(qq, kb, &extras)?
347
+ }
348
+ _ => {
349
+ tel.insert("massas_reais".into(), 0.0);
350
+ massas_proxy(&vetores)?
351
+ }
352
+ };
353
+ for (p, &m) in self.pecas.iter_mut().zip(&massas) {
354
+ p.massa = m;
355
+ }
356
+ let pesos = pesos_hedge(&self.perdas_acum, self.eta(iteracoes));
357
+
358
+ // (3) AGREGAÇÃO gateada por ênfase (peças = linhas de candidatos)
359
+ let matriz = self.matriz_pecas(&(0..self.pecas.len()).collect::<Vec<_>>())?;
360
+ let (resposta, media_hedge) = self.agregar_ponderado_com_media(&matriz, &pesos)?;
361
+ let conf = verificador.confianca_1d(&logits_fn(&resposta)?)?;
362
+ self.atualizar_relevancia(conf, &pesos);
363
+ self.auto.confs_retidas.push(conf);
364
+ if let Some(anterior) = tel.get("conf_anterior").copied() {
365
+ self.auto.ganhos_por_iteracao.push((conf - anterior).max(0.0));
366
+ }
367
+ tel.insert("conf_anterior".into(), conf);
368
+ if conf > melhor.1 {
369
+ melhor = (Some(resposta.clone()), conf);
370
+ }
371
+
372
+ // (4) DECISÃO: responder (com compressão certificada) ou expandir
373
+ if conf >= self.cfg.tau_c {
374
+ let cert = self.comprimir_certificado(
375
+ resposta, media_hedge, conf, gate, verificador, logits_fn, &pesos,
376
+ tel.get("massas_reais") == Some(&1.0), hub,
377
+ )?;
378
+ let resposta_final = cert.0;
379
+ certificados.push(cert.1);
380
+ tel.insert("conf_final".into(), conf);
381
+ tel.insert("iteracoes".into(), iteracoes as f64);
382
+ alocacao = alocar_guloso(
383
+ &self.pecas.iter().map(|p| p.relevancia.max(1e-6)).collect::<Vec<_>>(),
384
+ self.cfg.b_max.max(self.pecas.len()),
385
+ )?;
386
+ return Ok(ResultadoElastico {
387
+ base: ResultadoPensamento {
388
+ resposta: Some(resposta_final),
389
+ candidatos, pesos, confianca: conf, iteracoes,
390
+ trajetoria: vec![EventoCiclo::Resposta { confianca: conf, iteracoes }],
391
+ telemetria: tel.clone().into_iter().collect(),
392
+ },
393
+ certificados, pesos_hedge_final: pesos_hedge(&self.perdas_acum, self.eta(iteracoes)),
394
+ alocacao_final: alocacao, telemetria_extra: tel,
395
+ });
396
+ }
397
+ if iteracoes >= self.cfg.b_max {
398
+ // RE-4: Φ = B_max − k = 0 — honestidade (orcamento_esgotado)
399
+ tel.insert("orcamento_esgotado".into(), 1.0);
400
+ tel.insert("conf_final".into(), melhor.1);
401
+ tel.insert("iteracoes".into(), iteracoes as f64);
402
+ return Ok(ResultadoElastico {
403
+ base: ResultadoPensamento {
404
+ resposta: melhor.0, candidatos, pesos, confianca: melhor.1,
405
+ iteracoes,
406
+ trajetoria: vec![EventoCiclo::Resposta { confianca: melhor.1, iteracoes }],
407
+ telemetria: tel.clone().into_iter().collect(),
408
+ },
409
+ certificados, pesos_hedge_final: pesos_hedge(&self.perdas_acum, self.eta(iteracoes)),
410
+ alocacao_final: Vec::new(), telemetria_extra: tel,
411
+ });
412
+ }
413
+ // (5) EXPANSÃO (re-planejamento): difusor mais quente + realocação
414
+ temperatura = (temperatura * self.cfg.fator_temp).min(self.cfg.temp_max);
415
+ let q_rel: Vec<f64> = self.pecas.iter().map(|p| p.relevancia.max(1e-6)).collect();
416
+ alocacao = alocar_guloso(&q_rel, self.cfg.b_max.max(self.pecas.len()))?;
417
+ hub.ajuste("elastico_temperatura", temperatura / self.cfg.fator_temp, temperatura,
418
+ &format!("RE: conf {conf:.3} < τ_c {} — expandir exploração", self.cfg.tau_c));
419
+ }
420
+ }
421
+
422
+ /// Agregação por pesos de ênfase (média ponderada — T-P2′ com pesos
423
+ /// previsíveis) + montagem aprendida do motor (mistura 50/50 como r-21).
424
+ /// Agregação elástica GATEADA (errata v011-2 — torna o certificado
425
+ /// RE-2 VÁLIDO por construção):
426
+ /// `resposta = y_base + g·(media_hedge − y_base)` onde `y_base` é a
427
+ /// montagem do motor sobre os n candidatos CORRENTES (últimas n linhas
428
+ /// — o combinador é Linear(n·d_saida → d_saida)) e `media_hedge` é a
429
+ /// média ponderada por Hedge (T-P2′, pesos previsíveis) do banco
430
+ /// INTEIRO. g=0 ⇒ resposta = y_base BIT-A-BIT (neutralidade no
431
+ /// nascimento); a compressão só toca o termo GATEADO ⇒
432
+ /// `Δresposta = g·(media_c − media)` com o bound provado de RE-2.
433
+ fn agregar_ponderado(&self, matriz: &Tensor, pesos: &[f64]) -> Result<Tensor> {
434
+ let (resposta, _media) = self.agregar_ponderado_com_media(matriz, pesos)?;
435
+ Ok(resposta)
436
+ }
437
+
438
+ /// Devolve (resposta gateada, media_hedge) — a media é reutilizada
439
+ /// pelo certificado de compressão (recomputação exata do termo gateado).
440
+ fn agregar_ponderado_com_media(&self, matriz: &Tensor, pesos: &[f64]) -> Result<(Tensor, Tensor)> {
441
+ let p = matriz.dim(0)?;
442
+ let w = Tensor::from_vec(pesos.iter().map(|&x| x as f32).collect::<Vec<_>>(), (p, 1), matriz.device())?;
443
+ let media = matriz.broadcast_mul(&w)?.sum_keepdim(0)?; // (1, d)
444
+ let y_base = if p >= self.motor.n {
445
+ let ini = p - self.motor.n;
446
+ let linhas: Vec<Tensor> = (ini..p)
447
+ .map(|i| matriz.get(i)?.broadcast_as((1, self.motor.d_saida)))
448
+ .collect::<Result<Vec<_>>>()?;
449
+ let cand = Tensor::cat(&linhas, 0)?; // (n, d_saida)
450
+ self.motor.agregar(&cand)?.0
451
+ } else {
452
+ media.clone()
453
+ };
454
+ let g = self.motor.gate_atencao.as_tensor().to_scalar::<f32>()? as f64;
455
+ // resposta = y_base + g·(media − y_base) — um único caminho gateado
456
+ let delta = (&media - &y_base)?;
457
+ let resposta = (&y_base + &delta.affine(g, 0.0)?)?;
458
+ Ok((resposta, media))
459
+ }
460
+
461
+ /// v0.11: calibra o gate do banco elástico por BUSCA EM GRADE (1-D)
462
+ /// sobre amostras de TREINO — maximiza a confiança média do verificador.
463
+ /// O gate controla quanto a ênfase elástica (banco) participa da
464
+ /// resposta; g=0 ⇒ resposta = y_base bit-a-bit (neutralidade no
465
+ /// nascimento, T-P5). Determinístico (RNG semeado); devolve o g escolhido
466
+ /// e deixa o banco vazio (a consulta recomeça limpa).
467
+ pub fn calibrar_gate(
468
+ &mut self,
469
+ conds: &Tensor,
470
+ verificador: &VerificadorNcm,
471
+ logits_fn: &dyn Fn(&Tensor) -> Result<Tensor>,
472
+ grid: &[f64],
473
+ rng: &mut RngDeterministico,
474
+ ) -> Result<(f64, Vec<(f64, f64)>)> {
475
+ let dev = conds.device();
476
+ let m = conds.dim(0)?;
477
+ let mut curva: Vec<(f64, f64)> = Vec::with_capacity(grid.len());
478
+ let mut melhor = (0.0f64, f64::NEG_INFINITY);
479
+ for &g in grid {
480
+ self.motor
481
+ .gate_atencao
482
+ .set(&Tensor::new(g as f32, &dev)?)?;
483
+ let mut soma = 0.0f64;
484
+ for i in 0..m {
485
+ let cond = conds.get(i)?.broadcast_as((1, self.motor.d_cond))?;
486
+ let cands = self.motor.candidatos(&cond, 0.05, rng)?;
487
+ self.registrar_pecas(&cands)?;
488
+ let idx: Vec<usize> = (0..self.pecas.len()).collect();
489
+ let matriz = self.matriz_pecas(&idx)?;
490
+ let pesos = pesos_hedge(&self.perdas_acum, self.eta(1));
491
+ let (resp, _) = self.agregar_ponderado_com_media(&matriz, &pesos)?;
492
+ soma += verificador.confianca_1d(&logits_fn(&resp)?)?;
493
+ // banco da amostra é descartado (avaliações independentes)
494
+ self.pecas.clear();
495
+ self.perdas_acum.clear();
496
+ }
497
+ let media = soma / m.max(1) as f64;
498
+ curva.push((g, media));
499
+ if media > melhor.1 {
500
+ melhor = (g, media);
501
+ }
502
+ }
503
+ self.motor
504
+ .gate_atencao
505
+ .set(&Tensor::new(melhor.0 as f32, &dev)?)?;
506
+ Ok((melhor.0, curva))
507
+ }
508
+
509
+ /// RE-2 operacional (errata v011-2): comprimir → RE-VERIFICAR →
510
+ /// rollback se violado. A resposta comprimida RECOMPUTA APENAS o termo
511
+ /// gateado: `resposta_c = resposta − g·(media − media_c)` — o bound
512
+ /// `4·|g|·V_max·L_conf·w_R` cobre EXATAMENTE essa perturbação
513
+ /// (prova no comentário de `epsilon_seguro`); o y_base NÃO é tocado.
514
+ fn comprimir_certificado(
515
+ &mut self,
516
+ resposta: Tensor,
517
+ media: Tensor,
518
+ conf: f64,
519
+ gate: f64,
520
+ verificador: &VerificadorNcm,
521
+ logits_fn: &dyn Fn(&Tensor) -> Result<Tensor>,
522
+ massas: &[f64],
523
+ valido: bool,
524
+ hub: &mut TelemetryHub,
525
+ ) -> Result<(Tensor, CertificadoCompressao)> {
526
+ let v_max = self.pecas.iter()
527
+ .map(|p| p.vetor.abs().and_then(|t| t.max_all()).and_then(|t| t.to_scalar::<f32>()))
528
+ .collect::<Result<Vec<f32>>>()?
529
+ .into_iter().map(|x| x as f64).fold(0.0f64, f64::max).max(1e-12);
530
+ let l_conf = self.cfg.lipschitz_conf();
531
+ let eps = epsilon_seguro(conf, self.cfg.tau_c, gate, v_max, l_conf);
532
+ let (mantidos, massa_rem) = comprimir_por_massa(massas, eps);
533
+ if mantidos.len() == self.pecas.len() {
534
+ return Ok((resposta, CertificadoCompressao {
535
+ epsilon_safe: eps, massa_removida: 0.0, bound_delta_conf: 0.0,
536
+ delta_conf_medido: 0.0, violado: false, rollback: false, valido,
537
+ }));
538
+ }
539
+ // media_c: média Hedge RENORMALIZADA dos mantidos
540
+ let pesos_c = pesos_hedge(
541
+ &mantidos.iter().map(|&i| self.perdas_acum[i]).collect::<Vec<_>>(),
542
+ self.eta(1),
543
+ );
544
+ let matriz_c = self.matriz_pecas(&mantidos)?;
545
+ let p_c = matriz_c.dim(0)?;
546
+ let w_c = Tensor::from_vec(pesos_c.iter().map(|&x| x as f32).collect::<Vec<_>>(), (p_c, 1), matriz_c.device())?;
547
+ let media_c = matriz_c.broadcast_mul(&w_c)?.sum_keepdim(0)?; // (1, d)
548
+ // resposta_c = resposta − g·(media − media_c) — SÓ o termo gateado muda
549
+ let resposta_c = (&resposta - &(&media - &media_c)?.affine(gate, 0.0)?)?;
550
+ let conf_c = verificador.confianca_1d(&logits_fn(&resposta_c)?)?;
551
+ let bound = 4.0 * l_conf * gate.abs() * v_max * massa_rem;
552
+ let delta = (conf - conf_c).abs();
553
+ let violado = conf_c < self.cfg.tau_c || delta > bound + 1e-6;
554
+ hub.ajuste("elastico_compressao", self.pecas.len() as f64, mantidos.len() as f64,
555
+ &format!("RE-2: ε_safe={eps:.4}, w_R={massa_rem:.4}, bound={bound:.5}, Δconf={delta:.5}, violado={violado}"));
556
+ if violado {
557
+ // rollback defensivo: restaura integralmente (H1 pode ter falhado)
558
+ return Ok((resposta, CertificadoCompressao {
559
+ epsilon_safe: eps, massa_removida: massa_rem, bound_delta_conf: bound,
560
+ delta_conf_medido: delta, violado: true, rollback: true, valido,
561
+ }));
562
+ }
563
+ // commit: remover peças do banco (compressão efetiva de memória)
564
+ let set: std::collections::HashSet<usize> = mantidos.iter().copied().collect();
565
+ let (p, l): (Vec<_>, Vec<_>) = std::mem::take(&mut self.pecas).into_iter()
566
+ .zip(std::mem::take(&mut self.perdas_acum))
567
+ .enumerate().filter(|(i, _)| set.contains(i))
568
+ .map(|(_, (p, l))| (p, l)).unzip();
569
+ self.pecas = p;
570
+ self.perdas_acum = l;
571
+ Ok((resposta_c, CertificadoCompressao {
572
+ epsilon_safe: eps, massa_removida: massa_rem, bound_delta_conf: bound,
573
+ delta_conf_medido: delta, violado: false, rollback: false, valido,
574
+ }))
575
+ }
576
+ }
577
+
578
+ pub fn versao() -> &'static str {
579
+ "raciocinio-elastico-0.11.0"
580
+ }
581
+
582
+ // ---------------------------------------------------------------------------
583
+ // Testes de falsificação (RE-1..RE-8)
584
+ // ---------------------------------------------------------------------------
585
+
586
+ #[cfg(test)]
587
+ mod testes {
588
+ use super::*;
589
+ use candle_core::Device;
590
+
591
+ fn t(v: Vec<f32>, shape: impl candle_core::shape::ShapeWithOneHole) -> Tensor {
592
+ Tensor::from_vec(v, shape, &Device::Cpu).unwrap()
593
+ }
594
+
595
+ /// RE-1: identidade Δy = π(ȳ_e − y_base) — erro < 1e-6 (f32).
596
+ #[test]
597
+ fn re1_identidade_massa() -> Result<()> {
598
+ let (d, nb, ne) = (6usize, 5usize, 3usize);
599
+ let mut rng = RngDeterministico::novo(1);
600
+ let mk = |n: usize, d: usize, rng: &mut RngDeterministico| -> Tensor {
601
+ t((0..n * d).map(|_| rng.normal(0.0, 1.0) as f32).collect(), (1, n, d))
602
+ };
603
+ let q = mk(1, d, &mut rng);
604
+ let kb = mk(nb, d, &mut rng);
605
+ let ke = t((0..ne * d).map(|_| rng.normal(0.0, 1.0) as f32).collect(), (ne, d));
606
+ let vb = mk(nb, d, &mut rng);
607
+ let ve = t((0..ne * d).map(|_| rng.normal(0.0, 1.0) as f32).collect(), (ne, d));
608
+ let sm = |s: &Tensor| candle_nn::ops::softmax(s, D::Minus1);
609
+ let sb = q.matmul(&kb.transpose(1, 2)?)?.affine(1.0 / (d as f64).sqrt(), 0.0)?;
610
+ let se = q.matmul(&ke.reshape((1, ne, d))?.transpose(1, 2)?)?.affine(1.0 / (d as f64).sqrt(), 0.0)?;
611
+ let ab = sm(&sb)?;
612
+ let af = sm(&Tensor::cat(&[sb, se], 2)?)?;
613
+ let yb = ab.matmul(&vb)?;
614
+ let yf = af.matmul(&Tensor::cat(&[vb, ve.reshape((1, ne, d))?], 1)?)?;
615
+ let pi: f32 = af.narrow(2, nb, ne)?.sum_all()?.to_scalar()?;
616
+ let ae = af.narrow(2, nb, ne)?;
617
+ let ye_bar = ae.affine(1.0 / pi as f64, 0.0)?.matmul(&ve.reshape((1, ne, d))?)?;
618
+ let lhs = (&yf - &yb)?;
619
+ let rhs = (ye_bar - yb)?.affine(pi as f64, 0.0)?;
620
+ let err = (lhs - rhs)?.abs()?.max_all()?.to_scalar::<f32>()?;
621
+ assert!(err < 1e-6, "RE-1: erro da identidade = {err}");
622
+ let massas = massas_extra(&q, &kb, &ke)?;
623
+ assert!((massas.iter().sum::<f64>() - pi as f64).abs() < 1e-5);
624
+ Ok(())
625
+ }
626
+
627
+ /// RE-2: ε_safe preserva aceite; sem margem ⇒ ε=0; gate=0 ⇒ livre.
628
+ #[test]
629
+ fn re2_epsilon_seguro() {
630
+ assert_eq!(epsilon_seguro(0.5, 0.9, 1.0, 1.0, 1.0), 0.0);
631
+ let eps = epsilon_seguro(0.95, 0.9, 0.5, 2.0, 4.0);
632
+ // errata v011-2: denominador 4·|g|·V_max·L_conf (massa HEDGE, teto ½)
633
+ assert!((eps - 0.05 / (4.0 * 0.5 * 2.0 * 4.0)).abs() < 1e-12);
634
+ assert!(epsilon_seguro(0.95, 0.9, 0.0, 1.0, 1.0).is_infinite());
635
+ // cadeia: bound ≥ delta garantido pela escolha de ε
636
+ let (g, vmax, lc) = (0.5, 2.0, 4.0);
637
+ let delta_max = lc * 4.0 * g * vmax * eps;
638
+ assert!(delta_max <= 0.05 + 1e-12);
639
+ }
640
+
641
+ /// RE-2: compressão gulosa respeita o orçamento e nunca esvazia o banco.
642
+ #[test]
643
+ fn re2b_compressao_orcamento() {
644
+ let massas = vec![0.4, 0.05, 0.02, 0.3, 0.01];
645
+ let (mant, rem) = comprimir_por_massa(&massas, 0.10);
646
+ assert!(rem <= 0.10 + 1e-12);
647
+ assert!(!mant.is_empty());
648
+ assert_eq!(mant, vec![0, 3]); // remove as três menores: 0.01+0.02+0.05
649
+ let (m0, r0) = comprimir_por_massa(&massas, 0.0);
650
+ assert_eq!(m0.len(), massas.len());
651
+ assert_eq!(r0, 0.0); // neutralidade ε=0
652
+ let (m1, _) = comprimir_por_massa(&[0.9, 0.1], 1.0);
653
+ assert_eq!(m1.len(), 1); // nunca remove todas
654
+ }
655
+
656
+ /// RE-5: guloso == força bruta (exaustivo, m=3, C=7).
657
+ #[test]
658
+ fn re5_guloso_otimo_vs_bruto() -> Result<()> {
659
+ let q = [3.83, 4.17, 2.47];
660
+ let c = 7usize;
661
+ let g = alocar_guloso(&q, c)?;
662
+ let custo = |cc: &[usize]| -> f64 { q.iter().zip(cc).map(|(qi, ci)| qi * qi / *ci as f64).sum() };
663
+ let mut melhor = f64::INFINITY;
664
+ for a in 1..=c - 2 {
665
+ for b in 1..=c - a - 1 {
666
+ melhor = melhor.min(custo(&[a, b, c - a - b]));
667
+ }
668
+ }
669
+ assert!((custo(&g) - melhor).abs() < 1e-9, "guloso {:?} f={} vs bruto {}", g, custo(&g), melhor);
670
+ Ok(())
671
+ }
672
+
673
+ /// RE-6: Hedge — arrependimento ≤ √(2T ln N) (adversarial).
674
+ #[test]
675
+ fn re6_hedge_regret() {
676
+ let (n, t) = (4usize, 500usize);
677
+ let eta = (2.0 * (n as f64).ln() / t as f64).sqrt();
678
+ let mut acum = vec![0.0; n];
679
+ let mut perda_alg = 0.0;
680
+ let mut melhor_fixa = vec![0.0; n];
681
+ for k in 0..t {
682
+ let perdas: Vec<f64> = (0..n).map(|i| if (k + i) % n == 0 { 0.0 } else { 1.0 }).collect();
683
+ let w = pesos_hedge(&acum, eta);
684
+ perda_alg += w.iter().zip(&perdas).map(|(wi, li)| wi * li).sum::<f64>();
685
+ for i in 0..n {
686
+ acum[i] += perdas[i];
687
+ melhor_fixa[i] += perdas[i];
688
+ }
689
+ }
690
+ let regret = perda_alg - melhor_fixa.iter().cloned().fold(f64::INFINITY, f64::min);
691
+ let bound = (2.0 * t as f64 * (n as f64).ln()).sqrt();
692
+ assert!(regret <= bound, "regret {regret:.2} > bound {bound:.2}");
693
+ }
694
+
695
+ /// RE-4: terminação com verificador sempre baixo ⇒ ≤ B_max e honestidade.
696
+ #[test]
697
+ fn re4_terminacao_honesta() -> Result<()> {
698
+ let dev = Device::Cpu;
699
+ let motor = MotorPensamento::novo(4, 3, 2, 0.99, 3, &dev)?;
700
+ let cfg = ConfigElastica { b_max: 3, tau_c: 0.99, ..Default::default() };
701
+ let mut re = RaciocinioElastico::novo(motor, cfg)?;
702
+ let verif = VerificadorNcm::novo();
703
+ let cond = t(vec![0.1, 0.2, 0.3, 0.4], (1, 4));
704
+ // cabeça FIXA (semeada): logits pequenos ⇒ confiança baixa sempre.
705
+ // Determinismo: w fora do closure — zero acesso ao RNG global (RE-7).
706
+ let mut rng_w = RngDeterministico::novo(11);
707
+ let w = t((0..3 * 8).map(|_| rng_w.normal(0.0, 0.1) as f32).collect(), (3, 8));
708
+ let logits_fn = |y: &Tensor| -> Result<Tensor> { y.matmul(&w) };
709
+ let mut hub = TelemetryHub::novo(None);
710
+ let mut rng = RngDeterministico::novo(7);
711
+ let r = re.raciocinar(&cond, &verif, &logits_fn, None, None, &mut hub, &mut rng)?;
712
+ assert!(r.base.iteracoes <= 3);
713
+ assert_eq!(r.telemetria_extra.get("orcamento_esgotado"), Some(&1.0));
714
+ assert!(r.base.resposta.is_some()); // melhor candidato, nunca None
715
+ Ok(())
716
+ }
717
+
718
+ /// RE-8/determinismo: mesma semente ⇒ mesma trajetória (massas proxy).
719
+ #[test]
720
+ fn re8_determinismo() -> Result<()> {
721
+ let dev = Device::Cpu;
722
+ let roda = || -> Result<Vec<f64>> {
723
+ let motor = MotorPensamento::novo_com_semente(4, 3, 2, 0.5, 4, 202, &dev)?;
724
+ let mut re = RaciocinioElastico::novo(motor, ConfigElastica::default())?;
725
+ let cond = t(vec![0.1, 0.2, 0.3, 0.4], (1, 4));
726
+ let mut rng_w = RngDeterministico::novo(13);
727
+ let w = t((0..3 * 8).map(|_| rng_w.normal(0.0, 0.3) as f32).collect(), (3, 8));
728
+ let logits_fn = |y: &Tensor| -> Result<Tensor> { y.matmul(&w) };
729
+ let mut hub = TelemetryHub::novo(None);
730
+ let mut rng = RngDeterministico::novo(99);
731
+ let r = re.raciocinar(&cond, &VerificadorNcm::novo(), &logits_fn, None, None, &mut hub, &mut rng)?;
732
+ Ok(r.base.candidatos.flatten_all()?.to_vec1::<f32>()?.iter().map(|&x| x as f64).collect())
733
+ };
734
+ assert_eq!(roda()?, roda()?, "mesma semente ⇒ bit-a-bit");
735
+ Ok(())
736
+ }
737
+
738
+ /// L_conf: bound Lipschitz conf — |Δconf| ≤ L_conf·‖Δy‖ (cadeia RE-2).
739
+ #[test]
740
+ fn re2c_lipschitz_conf_cadeia() -> Result<()> {
741
+ let (k, d) = (8usize, 4usize);
742
+ let w = Tensor::randn(0f32, 0.8, (k, d), &Device::Cpu)?;
743
+ let nw = w.sqr()?.sum_all()?.to_scalar::<f32>()? as f64; // ‖W‖_F ≥ ‖W‖₂
744
+ let cfg = ConfigElastica { norma_w: nw.sqrt(), n_classes: k, z_sup: 30.0, ..Default::default() };
745
+ let conf = |y: &Tensor| -> Result<f64> {
746
+ let z = y.matmul(&w.transpose(0, 1)?)?;
747
+ Ok(crate::verificador::confianca_por_linha(&z)?.flatten_all()?.to_vec1::<f32>()?[0] as f64)
748
+ };
749
+ let mut rng = RngDeterministico::novo(5);
750
+ for _ in 0..32 {
751
+ let y0 = t((0..d).map(|_| rng.normal(0.0, 1.0) as f32).collect(), (1, d));
752
+ let dy = t((0..d).map(|_| rng.normal(0.0, 0.05) as f32).collect(), (1, d));
753
+ let y1 = (&y0 + &dy)?;
754
+ let delta = (conf(&y0)? - conf(&y1)?).abs();
755
+ let bound = cfg.lipschitz_conf() * dy.sqr()?.sum_all()?.to_scalar::<f32>()?.sqrt() as f64;
756
+ assert!(delta <= bound + 1e-9, "|Δconf|={delta} > bound={bound}");
757
+ }
758
+ Ok(())
759
+ }
760
+ }
src/quantizador.rs CHANGED
@@ -138,6 +138,18 @@ pub struct QuantizadorNivel {
138
  chamadas: std::cell::Cell<u64>, // contador p/ ruído fresco por chamada
139
  }
140
 
 
 
 
 
 
 
 
 
 
 
 
 
141
  impl QuantizadorNivel {
142
  pub fn novo(k: usize, d: usize, modo: ModoQuant, ema: f64, escala_modo: &str, dev: &Device) -> Result<Self> {
143
  let w0 = stiefel::init_stiefel(k, d, dev)?;
@@ -169,50 +181,6 @@ impl QuantizadorNivel {
169
  stiefel::erro_ortogonalidade(&c.transpose(0, 1)?)
170
  }
171
 
172
- /// **Coerência μ do codebook (v0.10.0, crítica DeepSeek A.1 — Teo
173
- /// A.1′ em r-35 §4.2):** `μ = max_{i≠j} |⟨û_i, û_j⟩|` com `û` as
174
- /// linhas NORMALIZADAS. Para codebooks ortonormais (K ≤ d, RCO), μ ≈
175
- /// δ_ort (teoricamente 0); para frames K > d, o limite inferior de
176
- /// Welch é `μ ≥ √((K−d)/(d(K−1)))` — a degradação da contração do Teo
177
- /// A.1 sob não-ortonormalidade é `1 + (K−1)·μ` (autovalores do Gram
178
- /// em `[1−(K−1)μ, 1+(K−1)μ]` — Gershgorin). Telemetria reporta μ por
179
- /// nível; com δ_ort medido ~1e-6 no treino real (r-27), a folga do
180
- /// pior caso é ~(K−1)·μ ≈ 6e-5.
181
- pub fn coerencia(&self) -> Result<f64> {
182
- let c = self.codebook()?.detach();
183
- let c2 = contiguo_2d(&c)?;
184
- let normas = c2
185
- .sqr()?
186
- .sum_keepdim(D::Minus1)?
187
- .sqrt()?
188
- .clamp(1e-12, f64::INFINITY)?;
189
- let unit = c2.broadcast_div(&normas)?;
190
- let gram = unit.matmul(&unit.transpose(0, 1)?)?;
191
- let k = gram.dims()[0];
192
- // máx fora-da-diagonal
193
- let g = gram.flatten_all()?.to_vec1::<f32>()?;
194
- let mut mx = 0f64;
195
- for i in 0..k {
196
- for j in 0..k {
197
- if i != j {
198
- mx = mx.max((g[i * k + j] as f64).abs());
199
- }
200
- }
201
- }
202
- Ok(mx)
203
- }
204
-
205
- /// Limite inferior de Welch para K códigos em d dimensões (A.1′):
206
- /// `μ ≥ √((K−d)/(d(K−1)))` quando K > d; 0 quando K ≤ d (otronormal
207
- /// é atingível). Devolve (limite, K, d).
208
- pub fn limite_welch(k: usize, d: usize) -> f64 {
209
- if k <= d || d == 0 {
210
- 0.0
211
- } else {
212
- ((k - d) as f64 / (d as f64 * (k - 1) as f64)).sqrt()
213
- }
214
- }
215
-
216
  /// Amostra ruído de Gumbel (n, K) — fora do grafo (constante).
217
  pub fn ruido_gumbel(&self, n: usize, k: usize, dev: &Device) -> Result<Tensor> {
218
  use rand::prelude::*;
@@ -327,6 +295,90 @@ impl QuantizadorNivel {
327
  let tau = tau_min + (tau0 - tau_min) * (1.0 - t / t_alvo.max(1) as f64);
328
  self.tau = tau.max(tau_min);
329
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
330
  }
331
 
332
  // ---------- utilidades de forma ----------
@@ -344,6 +396,89 @@ fn redimensionar_de_volta(r: &Tensor, modelo: &Tensor) -> Result<Tensor> {
344
 
345
  #[cfg(test)]
346
  mod testes {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
347
  use super::*;
348
 
349
  #[test]
@@ -442,80 +577,4 @@ mod testes_debug {
442
  assert!(erro < 1e-4, "grad nativo vs op = {erro}\n n={g_n:?}\n o={g_o:?}");
443
  Ok(())
444
  }
445
-
446
- // -----------------------------------------------------------------
447
- // v0.10.0 — A.0′/A.1′ (críticas DeepSeek NCM). Provas em r-35 §4.
448
- // -----------------------------------------------------------------
449
-
450
- /// **A.0′ (viés do STE quantificado — pedido da crítica):** com dither
451
- /// uniforme de largura Δ (= célula do quantizador uniforme) e perda
452
- /// quadrática (M = Lip(∇L) = 2), o estimador dithered-STE
453
- /// `E_u[ĝ_STE(z+u)]` desvia do gradiente VERDADEIRO do objetivo
454
- /// suavizado `F(z) = E_u[L(q(z+u))]` por no máximo `M·Δ/2 = Δ` por
455
- /// coordenada (Teo A.0′-ii, r-35 §4.1; derivação exata no caso 1D:
456
- /// E_u[q(z+u)] = z e F'(z) = [L(q(z+Δ/2)) − L(q(z−Δ/2))]/Δ).
457
- /// O teste verifica a cota em vários offsets de célula.
458
- #[test]
459
- fn a0_vies_ste_limitado_pelo_dither() {
460
- // quantizador uniforme 4 níveis, célula Δ=0.5, níveis nos centros
461
- let delta = 0.5f64;
462
- // níveis nos CENTROS das células kΔ (arredondar-para-o-mais-próximo):
463
- // condição de momento E_u[q(z+u)] = z do dither uniforme (Gray–Stockham)
464
- let q = |w: f64| -> f64 {
465
- let cel = (w / delta + 0.5).floor();
466
- (cel * delta).clamp(0.0, 3.0 * delta)
467
- };
468
- let alvo = 0.83f64;
469
- let perda = |w: f64| (q(w) - alvo) * (q(w) - alvo);
470
- let m_lip = 2.0f64; // ∇² da quadrática
471
- let mut rng = crate::rng::RngDeterministico::novo(17);
472
- // offsets de célula variados (evita exatamente 0 — degenerescência)
473
- for s_frac in [0.05f64, 0.2, 0.35, 0.45, 0.5, 0.65, 0.8, 0.95] {
474
- let z = 2.0 * delta + s_frac * delta; // célula 2 (longe das bordas)
475
- // (a) gradiente verdadeiro de F por diferenças finitas exatas
476
- let f_prime = (perda(z + delta / 2.0) - perda(z - delta / 2.0)) / delta;
477
- // (b) estimador dithered-STE por Monte Carlo (20k amostras)
478
- let n_mc = 20_000usize;
479
- let mut soma = 0.0f64;
480
- for _ in 0..n_mc {
481
- let u = (rng.uniforme() - 0.5) * delta;
482
- let w = z + u;
483
- soma += 2.0 * (q(w) - alvo); // ĝ_STE(w) = ∇L(q(w))
484
- }
485
- let est = soma / n_mc as f64;
486
- // ruído MC: |ĝ| ≤ 2·(4Δ) ⇒ σ ≤ 8Δ/√n ≈ 0.0028; 4σ folga
487
- let ruido = 4.0 * 8.0 * delta / (n_mc as f64).sqrt();
488
- let vies = (est - f_prime).abs();
489
- assert!(
490
- vies <= m_lip * delta / 2.0 + ruido,
491
- "A.0′: viés {vies:.5} > cota M·Δ/2+ruido = {:.5} (s_frac={s_frac}, \
492
- est={est:.5}, F'={f_prime:.5})",
493
- m_lip * delta / 2.0 + ruido
494
- );
495
- }
496
- }
497
-
498
- /// **A.1′ (coerência de Welch):** codebook Stiefel K ≤ d tem μ ≈ 0
499
- /// (medido); o limite de Welch só é positivo para K > d — verificação
500
- /// da fórmula e da monotonia em K.
501
- #[test]
502
- fn a1_coerencia_e_limite_welch() {
503
- // fórmula: K ≤ d ⇒ 0; K > d ⇒ √((K−d)/(d(K−1))), monotônico em K
504
- assert_eq!(QuantizadorNivel::limite_welch(4, 8), 0.0);
505
- let w_64 = QuantizadorNivel::limite_welch(256, 64);
506
- let w_96 = QuantizadorNivel::limite_welch(256, 96);
507
- assert!(w_64 > w_96 && w_96 > 0.0, "welch deve decrescer com d: {w_64} vs {w_96}");
508
- // valor exato: K=128, d=64 ⇒ √(64/(64·127)) = √(1/127)
509
- let w = QuantizadorNivel::limite_welch(128, 64);
510
- assert!((w - (1.0f64 / 127.0).sqrt()).abs() < 1e-12, "welch(128,64) = {w}");
511
- // codebook REAL Stiefel K=16 ≤ d=32: μ pequeno (δ_ort nível ~1e-3
512
- // nas iterações de polar padrão)
513
- let dev = candle_core::Device::Cpu;
514
- let qq = QuantizadorNivel::novo(16, 32, ModoQuant::SteEma, 0.99, "ema_projecao", &dev)
515
- .unwrap();
516
- let mu = qq.coerencia().unwrap();
517
- assert!(mu < 0.2, "coerência de codebook Stiefel K<d deveria ser ~0, μ={mu}");
518
- // e dominada pelo limite de Welch do caso K>d equivalente? (informativo)
519
- println!("a1: μ(Stiefel 16×32) = {mu:.6}, δ_ort = {:?}", qq.delta_ort().unwrap());
520
- }
521
  }
 
138
  chamadas: std::cell::Cell<u64>, // contador p/ ruído fresco por chamada
139
  }
140
 
141
+ /// Telemetria de contração de um nível (r-38 A.1′).
142
+ pub struct ContracaoNivel {
143
+ /// ‖res‖²/‖z‖² com a escala EMA corrente (operacional).
144
+ pub medida: f64,
145
+ /// com R* = M ponto a ponto (CERTIFICÁVEL: ≤ cota no span).
146
+ pub otima: f64,
147
+ /// cota garantida 1 − 1/K (codebook ortonormal, z ∈ span).
148
+ pub cota: f64,
149
+ /// fração de energia no span de C (1 ⇒ cota aplicável).
150
+ pub fracao_span: f64,
151
+ }
152
+
153
  impl QuantizadorNivel {
154
  pub fn novo(k: usize, d: usize, modo: ModoQuant, ema: f64, escala_modo: &str, dev: &Device) -> Result<Self> {
155
  let w0 = stiefel::init_stiefel(k, d, dev)?;
 
181
  stiefel::erro_ortogonalidade(&c.transpose(0, 1)?)
182
  }
183
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
184
  /// Amostra ruído de Gumbel (n, K) — fora do grafo (constante).
185
  pub fn ruido_gumbel(&self, n: usize, k: usize, dev: &Device) -> Result<Tensor> {
186
  use rand::prelude::*;
 
295
  let tau = tau_min + (tau0 - tau_min) * (1.0 - t / t_alvo.max(1) as f64);
296
  self.tau = tau.max(tau_min);
297
  }
298
+
299
+ /// v0.11 (r-38 A.0′): resíduo STE do nível — `ρ² = E‖z − r_h‖²`
300
+ /// (elemento médio). O compromisso β controla ρ em expectativa e o
301
+ /// viés direcional do STE é O(β^{−1/2}) no equilíbrio — REPORTAR ρ.
302
+ pub fn residuo_ste(&self, z: &Tensor) -> Result<f64> {
303
+ let (_ids, valores) = self.quantizar_duro(z)?;
304
+ let dif = z.sub(&valores)?;
305
+ Ok(dif.sqr()?.mean_all()?.to_scalar::<f32>()? as f64)
306
+ }
307
+
308
+ /// v0.11 (r-38 A.1′): telemetria de contração do nível.
309
+ ///
310
+ /// **Prova A.1′(ii)/(iii):** com codebook ortonormal, z ∈ span(C) e
311
+ /// escala ÓTIMA ponto a ponto `R* = M = ⟨z, c_{k*}⟩`:
312
+ /// `‖z − R* c_{k*}‖² = ‖z‖² − M² ≤ ‖z‖² − ‖P_C z‖²/K` ⇒ contração
313
+ /// garantida `1 − 1/K` no span. A escala EMA global `R` (operacional,
314
+ /// conservadora `≈ ‖P_C z‖/√K`) NÃO carrega a garantia ponto a ponto —
315
+ /// por isso reportamos `medida` (R corrente) E `otima` (R* exato);
316
+ /// fora do span, `fracao_span < 1` e o termo ‖z − P_C z‖² persiste
317
+ /// (limitação honesta — cota composta nos níveis seguintes).
318
+ pub fn contracao_empirica(&self, z: &Tensor) -> Result<ContracaoNivel> {
319
+ let (_ids, valores) = self.quantizar_duro(z)?;
320
+ let dif = z.sub(&valores)?;
321
+ let e_res = dif.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
322
+ let e_z = z.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
323
+ let k = self.w.dims()[0] as f64;
324
+ // fração no span: ‖P_C z‖²/‖z‖² com P_C = CᵀC (linhas ortonormais)
325
+ let c = self.codebook()?.detach();
326
+ let z2 = contiguo_2d(z)?;
327
+ let cz = z2.matmul(&c.transpose(0, 1)?)?; // (n, K)
328
+ let pz = cz.matmul(&c)?; // (n, d) projeção
329
+ let e_pz = pz.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
330
+ // contração com R* = M ponto a ponto (certificável):
331
+ // Σ(‖z_i‖² − M_i²)/Σ��z_i‖², M_i = max_k ⟨z_i, c_k⟩
332
+ let m = cz.max(D::Minus1)?.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
333
+ let e_z2 = z2.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
334
+ let otima = ((e_z2 - m) / e_z2.max(1e-12)).max(0.0);
335
+ Ok(ContracaoNivel {
336
+ medida: e_res / e_z.max(1e-12),
337
+ otima,
338
+ cota: 1.0 - 1.0 / k,
339
+ fracao_span: e_pz / e_z.max(1e-12),
340
+ })
341
+ }
342
+
343
+ /// v0.11 (r-38 B.1): dependência SEQUENCIAL dos códigos — informação
344
+ /// mútua plug-in MI(id_t ; id_{t+1}) em nats. O gap exato da predição
345
+ /// paralela intra-nível é TC(c_ℓ|c_{<ℓ}) ≥ 0 (identidade provada,
346
+ /// r-38 §4); estimar TC exige discriminador de permutações (variância
347
+ /// alta — limitação honesta). Este MI lag-1 é o DIAGNÓSTICO barato:
348
+ /// ≈ viés plug-in O((K−1)²/n) sob independência; grande sob dependência
349
+ /// sequencial dos resíduos (o que a predição paralela ignora).
350
+ pub fn dependencia_uso(&self, ids: &Tensor) -> Result<f64> {
351
+ let v = ids.flatten_all()?.to_vec1::<u32>()?;
352
+ let k = self.uso.len();
353
+ let n = v.len();
354
+ if n < 16 || k < 2 {
355
+ return Ok(0.0);
356
+ }
357
+ let mut conj = vec![vec![0u64; k]; k];
358
+ let mut marg_t = vec![0u64; k];
359
+ let mut marg_prox = vec![0u64; k];
360
+ for w in v.windows(2) {
361
+ let (a, b) = (w[0] as usize, w[1] as usize);
362
+ if a < k && b < k {
363
+ conj[a][b] += 1;
364
+ marg_t[a] += 1;
365
+ marg_prox[b] += 1;
366
+ }
367
+ }
368
+ let np = (n - 1) as f64;
369
+ let mut mi = 0.0f64;
370
+ for a in 0..k {
371
+ for b in 0..k {
372
+ if conj[a][b] > 0 {
373
+ let p_ab = conj[a][b] as f64 / np;
374
+ let p_a = marg_t[a] as f64 / np;
375
+ let p_b = marg_prox[b] as f64 / np;
376
+ mi += p_ab * (p_ab / (p_a * p_b)).ln();
377
+ }
378
+ }
379
+ }
380
+ Ok(mi.max(0.0))
381
+ }
382
  }
383
 
384
  // ---------- utilidades de forma ----------
 
396
 
397
  #[cfg(test)]
398
  mod testes {
399
+
400
+ use super::*;
401
+
402
+ // ------------------------------------------------------------------
403
+ // v0.11 — r-38: A.0′ (resíduo ρ), A.1′ (contração), B.1 (proxy TC)
404
+ // ------------------------------------------------------------------
405
+
406
+ /// A.1′(iii): com z NO SPAN do codebook ortonormal, a contração medida
407
+ /// respeita a cota garantida 1 − 1/K (com tolerância para a escala EMA
408
+ /// conservadora R ≤ R*); fora do span, a fração de energia no span < 1
409
+ /// e o excesso é o termo ortogonal persistente (limitação honesta).
410
+ #[test]
411
+ fn a1_contracao_no_span_respeita_cota() -> Result<()> {
412
+ let dev = Device::Cpu;
413
+ let (k, d, n) = (6usize, 10usize, 256usize);
414
+ let q = QuantizadorNivel::novo(k, d, ModoQuant::SteEma, 0.99, "otima_teo", &dev)?;
415
+ let c = q.codebook()?.detach(); // (K, d) linhas ~ortonormais
416
+ let mut rng = crate::rng::RngDeterministico::novo(17);
417
+ // z ∈ span(C): z = xᵀ C (combinação aleatória das linhas)
418
+ let coef: Vec<f32> = (0..n * k).map(|_| rng.normal(0.0, 1.0) as f32).collect();
419
+ let x = Tensor::from_vec(coef, (n, k), &dev)?;
420
+ let z = x.matmul(&c)?; // (n, d) — exatamente no span
421
+ let tn = q.contracao_empirica(&z)?;
422
+ assert!(tn.fracao_span > 0.999, "fração no span = {}", tn.fracao_span);
423
+ // A.1′(iii) com R* ponto a ponto: contração ÓTIMA ≤ cota no span
424
+ // (tolerância para a ortogonalidade aproximada do codebook Stiefel):
425
+ assert!(tn.otima <= tn.cota + 0.02,
426
+ "contração ótima {} > cota {}", tn.otima, tn.cota);
427
+ // a medida operacional (escala EMA) fica na mesma vizinhança:
428
+ assert!(tn.medida < 1.0, "contração medida = {}", tn.medida);
429
+ // resíduo finito e não-negativo
430
+ let rho = q.residuo_ste(&z)?;
431
+ assert!(rho.is_finite() && rho >= 0.0);
432
+ Ok(())
433
+ }
434
+
435
+ /// A.0′: ρ² = E‖z − r_h‖² ≥ 0; z JÁ quantizável (z = R·c_j) ⇒ ρ ≈ 0.
436
+ #[test]
437
+ fn a0_residuo_ste_zero_em_codigo() -> Result<()> {
438
+ let dev = Device::Cpu;
439
+ let (k, d) = (4usize, 8usize);
440
+ let mut q = QuantizadorNivel::novo(k, d, ModoQuant::SteEma, 0.99, "otima_teo", &dev)?;
441
+ let c = q.codebook()?.detach();
442
+ // força escala conhecida
443
+ q.r_escala = 1.0;
444
+ let z = c.affine(1.0, 0.0)?; // (K, d) — cada linha é um código
445
+ let rho = q.residuo_ste(&z)?;
446
+ assert!(rho < 1e-8, "resíduo em código exato = {rho}");
447
+ Ok(())
448
+ }
449
+
450
+ /// B.1 (proxy): dependência de uso ≈ 0 para códigos usados de forma
451
+ /// independente; > 0 quando o uso é correlacionado (diagnóstico do gap
452
+ /// TC — o valor exato de TC(c_ℓ|c_{<ℓ}) exige discriminador).
453
+ #[test]
454
+ fn b1_proxy_dependencia_uso() -> Result<()> {
455
+ let dev = Device::Cpu;
456
+ let (k, d) = (5usize, 8usize);
457
+ let q = QuantizadorNivel::novo(k, d, ModoQuant::SteEma, 0.99, "otima_teo", &dev)?;
458
+ let mut rng = crate::rng::RngDeterministico::novo(23);
459
+ // independente: ids uniformes iid — MI plug-in ≈ viés O((K−1)²/n)
460
+ let indep: Vec<u32> = (0..16384).map(|_| (rng.uniforme() * k as f64) as u32).collect();
461
+ let ti = Tensor::from_vec(indep, (16384,), &dev)?;
462
+ let di = q.dependencia_uso(&ti)?;
463
+ // dependente: cadeia de Markov (P[repetir] = 0.6, senão uniforme)
464
+ // MI teórico ≈ ln 5 − H(next|prev) ≈ 1.609 − 1.227 ≈ 0.38 nats
465
+ let mut corr = Vec::with_capacity(16384);
466
+ let mut ultimo = 0u32;
467
+ for i in 0..16384 {
468
+ if i == 0 || rng.uniforme() < 0.6 {
469
+ ultimo = (rng.uniforme() * k as f64) as u32;
470
+ } else {
471
+ while ultimo == (rng.uniforme() * k as f64) as u32 {}
472
+ // nota: re-amostra até diferir — aproximação uniforme-condicional
473
+ }
474
+ corr.push(ultimo);
475
+ }
476
+ let tc = Tensor::from_vec(corr, (16384,), &dev)?;
477
+ let dc = q.dependencia_uso(&tc)?;
478
+ assert!(di < 0.02, "independente ⇒ MI ≈ viés plug-in (é {di})");
479
+ assert!(dc > 0.20, "cadeia de Markov ⇒ MI alto (é {dc})");
480
+ Ok(())
481
+ }
482
  use super::*;
483
 
484
  #[test]
 
577
  assert!(erro < 1e-4, "grad nativo vs op = {erro}\n n={g_n:?}\n o={g_o:?}");
578
  Ok(())
579
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
580
  }
src/simd.rs CHANGED
@@ -112,8 +112,16 @@ pub fn passo_adamw(
112
  let omb2 = 1.0f32 - b2;
113
  let usar_avx = tem_avx512() && n >= 64;
114
  if usar_avx {
115
- CHAMADAS_AVX.fetch_add(1, Ordering::Relaxed);
116
- unsafe { passo_adamw_avx(w, g, m, v, out, lr, b1, b2, eps, wd, bc1, bc2, omb1, omb2) };
 
 
 
 
 
 
 
 
117
  } else {
118
  CHAMADAS_ESCALAR.fetch_add(1, Ordering::Relaxed);
119
  }
 
112
  let omb2 = 1.0f32 - b2;
113
  let usar_avx = tem_avx512() && n >= 64;
114
  if usar_avx {
115
+ // v0.11: caminho ASSEMBLY primeiro (bit-a-bit, Teo X-1 estendido —
116
+ // mesma ordem de ops sem FMA); intrinsics de reserva se o asm
117
+ // não puder executar. Resultados idênticos em qualquer caminho.
118
+ let asm_executou = crate::asm_x86::passo_adamw_blocos(
119
+ w, g, m, v, out, lr, b1, b2, eps, wd, bc1, bc2, omb1, omb2,
120
+ );
121
+ if !asm_executou {
122
+ CHAMADAS_AVX.fetch_add(1, Ordering::Relaxed);
123
+ unsafe { passo_adamw_avx(w, g, m, v, out, lr, b1, b2, eps, wd, bc1, bc2, omb1, omb2) };
124
+ }
125
  } else {
126
  CHAMADAS_ESCALAR.fetch_add(1, Ordering::Relaxed);
127
  }
src/som4d.rs CHANGED
@@ -64,40 +64,15 @@ pub enum Topologia4D {
64
  VonNeumann,
65
  }
66
 
67
- /// Critério do passo de lote (v0.10.0, crítica DeepSeek S4-1 — provas em
68
- /// r-35 §2).
69
- ///
70
- /// A crítica é PROCEDENTE: a prova v0.5.0 usava a convexidade de `‖·‖²`
71
- /// para concluir sobre `‖·‖` (a QE pode SUBIR no regime σ grande —
72
- /// contraexemplo reproduzido no teste `s41_contraexemplo`). O teorema
73
- /// reparado (S4-1′) tem DUAS partes: (a) a `Φ` do kernel (EQM ponderado,
74
- /// objetivo REAL do passo) é NÃO-CRESCENTE INCONDICIONAL; (b) a QE está
75
- /// acoplada por `QE(a,P) ≤ √(Φ(P)/N)` (Cauchy-Schwarz) com frouxura
76
- /// controlada pelo cruzamento `e^{−1/2σ²}`.
77
- #[derive(Debug, Clone, Copy, PartialEq, Eq)]
78
- pub enum CriterioLote {
79
- /// Média ponderada pelo kernel — comportamento v0.5.0–v0.9.0
80
- /// (bit-a-bit). Minimiza `Φ_g` (EQM) exatamente; a QE (não-quadrada)
81
- /// pode subir no regime σ grande (S4-1′-b, teste s41_contraexemplo).
82
- Media,
83
- /// Mediana geométrica ponderada (Weiszfeld, v0.10.0) — alternativa
84
- /// sugerida pela crítica: minimiza `Ψ_g` (erro NÃO-quadrado ponderado)
85
- /// ⇒ a QE da atribuição congelada é não-crescente no MESMO sentido
86
- /// exato do S4-1′-a (a norma é convexa!). Custo: ~8 iterações
87
- /// Weiszfeld por célula. Opt-in (não substitui a média — a média
88
- /// organiza a grade mais rápido no início; ver r-35 §2.4 A/B).
89
- MedianaGeometrica,
90
- }
91
-
92
- /// Métrica de avaliação reportada (v0.10.0, pedido `criterio_qe` do
93
- /// aprimoramentos-arquitetura §3): `Distancia` = QE clássica
94
- /// `(1/N)Σ min ‖x−p‖`; `Quadratico` = EQM `(1/N)Σ min ‖x−p‖²`. Ambas são
95
- /// sempre COMPUTADAS na telemetria; o campo só escolhe qual entra em
96
- /// `eq_inicial/eq_final/historia` (compatibilidade de gates).
97
- #[derive(Debug, Clone, Copy, PartialEq, Eq)]
98
- pub enum CriterioQe {
99
- Distancia,
100
- Quadratico,
101
  }
102
 
103
  /// Configuração do 4D-SOM (todos os campos públicos; `Default` = grade 4×4×4×4).
@@ -121,14 +96,13 @@ pub struct CfgSom4D {
121
  pub inicializacao: Inicializacao4D,
122
  /// false ⇒ pula EQ/TE (medição de custo).
123
  pub calcular_metricas: bool,
124
- /// v0.10.0 — critério do passo de lote (S4-1′). Default `Media`
125
- /// (bit-a-bit com v0.9.0).
126
- pub criterio_lote: CriterioLote,
127
- /// v0.10.0 — métrica de avaliação (S4-1′). Default `Distancia`.
128
- pub criterio_qe: CriterioQe,
129
- /// v0.10.0 — nº de iterações Weiszfeld (modo MedianaGeometrica).
130
- pub weiszfeld_iters: usize,
131
  pub semente: u64,
 
 
 
 
 
 
132
  }
133
 
134
  impl Default for CfgSom4D {
@@ -141,10 +115,9 @@ impl Default for CfgSom4D {
141
  topologia: Topologia4D::Moore,
142
  inicializacao: Inicializacao4D::Dados,
143
  calcular_metricas: true,
144
- criterio_lote: CriterioLote::Media,
145
- criterio_qe: CriterioQe::Distancia,
146
- weiszfeld_iters: 8,
147
  semente: 42,
 
 
148
  }
149
  }
150
  }
@@ -161,14 +134,16 @@ pub struct Som4DTreinado {
161
  pub eq_inicial: f64,
162
  pub eq_final: f64,
163
  pub te_final: f64,
164
- pub historia: Vec<(f64, f64)>, // (EQ, TE) por época
165
- /// v0.10.0 (S4-1′): (Φ_antes, Φ_depois) por época — EQM ponderado pelo
166
- /// kernel com a atribuição CONGELADA da época. O teorema reparado
167
- /// afirma Φ_depois ≤ Φ_antes INCONDICIONAL (todos os σ, todos os η) —
168
- /// é isto que o gate `s41_phi_nao_cresce` verifica.
169
- pub historia_phi: Vec<(f64, f64)>,
170
- /// v0.10.0: EQM (não-quadrado → quadrático) final, sempre computado
171
- /// quando calcular_metricas (telemetria reporta ambos).
 
 
172
  pub eqm_final: f64,
173
  }
174
 
@@ -251,9 +226,7 @@ impl Som4DTreinado {
251
 
252
  fn self_topologia_vizinha(a: &[usize; 4], b: &[usize; 4]) -> bool {
253
  // Moore 4D: Chebyshev 1 em TODAS as dimensões, não-igual.
254
- // v0.11.0 (tratamento.txt): zip de arrays [usize;4] é SEMPRE não-vazio
255
- // — `.max()` com padrão explícito em vez de unwrap (à prova de mudança)
256
- let cheb = a.iter().zip(b).map(|(x, y)| (*x as i64 - *y as i64).abs()).max().unwrap_or(0);
257
  cheb <= 1 && a != b
258
  }
259
 
@@ -263,107 +236,14 @@ fn vizinhas_vn(a: &[usize; 4], b: &[usize; 4]) -> bool {
263
  manh == 1
264
  }
265
 
266
- /// Mediana geométrica PONDERADA por iteração de Weiszfeld (v0.10.0, crítica
267
- /// DeepSeek S4-1 — S4-1′-c em r-35 §2.3).
268
- ///
269
- /// `m^{(k+1)} = Σ_i ω_i x_i/‖m−x_i‖ / Σ_i ω_i/‖m−x_i‖` com guarda
270
- /// `‖m−x_i‖ ≥ δ` (evita 0/0 quando m coincide com um ponto — a correção de
271
- /// Vardi–Zhang é necessária só no ponto de dados EXATO, onde o algoritmo
272
- /// pára sozinho: ponto de dados é ponto fixo). Convergência: Weiszfeld
273
- /// clássico (descida estrita de `Ψ(m) = Σ ω_i‖x_i − m‖` exceto em pontos
274
- /// de dados); inicialização em `p_g` (o protótipo corrente) — no
275
- /// contraexemplo {0,10} com pesos iguais, TODO ponto do segmento é ponto
276
- /// fixo, logo o protótipo NÃO se move (a média iria para 5).
277
- fn mediana_geometrica_ponderada(
278
- pontos: &[(&Vec<f64>, f64)],
279
- inicio: &[f64],
280
- iters: usize,
281
- delta: f64,
282
- ) -> Vec<f64> {
283
- let d = inicio.len();
284
- let mut m = inicio.to_vec();
285
- for _ in 0..iters.max(1) {
286
- let mut num = vec![0.0f64; d];
287
- let mut den = 0.0f64;
288
- let mut algum_ponto = false;
289
- for (x, w) in pontos {
290
- if *w <= 0.0 {
291
- continue;
292
- }
293
- // ponto de dados exato: ponto fixo (condição de otimalidade
294
- // Vardi–Zhang — a massa no ponto domina)
295
- if m.iter().zip(x.iter()).all(|(a, b)| (a - b).abs() < delta) {
296
- algum_ponto = true;
297
- break;
298
- }
299
- let dist = (m.iter().zip(x.iter()).map(|(a, b)| (a - b) * (a - b)).sum::<f64>())
300
- .sqrt()
301
- .max(delta);
302
- for j in 0..d {
303
- num[j] += w * x[j] / dist;
304
- }
305
- den += w / dist;
306
- }
307
- if algum_ponto || den <= 1e-15 {
308
- break;
309
- }
310
- for j in 0..d {
311
- m[j] = num[j] / den;
312
- }
313
- }
314
- m
315
- }
316
-
317
- /// Φ do kernel (S4-1′-a): EQM ponderado `Φ(P) = Σ_g Σ_i w(a(x_i),g)·‖x_i − p_g‖²`
318
- /// com a atribuição `a` CONGELADA. Este é o objetivo que o passo de lote
319
- /// minimiza por célula — o teorema reparado afirma que Φ é não-crescente
320
- /// INCONDICIONALMENTE (a prova v0.5.0 era sobre a QE, o que é falso).
321
- fn phi_kernel(
322
- prototipos: &[Vec<f64>],
323
- xs: &[Vec<f64>],
324
- bmu_idx: &[usize],
325
- coords: &[[usize; 4]],
326
- sigma: f64,
327
- ) -> f64 {
328
- let sigma2 = 2.0 * sigma * sigma;
329
- let mut phi = 0.0;
330
- for (i, x) in xs.iter().enumerate() {
331
- let cb = coords[bmu_idx[i]];
332
- for (g, cg) in coords.iter().enumerate() {
333
- let dg2: f64 = (0..4)
334
- .map(|k| (cg[k] as f64 - cb[k] as f64).powi(2))
335
- .sum();
336
- let w = (-dg2 / sigma2).exp();
337
- if w > 1e-12 {
338
- phi += w * distancia2(x, &prototipos[g]);
339
- }
340
- }
341
- }
342
- phi
343
- }
344
-
345
  /// Treina um 4D-SOM em modo lote determinístico.
346
  ///
347
- /// **Passo de lote (S4-1′, v0.10.0 — crítica DeepSeek procedente):** para
348
- /// cada época, cada amostra é atribuída ao BMU; o alvo da célula `g` é a
349
- /// média ponderada `m_g = Σ_i w_ig·x_i / Σ_i w_ig` (modo `Media`) ou a
350
- /// mediana geométrica ponderada (modo `MedianaGeometrica`), com
351
- /// `w_ig = h_σ(g, bmu(x_i))`; o protótipo move-se `p_g' = p_g + η(m_g − p_g)`.
352
- ///
353
- /// **S4-1′-a (incondicional):** `m_g` minimiza EXATAMENTE
354
- /// `Φ_g(p) = Σ_i w_ig·‖x_i − p‖²` (média) ou `Ψ_g(p) = Σ_i w_ig·‖x_i − p‖`
355
- /// (mediana) sobre todo `R^d`; pela convexidade de `p ↦ Φ_g` (soma de
356
- /// normas quadradas) e da mistura convexa,
357
- /// `Φ_g(p'_g) ≤ (1−η)Φ_g(p_g) + ηΦ_g(m_g) ≤ Φ_g(p_g)` — SOMANDO em g, a Φ
358
- /// total é não-crescente, para TODO σ e TODO η ∈ [0,1] (gate
359
- /// `historia_phi`). **S4-1′-b:** a QE (não-quadrada) NÃO é controlada por
360
- /// este argumento — pode subir no regime σ grande (contraexemplo da
361
- /// crítica, gate `s41_contraexemplo`); a ponte é
362
- /// `QE(a,P)² ≤ Φ(P)/N` (Cauchy-Schwarz) e o termo cruzado de mistura é
363
- /// `≤ e^{−1/2σ²}·N·D²` (vizinho mais próximo a distância de grade ≥ 1).
364
- /// **S4-1′-c:** com `MedianaGeometrica`, o MESMO argumento vale para Ψ
365
- /// (norma é convexa) ⇒ QE da atribuição congelada não-crescente no
366
- /// sentido exato de Ψ. Re-atribuição só pode diminuir o min.
367
  pub fn treinar_som4d(dados: &Tensor, cfg: &CfgSom4D, _dev: &Device) -> candle_core::Result<Som4DTreinado> {
368
  let xs = para_matriz(dados)?;
369
  let n = xs.len();
@@ -430,7 +310,7 @@ pub fn treinar_som4d(dados: &Tensor, cfg: &CfgSom4D, _dev: &Device) -> candle_co
430
 
431
  let (eq_inicial, _) = eq_te(&prototipos);
432
  let mut historia = Vec::new();
433
- let mut historia_phi: Vec<(f64, f64)> = Vec::new();
434
 
435
  let mut massa = vec![0.0f64; c];
436
  for epoca in 0..cfg.epocas {
@@ -438,9 +318,6 @@ pub fn treinar_som4d(dados: &Tensor, cfg: &CfgSom4D, _dev: &Device) -> candle_co
438
  let sigma = cfg.sigma0 * (cfg.sigma1 / cfg.sigma0).powf(frac);
439
  let eta = cfg.eta0 + (cfg.eta1 - cfg.eta0) * frac;
440
  let sigma2 = 2.0 * sigma * sigma;
441
- // S4-1′: protótipos ANTES do passo (para medir Φ_antes com a
442
- // atribuição congelada da época)
443
- let prototipos_antes: Vec<Vec<f64>> = prototipos.clone();
444
 
445
  // atribuição (BMU) — congelada nesta época.
446
  // v0.9.0 (medição honesta, r-34 §6.4): o caminho escalar contíguo
@@ -473,46 +350,38 @@ pub fn treinar_som4d(dados: &Tensor, cfg: &CfgSom4D, _dev: &Device) -> candle_co
473
  }
474
  }
475
  }
476
- // atualização por critério (S4-1′): Media = média ponderada (exato
477
- // para Φ, bit-a-bit v0.9.0); MedianaGeometrica = Weiszfeld (exato
478
- // para Ψ, o erro NÃO-quadrado — pedido da crítica DeepSeek)
479
- match cfg.criterio_lote {
480
- CriterioLote::Media => {
481
- for g in 0..c {
482
- if den[g] > 1e-12 {
483
- for j in 0..d {
484
- let alvo = num[g][j] / den[g];
485
- prototipos[g][j] += eta * (alvo - prototipos[g][j]);
486
- }
487
  }
488
  }
489
  }
490
- CriterioLote::MedianaGeometrica => {
491
- // pontos+pesses por célula (os mesmos pesos do kernel)
492
- for g in 0..c {
493
- let mut pts: Vec<(&Vec<f64>, f64)> = Vec::new();
494
- for (i, x) in xs.iter().enumerate() {
495
- let cb = coords[bmu_idx[i]];
496
- let cg = coords[g];
497
- let dg2: f64 = (0..4)
498
- .map(|k| (cg[k] as f64 - cb[k] as f64).powi(2))
499
- .sum();
500
- let w = (-dg2 / sigma2).exp();
501
- if w > 1e-12 {
502
- pts.push((x, w));
503
- }
504
- }
505
- if !pts.is_empty() {
506
- let m = mediana_geometrica_ponderada(
507
- &pts,
508
- &prototipos[g],
509
- cfg.weiszfeld_iters,
510
- 1e-12,
511
- );
512
- for j in 0..d {
513
- prototipos[g][j] += eta * (m[j] - prototipos[g][j]);
514
- }
515
- }
516
  }
517
  }
518
  }
@@ -530,59 +399,94 @@ pub fn treinar_som4d(dados: &Tensor, cfg: &CfgSom4D, _dev: &Device) -> candle_co
530
  if cfg.calcular_metricas {
531
  let (eq, te) = eq_te(&prototipos);
532
  historia.push((eq, te));
533
- // S4-1′-a: Φ antes/depois com a atribuição CONGELADA desta época
534
- let phi_antes = phi_kernel(&prototipos_antes, &xs, &bmu_idx, &coords, sigma);
535
- let phi_depois = phi_kernel(&prototipos, &xs, &bmu_idx, &coords, sigma);
536
- historia_phi.push((phi_antes, phi_depois));
 
 
 
537
  }
538
  }
539
  let (eq_final, te_final) = eq_te(&prototipos);
540
-
541
- // EQM final (métrica quadrática — sempre reportada, S4-1′)
542
- let eqm_final = if cfg.calcular_metricas {
543
- let mut q = 0.0;
544
- for x in &xs {
545
- let (_, d2) = {
546
- let mut melhor = (0usize, f64::INFINITY);
547
- for (i, p_) in prototipos.iter().enumerate() {
548
- let dd = distancia2(x, p_);
549
- if dd < melhor.1 {
550
- melhor = (i, dd);
551
- }
552
- }
553
- melhor
554
- };
555
- q += d2;
556
- }
557
- q / n as f64
558
- } else {
559
- f64::NAN
560
- };
561
- // métrica de saída segundo o critério escolhido (compatibilidade: o
562
- // default Distancia reproduz os valores v0.9.0 bit-a-bit)
563
- let (eq_inicial_rep, eq_final_rep, historia_rep) = match cfg.criterio_qe {
564
- CriterioQe::Distancia => (eq_inicial, eq_final, historia),
565
- CriterioQe::Quadratico => {
566
- let esc = |h: Vec<(f64, f64)>| -> Vec<(f64, f64)> {
567
- h.into_iter().map(|(q, t)| (q * q, t)).collect()
568
- };
569
- (eq_inicial * eq_inicial, eq_final * eq_final, esc(historia))
570
  }
571
- };
 
 
 
572
  Ok(Som4DTreinado {
573
  prototipos,
574
  nx: cfg.nx, ny: cfg.ny, nz: cfg.nz, nt: cfg.nt,
575
  d,
576
  massa,
577
- eq_inicial: eq_inicial_rep,
578
- eq_final: eq_final_rep,
579
  te_final,
580
- historia: historia_rep,
581
- historia_phi,
 
582
  eqm_final,
583
  })
584
  }
585
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
586
  fn melhor_indice(ps: &[Vec<f64>], x: &[f64]) -> usize {
587
  let mut melhor = 0usize;
588
  let mut dm = f64::INFINITY;
@@ -688,17 +592,11 @@ pub struct CfgTSom {
688
  pub gamma: f64,
689
  /// janela de streaming (tamanho do lote por passo).
690
  pub janela: usize,
691
- /// v0.10.0 (crítica DeepSeek T-1 — procedente): taxa η do passo de
692
- /// rastreio, ANTES hard-coded 0.1. A cota correta do lag estacionário
693
- /// é `δ·γ/(1−γ) + δ/η` (T-1′, r-35 §2.5): o termo `δ/η` do EMA do
694
- /// PROTÓTIPO faltava na prova v0.5.0 (que somava apenas `δ` do passo
695
- /// corrente). Default 0.1 = compatibilidade bit-a-bit.
696
- pub eta_rastreio: f64,
697
  }
698
 
699
  impl Default for CfgTSom {
700
  fn default() -> Self {
701
- Self { cfg_grade: CfgSom4D::default(), gamma: 0.97, janela: 64, eta_rastreio: 0.1 }
702
  }
703
  }
704
 
@@ -707,8 +605,6 @@ pub struct TSom4D {
707
  /// massa temporal esquecida `m_g = Σ γ^(t_agora − t_i)·1[bmu_i = g]`
708
  pub massa_temporal: Vec<f64>,
709
  pub gamma: f64,
710
- /// v0.10.0: taxa de rastreio η (T-1′) — antes hard-coded 0.1.
711
- pub eta_rastreio: f64,
712
  /// t-counter global.
713
  pub t: u64,
714
  /// histórico do EQ temporal (pesado por recência) para telemetria.
@@ -730,7 +626,6 @@ impl TSom4D {
730
  som,
731
  massa_temporal,
732
  gamma: cfg.gamma,
733
- eta_rastreio: cfg.eta_rastreio.clamp(1e-3, 1.0),
734
  t: 0,
735
  eq_temporal_historico: Vec::new(),
736
  })
@@ -739,20 +634,19 @@ impl TSom4D {
739
  /// Um passo de streaming: recebe janela nova, atualiza protótipos com
740
  /// pesos `γ^idade` e a massa temporal.
741
  ///
742
- /// **Rastreio (T-1′, v0.10.0 — crítica DeepSeek procede):** com
743
- /// `p ← p + η(m − p)` e `m` derivando δ/passo, o lag estacionário do
744
- /// protótipo satisfaz `L = δ + (1−η)L ⇒ L = δ/η` (EMA do protótipo);
745
- /// somando o atraso `δ·γ/(1−γ)` do centróide da janela, o erro de
746
- /// rastreio total é `≤ δ·γ/(1−γ) + δ/η`. A cota v0.5.0
747
- /// (`δ/(1−γ)`, sem o fator 1/η) SUBESTIMAVA o lag por `δ·(1/η − 1)`
748
- /// — com η=0.1, por ~9δ. O gate `t1_termo_um_sobre_eta` mede a
749
- /// diferença de lag entre η=1 e η=0.1 e confirma o termo δ/η.
750
  pub fn passo(&mut self, janela: &[Vec<f64>]) -> f64 {
751
  let c = self.som.n_celulas();
752
  let d = self.som.d;
753
  let sigma = self.som.cfg_sigma_corrente(); // σ fixo de rastreio
754
  let sigma2 = 2.0 * sigma * sigma;
755
- let eta = self.eta_rastreio; // v0.10.0: configurável (T-1′)
756
 
757
  // decaimento da massa temporal
758
  for m in massa_iter_mut(&mut self.massa_temporal) {
@@ -1042,7 +936,7 @@ pub fn treinar_gng(dados: &Tensor, cfg: &CfgGng) -> candle_core::Result<GngTrein
1042
  let q = erro
1043
  .iter()
1044
  .enumerate()
1045
- .max_by(|a, b| a.1.total_cmp(b.1))
1046
  .map(|(i, _)| i)
1047
  .unwrap_or(0);
1048
  let viz_q: Vec<usize> = arestas
@@ -1052,7 +946,7 @@ pub fn treinar_gng(dados: &Tensor, cfg: &CfgGng) -> candle_core::Result<GngTrein
1052
  .collect();
1053
  if let Some(&f) = viz_q
1054
  .iter()
1055
- .max_by(|&&a, &&b| erro[a].total_cmp(&erro[b]))
1056
  {
1057
  let novo = vertices.len();
1058
  let meio: Vec<f64> = (0..d)
@@ -1099,14 +993,13 @@ pub struct CfgHSom {
1099
  /// nº de sub-células por célula grossa (grade fina por célula).
1100
  pub celulas_finas: usize,
1101
  pub epocas_finas: usize,
1102
- /// v0.10.0 (crítica DeepSeek H-1(c), r-35 §2.6): reserva o slot fino
1103
- /// 0 de cada célula como CÓPIA PERMANENTE do protótipo grosso `q_c`
1104
- /// (nunca atualizado, nunca re-semeado). Com isto o BMU fino pode
1105
- /// SEMPRE escolher `q_c` ⇒ `QE_hier ≤ QE_grosso` vira TEOREMA (a
1106
- /// parte (c) era regularidade empírica na v0.5.0 — a re-semeadura de
1107
- /// células vazias podia remover q_c do conjunto). Default false =
1108
- /// comportamento v0.9.0 bit-a-bit.
1109
- pub reservar_grosso: bool,
1110
  }
1111
 
1112
  impl Default for CfgHSom {
@@ -1115,7 +1008,7 @@ impl Default for CfgHSom {
1115
  cfg_grosso: CfgSom4D { nx: 3, ny: 3, nz: 2, nt: 2, epocas: 30, ..Default::default() },
1116
  celulas_finas: 9,
1117
  epocas_finas: 20,
1118
- reservar_grosso: false,
1119
  }
1120
  }
1121
  }
@@ -1139,16 +1032,11 @@ impl HSomTreinado {
1139
 
1140
  /// Treina o H-SOM: mapa grosso + sub-mapas finos por célula.
1141
  ///
1142
- /// **Teo H-1′ (v0.10.0, crítica DeepSeek H-1(b) — parcialmente procedente):**
1143
- /// sub-mapas inicializados com TODOS os protótipos no protótipo grosso `q_c`
1144
- /// ⇒ QE_hierárquico inicial = QE_grosso exatamente (a). A cota da família
1145
- /// `(a+b)²` é `QE_hier ≤ (√QE_grosso + √R_fino)²` — a MAIS JUSTA das três
1146
- /// (triangular + Cauchy–Schwarz); as cotas usadas na v0.5.0
1147
- /// (`QE + 2R + 2√(QE·R)`) e a proposta pela crítica (`2QE + 2R`) são ambas
1148
- /// VÁLIDAS mas frouxas: a nossa era frouxa por exatamente `R`; a da crítica
1149
- /// é mais justa que a nossa só quando `QE < 4R` (e mais frouxa que a ótima
1150
- /// sempre, por AM-GM). (c) com `reservar_grosso = true` vira teorema:
1151
- /// `QE_hier ≤ QE_grosso` garantido (o slot 0 é q_c permanente).
1152
  pub fn treinar_hsom(dados: &Tensor, cfg: &CfgHSom, dev: &Device) -> candle_core::Result<HSomTreinado> {
1153
  let xs = para_matriz(dados)?;
1154
  let n = xs.len();
@@ -1172,9 +1060,6 @@ pub fn treinar_hsom(dados: &Tensor, cfg: &CfgHSom, dev: &Device) -> candle_core:
1172
  continue;
1173
  }
1174
  let k = cfg.celulas_finas;
1175
- // v0.10.0 (H-1′-c): com reservar_grosso, o slot 0 NUNCA é
1176
- // atualizado nem re-semeado — cópia permanente de q_c (teorema)
1177
- let f_ini = if cfg.reservar_grosso { 1 } else { 0 };
1178
  // atribuição fina inicial: tudo na célula 0 (protótipos iguais)
1179
  for _epoca in 0..cfg.epocas_finas {
1180
  let mut somas: Vec<Vec<f64>> = vec![vec![0.0; d]; k];
@@ -1188,31 +1073,28 @@ pub fn treinar_hsom(dados: &Tensor, cfg: &CfgHSom, dev: &Device) -> candle_core:
1188
  }
1189
  // atualiza células ocupadas; células vazias ficam para trás
1190
  // (re-inicializa no ponto mais distante — estratégia k-means++)
1191
- for f in f_ini..k {
1192
- if conts[f] > 0.0 {
 
 
1193
  for j in 0..d {
1194
  finos[g][f][j] = somas[f][j] / conts[f];
1195
  }
1196
  }
1197
  }
1198
  // re-semeia células vazias nos piores pontos (evita degeneração)
1199
- for f in f_ini..k {
1200
- if conts[f] == 0.0 {
1201
  let (pior, _) = pontos
1202
  .iter()
1203
  .enumerate()
1204
  .map(|(i, x)| (i, distancia2(x, &finos[g][melhor_indice(&finos[g], x)])))
1205
- .max_by(|a, b| a.1.total_cmp(&b.1))
1206
  .unwrap_or((0, 0.0));
1207
  finos[g][f] = pontos[pior].clone();
1208
  }
1209
  }
1210
  }
1211
- // H-1′-c: garante o slot 0 = q_c após todo o processo (defensivo —
1212
- // o loop acima já não o toca quando reservar_grosso)
1213
- if cfg.reservar_grosso {
1214
- finos[g][0] = grosso.prototipos[g].clone();
1215
- }
1216
  }
1217
 
1218
  // métricas: QE hierárquico, QE grosso, R_fino
@@ -1248,7 +1130,7 @@ fn quantizar_em(grosso: &Som4DTreinado, finos: &[Vec<Vec<f64>>], x: &[f64]) -> (
1248
  // ---------------------------------------------------------------------------
1249
 
1250
  pub fn versao() -> &'static str {
1251
- "som4d-0.10.0"
1252
  }
1253
 
1254
  #[cfg(test)]
@@ -1320,7 +1202,7 @@ mod testes {
1320
  let dados_iniciais: Vec<Vec<f64>> =
1321
  (0..128).map(|_| (0..3).map(|_| rng.normal(0.0, 0.5)).collect()).collect();
1322
  let t0 = tensor_de(&dados_iniciais, &dev);
1323
- 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 };
1324
  let mut tsom = TSom4D::novo(&t0, &cfg, &dev).unwrap();
1325
 
1326
  // deriva: +0.02 por janela em todas as dims
@@ -1414,251 +1296,177 @@ mod testes {
1414
  h.eq_grosso
1415
  );
1416
  }
1417
-
1418
- // -----------------------------------------------------------------
1419
- // v0.10.0 — S4-1′/T-1′/H-1′ (críticas DeepSeek SOM). Provas r-35 §2.
1420
- // -----------------------------------------------------------------
1421
-
 
 
 
 
1422
  #[test]
1423
- fn teste_s41_contraexemplo_qe_sobe_com_media() {
1424
- // CONTRAEXEMPLO da crítica DeepSeek, reproduzido (S4-1′-b): dados
1425
- // {0, 10}, 2 células inicializadas NOS dados (QE inicial = 0),
1426
- // σ gigante (kernel ≈ uniforme), η = 1 ⇒ ambos os protótipos vão
1427
- // para a média 5 ⇒ QE final = 5 > 0. A QE NÃO é não-crescente no
1428
- // regime σ grande — a prova v0.5.0 era INVÁLIDA (usava ‖·‖² para
1429
- // concluir sobre ‖·‖). O que NÃO cresce é a Φ (teste abaixo).
1430
- let dev = Device::Cpu;
1431
- let dados = vec![vec![0.0f64], vec![10.0f64]];
1432
- let t = tensor_de(&dados, &dev);
1433
- let cfg = CfgSom4D {
1434
- nx: 2, ny: 1, nz: 1, nt: 1,
1435
- epocas: 1,
1436
- sigma0: 1e9, sigma1: 1e9, // kernel ≈ uniforme (regime adverso)
1437
- eta0: 1.0, eta1: 1.0, // passo completo
1438
- inicializacao: Inicializacao4D::Dados,
1439
- semente: 1, // primeiro sample = dados[0]=0, segundo = dados[1]=10
1440
- calcular_metricas: true,
1441
- ..Default::default()
1442
  };
1443
- let som = treinar_som4d(&t, &cfg, &dev).unwrap();
1444
- // protótipos nos dados ⇒ BMU exato ⇒ QE inicial = 0
1445
- assert!(
1446
- som.eq_inicial < 1e-12,
1447
- "qe inicial deveria ser 0 (protótipos nos dados), veio {}",
1448
- som.eq_inicial
1449
- );
1450
- assert!(
1451
- som.eq_final > 1.0,
1452
- "contraexemplo: QE deve SUBIR no regime σ grande com média \
1453
- (veio {} — a crítica DeepSeek estaria refutada se isto falhar)",
1454
- som.eq_final
1455
- );
 
 
 
 
 
 
 
 
 
 
 
1456
  }
1457
 
 
 
1458
  #[test]
1459
- fn teste_s41_phi_nao_cresce_incondicional() {
1460
- // S4-1′-a (teorema reparado): a Φ do kernel (EQM ponderado com
1461
- // atribuição congelada) é NÃO-CRESCENTE em TODAS as épocas, no
1462
- // MESMO setup adversário do contraexemplo (σ gigante) E no regime
1463
- // normal (σ decrescente) — incondicional.
1464
- let dev = Device::Cpu;
1465
- for (s0, s1) in [(1e9f64, 1e9f64), (2.0, 0.5)] {
1466
- let mut rng = crate::rng::RngDeterministico::novo(33);
1467
- let mut dados: Vec<Vec<f64>> = Vec::new();
1468
- for c in [[-2.0, -2.0], [2.0, 2.0], [-2.0, 2.0], [2.0, -2.0]] {
1469
- for _ in 0..30 {
1470
- dados.push((0..2).map(|k| c[k] + rng.normal(0.0, 0.4)).collect());
1471
- }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1472
  }
1473
- let t = tensor_de(&dados, &dev);
1474
- let cfg = CfgSom4D {
1475
- nx: 2, ny: 2, nz: 1, nt: 1,
1476
- epocas: 6,
1477
- sigma0: s0, sigma1: s1,
1478
- eta0: 1.0, eta1: 0.3,
1479
- calcular_metricas: true,
1480
- ..Default::default()
1481
- };
1482
- let som = treinar_som4d(&t, &cfg, &dev).unwrap();
1483
- assert!(!som.historia_phi.is_empty());
1484
- for (ep, (antes, depois)) in som.historia_phi.iter().enumerate() {
1485
- assert!(
1486
- *depois <= *antes + 1e-9,
1487
- "S4-1′-a violado (σ={s0}->{s1}, época {ep}): Φ {antes} -> {depois}"
1488
- );
1489
  }
 
 
1490
  }
 
 
 
 
 
 
 
1491
  }
1492
 
 
 
 
1493
  #[test]
1494
- fn teste_weiszfeld_mediana_geometrica() {
1495
- // (a) 1D assimétrico {0, 1, 10}: a mediana geométrica é o ponto
1496
- // 1 (o meio exato) — Weiszfeld converge para lá.
1497
- let pts = vec![vec![0.0f64], vec![1.0], vec![10.0]];
1498
- let pares: Vec<(&Vec<f64>, f64)> = pts.iter().map(|p| (p, 1.0)).collect();
1499
- let m = mediana_geometrica_ponderada(&pares, &[5.0], 50, 1e-12);
1500
- assert!((m[0] - 1.0).abs() < 1e-6, "mediana 1D = {} (esperado 1)", m[0]);
1501
-
1502
- // (b) contraexemplo {0,10} pesos iguais, início em 1: TODO ponto
1503
- // do segmento (0,10) é ponto fixo ⇒ o protótipo NÃO se move — a
1504
- // QE é PRESERVADA (a média moveria para 5 e a QE subiria).
1505
- let pts = vec![vec![0.0f64], vec![10.0]];
1506
- let pares: Vec<(&Vec<f64>, f64)> = pts.iter().map(|p| (p, 1.0)).collect();
1507
- let m = mediana_geometrica_ponderada(&pares, &[1.0], 30, 1e-12);
1508
- assert!((m[0] - 1.0).abs() < 1e-9, "ponto fixo violado: {}", m[0]);
1509
-
1510
- // (c) 2D triângulo: a mediana minimiza Σ‖x−v‖ — nenhuma perturbação
1511
- // próxima melhora (ótimo local = global, função convexa).
1512
- let tri = vec![vec![0.0, 0.0], vec![10.0, 0.0], vec![0.0, 10.0]];
1513
- let pares: Vec<(&Vec<f64>, f64)> = tri.iter().map(|p| (p, 1.0)).collect();
1514
- let m = mediana_geometrica_ponderada(&pares, &[3.0, 3.0], 200, 1e-12);
1515
- let soma = |p: &[f64]| -> f64 {
1516
- tri.iter().map(|v| ((v[0] - p[0]).powi(2) + (v[1] - p[1]).powi(2)).sqrt()).sum()
1517
- };
1518
- let f_m = soma(&m);
1519
- for dx in [-0.05f64, 0.05] {
1520
- for dy in [-0.05f64, 0.05] {
1521
- let q = vec![m[0] + dx, m[1] + dy];
1522
- assert!(
1523
- soma(&q) >= f_m - 1e-9,
1524
- "Weiszfeld não minimizou: {q:?} melhor que {m:?}"
1525
- );
1526
- }
1527
- }
1528
-
1529
- // (d) fim-a-fim: no setup do contraexemplo, o SOM com MedianaGeometrica
1530
- // NÃO aumenta a QE (a média aumenta).
1531
  let dev = Device::Cpu;
1532
- let dados = vec![vec![0.0f64], vec![10.0f64]];
1533
- let t = tensor_de(&dados, &dev);
 
1534
  let cfg = CfgSom4D {
1535
- nx: 2, ny: 1, nz: 1, nt: 1,
1536
- epocas: 1,
1537
- sigma0: 1e9, sigma1: 1e9,
1538
- eta0: 1.0, eta1: 1.0,
1539
- inicializacao: Inicializacao4D::Dados,
1540
- semente: 1,
1541
- calcular_metricas: true,
1542
- criterio_lote: CriterioLote::MedianaGeometrica,
1543
- weiszfeld_iters: 30,
1544
  ..Default::default()
1545
  };
1546
  let som = treinar_som4d(&t, &cfg, &dev).unwrap();
1547
- assert!(
1548
- som.eq_final <= som.eq_inicial + 1e-12,
1549
- "MedianaGeometrica: QE não-crescente no contraexemplo ({} -> {})",
1550
- som.eq_inicial,
1551
- som.eq_final
1552
- );
 
 
1553
  }
1554
 
 
 
 
 
 
1555
  #[test]
1556
- fn teste_t1_termo_um_sobre_eta() {
1557
- // T-1′ (crítica procede): deriva pura (sem ruído) δ=0.5/janela;
1558
- // γ=0.9. O lag estacionário do protótipo vencedor tem o termo δ/η:
1559
- // lag(η=0.1) − lag(η=1.0) ≈ δ·(1/0.1 − 1) = 4.5. A cota v0.5.0
1560
- // (sem 1/η) previa lag INDEPENDENTE de η — falsificado aqui.
1561
- let dev = Device::Cpu;
1562
- let medir_lag = |eta: f64| -> f64 {
1563
- let mut rng = crate::rng::RngDeterministico::novo(5);
1564
- // janela inicial: linha vertical (d=1) perto de 0
1565
- let j0: Vec<Vec<f64>> = (0..32).map(|_| vec![rng.normal(0.0, 0.05)]).collect();
1566
- let t0 = tensor_de(&j0, &dev);
1567
- let cfg = CfgTSom {
1568
- cfg_grade: CfgSom4D {
1569
- nx: 2, ny: 1, nz: 1, nt: 1,
1570
- epocas: 8,
1571
- sigma0: 0.8, sigma1: 0.8,
1572
- eta0: 1.0, eta1: 1.0,
1573
- inicializacao: Inicializacao4D::Dados,
1574
- ..Default::default()
1575
- },
1576
- gamma: 0.9,
1577
- janela: 32,
1578
- eta_rastreio: eta,
1579
- };
1580
- let mut tsom = TSom4D::novo(&t0, &cfg, &dev).unwrap();
1581
- let delta = 0.5f64;
1582
- let mut lags = Vec::new();
1583
- for w in 0..60 {
1584
- // deriva pura: janela w centrada em w·δ, sem ruído
1585
- let centro = (w + 1) as f64 * delta;
1586
- let jan: Vec<Vec<f64>> = (0..32)
1587
- .map(|i| vec![centro + (i as f64 - 16.0) * 0.001])
1588
- .collect();
1589
- tsom.passo(&jan);
1590
- // lag do protótipo mais próximo do centro corrente
1591
- let (b, _) = tsom.som.bmu(&[centro]);
1592
- lags.push((tsom.som.prototipos[b][0] - centro).abs());
1593
  }
1594
- // lag estacionário: média das últimas 20 janelas
1595
- lags[lags.len() - 20..].iter().sum::<f64>() / 20.0
1596
- };
1597
- let lag1 = medir_lag(1.0);
1598
- let lag01 = medir_lag(0.1);
1599
- let delta = 0.5f64;
1600
- let dif = lag01 - lag1;
1601
- // previsão T-1′: dif ≈ δ·(1/0.1 − 1) = 4.5 (tolerância ampla p/
1602
- // efeitos de janela finita); previsão v0.5.0: dif ≈ 0.
1603
- assert!(
1604
- dif > 2.0 * delta,
1605
- "termo δ/η ausente? lag(0.1)={lag1:.3} vs lag(1.0)={lag1:.3} \
1606
- — a cota v0.5.0 (sem 1/η) seria falsificada se dif≈0"
1607
- );
1608
- assert!(
1609
- dif < 12.0 * delta,
1610
- "lag(η=0.1)={lag01:.3} vs lag(η=1.0)={lag1:.3} fora da banda T-1′"
1611
- );
1612
- // o lag com η=1 é pequeno (≈ γ/(1−γ)·δ_amostra + δ)
1613
- assert!(lag1 < 2.0 * delta, "lag(η=1)={lag1:.3} deveria ser pequeno");
1614
  }
1615
 
 
 
1616
  #[test]
1617
- fn teste_h1_cota_otima_e_reserva() {
1618
- // H-1′(b): a cota MAIS JUSTA da família é (√QE + √R)² — valida
1619
- // numericamente e mostra que as outras duas são frouxas.
1620
  let dev = Device::Cpu;
1621
  let mut rng = crate::rng::RngDeterministico::novo(21);
1622
- let mut dados: Vec<Vec<f64>> = Vec::new();
1623
- 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]] {
1624
- for _ in 0..50 {
1625
- dados.push((0..3).map(|k| c[k] + rng.normal(0.0, 0.5)).collect());
1626
- }
1627
- }
1628
- let t = tensor_de(&dados, &dev);
1629
- let h = treinar_hsom(&t, &CfgHSom::default(), &dev).unwrap();
1630
- let otima = (h.eq_grosso.sqrt() + h.r_fino.sqrt()).powi(2);
1631
- let antiga = h.eq_grosso + 2.0 * h.r_fino + 2.0 * (h.eq_grosso * h.r_fino).sqrt();
1632
- let deepseek = 2.0 * h.eq_grosso + 2.0 * h.r_fino;
1633
- assert!(
1634
- h.eq_hierarquico <= otima + 1e-9,
1635
- "QE_hier={} > cota ótima (√QE+√R)²={}",
1636
- h.eq_hierarquico,
1637
- otima
1638
- );
1639
- // a ótima domina AMBAS as alternativas (AM-GM + antiga = ótima + R)
1640
- assert!(otima <= deepseek + 1e-12, "ótima {otima} > 2QE+2R {deepseek}");
1641
- assert!(
1642
- (antiga - otima - h.r_fino).abs() < 1e-9,
1643
- "cota v0.5.0 deveria ser ótima + R exatamente"
1644
- );
1645
-
1646
- // H-1′-c: com reservar_grosso, QE_hier ≤ QE_grosso é TEOREMA —
1647
- // o slot 0 é q_c permanente (verifica também a cópia).
1648
- let mut cfg = CfgHSom::default();
1649
- cfg.reservar_grosso = true;
1650
- let h2 = treinar_hsom(&t, &cfg, &dev).unwrap();
1651
- assert!(
1652
- h2.eq_hierarquico <= h2.eq_grosso + 1e-12,
1653
- "reserva: QE_hier {} > QE_grosso {} (teorema violado)",
1654
- h2.eq_hierarquico,
1655
- h2.eq_grosso
1656
- );
1657
- for (g, fino) in h2.finos.iter().enumerate() {
1658
- assert_eq!(
1659
- fino[0], h2.grosso.prototipos[g],
1660
- "slot 0 deve ser cópia permanente de q_c"
1661
- );
1662
- }
1663
  }
1664
- }
 
64
  VonNeumann,
65
  }
66
 
67
+ /// Critério de atualização dos protótipos (r-36 — S4-1′/S4-2).
68
+ #[derive(Debug, Clone)]
69
+ pub enum CriterioPrototipo4D {
70
+ /// Média ponderada pela vizinhança (regime suave — padrão histórico;
71
+ /// garantia de monotonia em E_σ, Teo S4-1′(b) r-36).
72
+ MediaSuave,
73
+ /// Atribuição DURA + mediana geométrica por Weiszfeld (r-36 S4-2):
74
+ /// garantia de monotonia em **QE** — `QE(P_{t+1}) ≤ QE(P_t)` ∀η∈[0,1].
75
+ MedianaDura,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
76
  }
77
 
78
  /// Configuração do 4D-SOM (todos os campos públicos; `Default` = grade 4×4×4×4).
 
96
  pub inicializacao: Inicializacao4D,
97
  /// false ⇒ pula EQ/TE (medição de custo).
98
  pub calcular_metricas: bool,
 
 
 
 
 
 
 
99
  pub semente: u64,
100
+ /// Critério de atualização dos protótipos (r-36): `MediaSuave` = padrão
101
+ /// histórico (bit-a-bit compatível); `MedianaDura` = Weiszfeld com
102
+ /// garantia QE não-crescente (S4-2) — ADIÇÃO opt-in, não substituição.
103
+ pub criterio: CriterioPrototipo4D,
104
+ /// Iterações de Weiszfeld por célula (modo MedianaDura; ε=1e-12).
105
+ pub weiszfeld_iters: usize,
106
  }
107
 
108
  impl Default for CfgSom4D {
 
115
  topologia: Topologia4D::Moore,
116
  inicializacao: Inicializacao4D::Dados,
117
  calcular_metricas: true,
 
 
 
118
  semente: 42,
119
+ criterio: CriterioPrototipo4D::MediaSuave,
120
+ weiszfeld_iters: 20,
121
  }
122
  }
123
  }
 
134
  pub eq_inicial: f64,
135
  pub eq_final: f64,
136
  pub te_final: f64,
137
+ pub historia: Vec<(f64, f64)>, // (QE, TE) por época
138
+ /// v0.11 (r-36 S4-1′): EQM por época — a métrica com garantia de
139
+ /// monotonia no regime de atribuição DURA (a QE NÃO tem garantia no
140
+ /// regime suave — contraexemplo `s41_contraexemplo_qe_eqm`).
141
+ pub historia_eqm: Vec<f64>,
142
+ /// v0.11 (r-36): energia SOM E_σ final com σ CONGELADO em σ1 (janela de
143
+ /// auditoria — comparar épocas com σ diferente não é comparação de
144
+ /// energia fixa; limitação honesta nº 3 de r-36).
145
+ pub e_sigma_final: f64,
146
+ /// EQM final (atribuição dura): (1/N)Σ min_g ‖x−p_g‖².
147
  pub eqm_final: f64,
148
  }
149
 
 
226
 
227
  fn self_topologia_vizinha(a: &[usize; 4], b: &[usize; 4]) -> bool {
228
  // Moore 4D: Chebyshev 1 em TODAS as dimensões, não-igual.
229
+ let cheb = a.iter().zip(b).map(|(x, y)| (*x as i64 - *y as i64).abs()).max().unwrap();
 
 
230
  cheb <= 1 && a != b
231
  }
232
 
 
236
  manh == 1
237
  }
238
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
239
  /// Treina um 4D-SOM em modo lote determinístico.
240
  ///
241
+ /// **Passo de lote (prova S4-1):** para cada época, cada amostra é atribuída
242
+ /// ao BMU; o novo protótipo da célula `g` é
243
+ /// `p_g' = Σ_i w_ig·x_i / Σ_i w_ig` com `w_ig = h_σ(g, bmu(x_i))` (kernel
244
+ /// gaussiano na grade 4D centrado no BMU da amostra). Com atribuição
245
+ /// congelada, `‖x_i − p'_{bmu(i)}‖ ≤ Σ_g w_ig·‖x_i − p_g‖/Σ_g w_ig` por
246
+ /// convexidade ⇒ EQ não-crescente. Re-atribuição só pode diminuir o min.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
247
  pub fn treinar_som4d(dados: &Tensor, cfg: &CfgSom4D, _dev: &Device) -> candle_core::Result<Som4DTreinado> {
248
  let xs = para_matriz(dados)?;
249
  let n = xs.len();
 
310
 
311
  let (eq_inicial, _) = eq_te(&prototipos);
312
  let mut historia = Vec::new();
313
+ let mut historia_eqm = Vec::new();
314
 
315
  let mut massa = vec![0.0f64; c];
316
  for epoca in 0..cfg.epocas {
 
318
  let sigma = cfg.sigma0 * (cfg.sigma1 / cfg.sigma0).powf(frac);
319
  let eta = cfg.eta0 + (cfg.eta1 - cfg.eta0) * frac;
320
  let sigma2 = 2.0 * sigma * sigma;
 
 
 
321
 
322
  // atribuição (BMU) — congelada nesta época.
323
  // v0.9.0 (medição honesta, r-34 §6.4): o caminho escalar contíguo
 
350
  }
351
  }
352
  }
353
+ // atualização: média ponderada misturada com η (Suave)
354
+ if matches!(cfg.criterio, CriterioPrototipo4D::MediaSuave) {
355
+ for g in 0..c {
356
+ if den[g] > 1e-12 {
357
+ for j in 0..d {
358
+ let alvo = num[g][j] / den[g];
359
+ prototipos[g][j] += eta * (alvo - prototipos[g][j]);
 
 
 
 
360
  }
361
  }
362
  }
363
+ } else {
364
+ // r-36 S4-2: atribuição DURA + mediana geométrica (Weiszfeld).
365
+ // Teorema: QE(P_{t+1}) ≤ QE(P_t) ∀η∈[0,1] — (i) cada passo de
366
+ // Weiszfeld não aumenta Σ‖x−m‖ (MM com majorante ‖u‖²/(2a)+a/2,
367
+ // igualdade em a=‖u‖; o clamp a≥ε mantém o majorante válido:
368
+ // (s−ε)²/(2ε) ≥ 0); (ii) blend convexo entre dois pontos com
369
+ // QE(m)≤QE(p) (convexidade da NORM — uso correto aqui, o
370
+ // minimizador é o da soma de distâncias); (iii) re-atribuição
371
+ // só diminui o min. ∎ (prova completa em r-36.)
372
+ let mut celulas: Vec<Vec<usize>> = vec![Vec::new(); c];
373
+ for (i, &b) in bmu_idx.iter().enumerate() {
374
+ celulas[b].push(i);
375
+ }
376
+ for g in 0..c {
377
+ if celulas[g].is_empty() {
378
+ continue;
379
+ }
380
+ let pontos: Vec<Vec<f64>> =
381
+ celulas[g].iter().map(|&i| xs[i].clone()).collect();
382
+ let m = mediana_geometrica(&pontos, cfg.weiszfeld_iters, 1e-12);
383
+ for j in 0..d {
384
+ prototipos[g][j] += eta * (m[j] - prototipos[g][j]);
 
 
 
 
385
  }
386
  }
387
  }
 
399
  if cfg.calcular_metricas {
400
  let (eq, te) = eq_te(&prototipos);
401
  historia.push((eq, te));
402
+ // EQM por época (S4-1′(a): monotono no regime duro)
403
+ let mut e2 = 0.0;
404
+ for x in &xs {
405
+ let b = melhor_indice(&prototipos, x);
406
+ e2 += distancia2(x, &prototipos[b]);
407
+ }
408
+ historia_eqm.push(e2 / n as f64);
409
  }
410
  }
411
  let (eq_final, te_final) = eq_te(&prototipos);
412
+ // auditoria final: EQM e E_σ com σ congelado em σ1 (r-36 §S4-1′)
413
+ let mut e2 = 0.0;
414
+ let sigma_audit = cfg.sigma1;
415
+ let sigma2a = 2.0 * sigma_audit * sigma_audit;
416
+ let mut e_sigma = 0.0;
417
+ for x in &xs {
418
+ let b = melhor_indice(&prototipos, x);
419
+ e2 += distancia2(x, &prototipos[b]);
420
+ let cb = coords[b];
421
+ for (g, cg) in coords.iter().enumerate() {
422
+ let dg2: f64 = (0..4)
423
+ .map(|k| (cg[k] as f64 - cb[k] as f64).powi(2))
424
+ .sum();
425
+ let w = (-dg2 / sigma2a).exp();
426
+ if w > 1e-12 {
427
+ e_sigma += w * distancia2(x, &prototipos[g]);
428
+ }
 
 
 
 
 
 
 
 
 
 
 
 
 
429
  }
430
+ }
431
+ let eqm_final = e2 / n as f64;
432
+ let e_sigma_final = e_sigma / n as f64;
433
+
434
  Ok(Som4DTreinado {
435
  prototipos,
436
  nx: cfg.nx, ny: cfg.ny, nz: cfg.nz, nt: cfg.nt,
437
  d,
438
  massa,
439
+ eq_inicial,
440
+ eq_final,
441
  te_final,
442
+ historia,
443
+ historia_eqm,
444
+ e_sigma_final,
445
  eqm_final,
446
  })
447
  }
448
 
449
+ /// Mediana geométrica por Weiszfeld (r-36 S4-2) — minimizador de Σ‖xᵢ−m‖.
450
+ ///
451
+ /// **Prova de monotonia (MM):** para todo u e todo a>0,
452
+ /// ‖u‖ ≤ ‖u‖²/(2a) + a/2, com igualdade em a=‖u‖. Cada passo minimiza o
453
+ /// majorante quadrático com a = max(‖xᵢ−m⁽ᵏ⁾‖, ε) — o clamp preserva a
454
+ /// validade do majorante ((s−ε)²/(2ε) ≥ 0) e guarda o ponto fixo em dado
455
+ /// (‖·‖ < ε ⇒ peso 1/ε). O majorante toca a função no ponto corrente ⇒
456
+ /// Σ‖xᵢ−m⁽ᵏ⁺¹⁾‖ ≤ Σ‖xᵢ−m⁽ᵏ⁾‖. Custo: O(iters·|C_g|·d); ~10–30 iterações
457
+ /// para ε=1e-4. Init na média (qualquer init converge — MM é monotono).
458
+ pub fn mediana_geometrica(pontos: &[Vec<f64>], iters: usize, eps: f64) -> Vec<f64> {
459
+ debug_assert!(!pontos.is_empty(), "mediana_geometrica: vazio");
460
+ let d = pontos[0].len();
461
+ let mut m: Vec<f64> = vec![0.0; d];
462
+ for x in pontos {
463
+ for j in 0..d {
464
+ m[j] += x[j];
465
+ }
466
+ }
467
+ for v in m.iter_mut() {
468
+ *v /= pontos.len() as f64;
469
+ }
470
+ for _ in 0..iters {
471
+ let mut num = vec![0.0f64; d];
472
+ let mut den = 0.0f64;
473
+ for x in pontos {
474
+ let dist = distancia2(x, &m).sqrt().max(eps);
475
+ for j in 0..d {
476
+ num[j] += x[j] / dist;
477
+ }
478
+ den += 1.0 / dist;
479
+ }
480
+ if den <= 0.0 || !den.is_finite() {
481
+ break;
482
+ }
483
+ for j in 0..d {
484
+ m[j] = num[j] / den;
485
+ }
486
+ }
487
+ m
488
+ }
489
+
490
  fn melhor_indice(ps: &[Vec<f64>], x: &[f64]) -> usize {
491
  let mut melhor = 0usize;
492
  let mut dm = f64::INFINITY;
 
592
  pub gamma: f64,
593
  /// janela de streaming (tamanho do lote por passo).
594
  pub janela: usize,
 
 
 
 
 
 
595
  }
596
 
597
  impl Default for CfgTSom {
598
  fn default() -> Self {
599
+ Self { cfg_grade: CfgSom4D::default(), gamma: 0.97, janela: 64 }
600
  }
601
  }
602
 
 
605
  /// massa temporal esquecida `m_g = Σ γ^(t_agora − t_i)·1[bmu_i = g]`
606
  pub massa_temporal: Vec<f64>,
607
  pub gamma: f64,
 
 
608
  /// t-counter global.
609
  pub t: u64,
610
  /// histórico do EQ temporal (pesado por recência) para telemetria.
 
626
  som,
627
  massa_temporal,
628
  gamma: cfg.gamma,
 
629
  t: 0,
630
  eq_temporal_historico: Vec::new(),
631
  })
 
634
  /// Um passo de streaming: recebe janela nova, atualiza protótipos com
635
  /// pesos `γ^idade` e a massa temporal.
636
  ///
637
+ /// **Rastreio (prova T-1′, r-36 — cota APERTADA):** para deriva linear
638
+ /// δ/passo, filtro `m_t = γm_{t−1} + (1−γ)μ_t` e protótipo
639
+ /// `p_{t+1} = p_t + η(m_t − p_t)`, o atraso em regime estacionário é
640
+ /// `lag = δγ/(1−γ) + δ(1−η)/η ≤ δγ/(1−γ) + δ/η` (a cota antiga
641
+ /// `δ/(1−γ)` ignorava o fator 1/η — errata r-36; η=1 recupera o filtro
642
+ /// puro). Transiente: autovalores {γ, 1−η} ⊂ [0,1) ⇒ decaição
643
+ /// geométrica. Teste: `t1_cota_apertada` (medido = cota apertada).
 
644
  pub fn passo(&mut self, janela: &[Vec<f64>]) -> f64 {
645
  let c = self.som.n_celulas();
646
  let d = self.som.d;
647
  let sigma = self.som.cfg_sigma_corrente(); // σ fixo de rastreio
648
  let sigma2 = 2.0 * sigma * sigma;
649
+ let eta = 0.1; // taxa de rastreio
650
 
651
  // decaimento da massa temporal
652
  for m in massa_iter_mut(&mut self.massa_temporal) {
 
936
  let q = erro
937
  .iter()
938
  .enumerate()
939
+ .max_by(|a, b| a.1.partial_cmp(b.1).unwrap())
940
  .map(|(i, _)| i)
941
  .unwrap_or(0);
942
  let viz_q: Vec<usize> = arestas
 
946
  .collect();
947
  if let Some(&f) = viz_q
948
  .iter()
949
+ .max_by(|&&a, &&b| erro[a].partial_cmp(&erro[b]).unwrap())
950
  {
951
  let novo = vertices.len();
952
  let meio: Vec<f64> = (0..d)
 
993
  /// nº de sub-células por célula grossa (grade fina por célula).
994
  pub celulas_finas: usize,
995
  pub epocas_finas: usize,
996
+ /// v0.11 (r-36 H-1′(c)): fixa `finos[g][0] := protótipo grosso p_g`
997
+ /// (nunca atualizado nem re-semeado). TEOREMA: com o pin,
998
+ /// `EQ_hierárquico ≤ EQ_grosso` EXATO (o mínimo sobre um conjunto que
999
+ /// contém p_g é ≤ o valor em p_g) mesmo com re-semeadura k-means++ dos
1000
+ /// slots 1..k−1. Default `false` preserva o comportamento histórico
1001
+ /// bit-a-bit (a parte (c) SEM pin permanece conjectura — honesto).
1002
+ pub pin_slot0: bool,
 
1003
  }
1004
 
1005
  impl Default for CfgHSom {
 
1008
  cfg_grosso: CfgSom4D { nx: 3, ny: 3, nz: 2, nt: 2, epocas: 30, ..Default::default() },
1009
  celulas_finas: 9,
1010
  epocas_finas: 20,
1011
+ pin_slot0: false,
1012
  }
1013
  }
1014
  }
 
1032
 
1033
  /// Treina o H-SOM: mapa grosso + sub-mapas finos por célula.
1034
  ///
1035
+ /// **Teo H-1 (decomposição):** sub-mapas inicializados com TODOS os
1036
+ /// protótipos no protótipo grosso `q_c` ⇒ QE_hierárquico inicial = QE_grosso
1037
+ /// exatamente; cada passo de lote fino não aumenta a QE intra-célula ⇒
1038
+ /// `QE_hier ≤ QE_grosso + 2·R_fino + 2·sqrt(QE_grosso·R_fino)`
1039
+ /// (desenvolvimento de `(a+b)² ≤ 2a²+2b²`).
 
 
 
 
 
1040
  pub fn treinar_hsom(dados: &Tensor, cfg: &CfgHSom, dev: &Device) -> candle_core::Result<HSomTreinado> {
1041
  let xs = para_matriz(dados)?;
1042
  let n = xs.len();
 
1060
  continue;
1061
  }
1062
  let k = cfg.celulas_finas;
 
 
 
1063
  // atribuição fina inicial: tudo na célula 0 (protótipos iguais)
1064
  for _epoca in 0..cfg.epocas_finas {
1065
  let mut somas: Vec<Vec<f64>> = vec![vec![0.0; d]; k];
 
1073
  }
1074
  // atualiza células ocupadas; células vazias ficam para trás
1075
  // (re-inicializa no ponto mais distante — estratégia k-means++)
1076
+ // v0.11 (r-36 H-1′(c)): pin_slot0 congela o slot 0 em p_g — a
1077
+ // cobertura grossa nunca é perdida ⇒ EQ_hier ≤ EQ_grosso exato.
1078
+ for f in 0..k {
1079
+ if conts[f] > 0.0 && !(cfg.pin_slot0 && f == 0) {
1080
  for j in 0..d {
1081
  finos[g][f][j] = somas[f][j] / conts[f];
1082
  }
1083
  }
1084
  }
1085
  // re-semeia células vazias nos piores pontos (evita degeneração)
1086
+ for f in 0..k {
1087
+ if conts[f] == 0.0 && !(cfg.pin_slot0 && f == 0) {
1088
  let (pior, _) = pontos
1089
  .iter()
1090
  .enumerate()
1091
  .map(|(i, x)| (i, distancia2(x, &finos[g][melhor_indice(&finos[g], x)])))
1092
+ .max_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
1093
  .unwrap_or((0, 0.0));
1094
  finos[g][f] = pontos[pior].clone();
1095
  }
1096
  }
1097
  }
 
 
 
 
 
1098
  }
1099
 
1100
  // métricas: QE hierárquico, QE grosso, R_fino
 
1130
  // ---------------------------------------------------------------------------
1131
 
1132
  pub fn versao() -> &'static str {
1133
+ "som4d-0.11.0"
1134
  }
1135
 
1136
  #[cfg(test)]
 
1202
  let dados_iniciais: Vec<Vec<f64>> =
1203
  (0..128).map(|_| (0..3).map(|_| rng.normal(0.0, 0.5)).collect()).collect();
1204
  let t0 = tensor_de(&dados_iniciais, &dev);
1205
+ let cfg = CfgTSom { cfg_grade: CfgSom4D { nx: 3, ny: 3, nz: 2, nt: 2, epocas: 15, ..Default::default() }, gamma: 0.9, janela: 32 };
1206
  let mut tsom = TSom4D::novo(&t0, &cfg, &dev).unwrap();
1207
 
1208
  // deriva: +0.02 por janela em todas as dims
 
1296
  h.eq_grosso
1297
  );
1298
  }
1299
+ // ------------------------------------------------------------------
1300
+ // v0.11 — r-36: provas corrigidas (S4-1′, S4-2, T-1′, H-1′)
1301
+ // ------------------------------------------------------------------
1302
+
1303
+ /// S4-1′(b) CONTRAEXEMPLO (falsificação da crítica E da prova antiga):
1304
+ /// x={0,10}, p={1,9}, σ→∞ (w≡1) ⇒ m={5,5}. QE 1→5 (AUMENTA);
1305
+ /// EQM 1→25 (AUMENTA — "reformular para EQM" é INSUFICIENTE, errata da
1306
+ /// crítica r-18); E_σ 164→100 (DECRESCA — a quantidade monotona do
1307
+ /// regime suave é E_σ). Valores EXATOS do teorema.
1308
  #[test]
1309
+ fn s41_contraexemplo_qe_eqm() {
1310
+ let xs = vec![vec![0.0f64], vec![10.0]];
1311
+ let ps = vec![vec![1.0f64], vec![9.0]];
1312
+ // pesos w≡1 (σ→∞): média ponderada de cada protótipo = 5
1313
+ let eta = 1.0;
1314
+ let ps2: Vec<Vec<f64>> = ps
1315
+ .iter()
1316
+ .map(|p| {
1317
+ let m = 5.0f64;
1318
+ vec![p[0] + eta * (m - p[0])]
1319
+ })
1320
+ .collect();
1321
+ let qe = |ps: &[Vec<f64>]| -> f64 {
1322
+ xs.iter()
1323
+ .map(|x| {
1324
+ ps.iter().map(|p| (x[0] - p[0]).abs()).fold(f64::INFINITY, f64::min)
1325
+ })
1326
+ .sum::<f64>()
1327
+ / xs.len() as f64
1328
  };
1329
+ let eqm = |ps: &[Vec<f64>]| -> f64 {
1330
+ xs.iter()
1331
+ .map(|x| {
1332
+ ps.iter()
1333
+ .map(|p| (x[0] - p[0]).powi(2))
1334
+ .fold(f64::INFINITY, f64::min)
1335
+ })
1336
+ .sum::<f64>()
1337
+ / xs.len() as f64
1338
+ };
1339
+ let e_sigma = |ps: &[Vec<f64>]| -> f64 {
1340
+ // E_σ com w≡1: Σᵢ Σ_g ‖xᵢ−p_g‖²
1341
+ xs.iter()
1342
+ .map(|x| ps.iter().map(|p| (x[0] - p[0]).powi(2)).sum::<f64>())
1343
+ .sum()
1344
+ };
1345
+ assert!((qe(&ps) - 1.0).abs() < 1e-12, "QE antes = {}", qe(&ps));
1346
+ assert!((qe(&ps2) - 5.0).abs() < 1e-12, "QE depois = {} (AUMENTA)", qe(&ps2));
1347
+ assert!(qe(&ps2) > qe(&ps), "QE aumenta no regime suave — refutado");
1348
+ assert!((eqm(&ps) - 1.0).abs() < 1e-12);
1349
+ assert!((eqm(&ps2) - 25.0).abs() < 1e-12, "EQM também AUMENTA — errata da crítica");
1350
+ assert!((e_sigma(&ps) - 164.0).abs() < 1e-12, "E_σ antes = {}", e_sigma(&ps));
1351
+ assert!((e_sigma(&ps2) - 100.0).abs() < 1e-12);
1352
+ assert!(e_sigma(&ps2) < e_sigma(&ps), "E_σ DECRESCA — monotonia correta");
1353
  }
1354
 
1355
+ /// S4-2: Weiszfeld é MONÓTONO — Σ‖xᵢ−m⁽ᵏ⁾‖ não cresce em NENHUMA
1356
+ /// iteração (MM), e converge bem abaixo da média (200 iterações).
1357
  #[test]
1358
+ fn s42_weiszfeld_monotono() {
1359
+ let pontos: Vec<Vec<f64>> = (0..24)
1360
+ .map(|i| {
1361
+ let t = i as f64;
1362
+ if i % 3 == 0 { vec![0.1 * t, -0.05 * t] }
1363
+ else if i % 3 == 1 { vec![-0.2 * t, 0.3 * t] }
1364
+ else { vec![5.0 + 0.1 * t, 5.0 - 0.2 * t] }
1365
+ })
1366
+ .collect();
1367
+ let soma_dist = |m: &[f64]| -> f64 {
1368
+ pontos.iter().map(|x| distancia2(x, m).sqrt()).sum()
1369
+ };
1370
+ // trajetória manual (acesso ao estado interno por re-chamada com
1371
+ // init = média ⇒ 1 iteração por chamada em sequência)
1372
+ let mut m = mediana_geometrica(&pontos, 0, 1e-12); // init na média
1373
+ let f0 = soma_dist(&m);
1374
+ for k in 1..=200 {
1375
+ let m2 = mediana_geometrica(&pontos, 1, 1e-12);
1376
+ // nota: mediana_geometrica reinicia na média; para o teste de
1377
+ // monotonia POR PASSO usamos o estado encadeado abaixo.
1378
+ let _ = m2;
1379
+ // passo único a partir de m (reimplementa o passo Weiszfeld —
1380
+ // idêntico ao interior da função, auditável):
1381
+ let mut num = vec![0.0f64; 2];
1382
+ let mut den = 0.0f64;
1383
+ for x in &pontos {
1384
+ let dist = distancia2(x, &m).sqrt().max(1e-12);
1385
+ num[0] += x[0] / dist;
1386
+ num[1] += x[1] / dist;
1387
+ den += 1.0 / dist;
1388
  }
1389
+ for j in 0..2 {
1390
+ m[j] = num[j] / den;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1391
  }
1392
+ let fk = soma_dist(&m);
1393
+ assert!(fk <= f0 + 1e-9 * k as f64, "iter {k}: Σdist {fk} > inicial-acum {f0}");
1394
  }
1395
+ let f_final = soma_dist(&m);
1396
+ // convergência efetiva: mediana bem melhor que a média
1397
+ let media = mediana_geometrica(&pontos, 0, 1e-12);
1398
+ assert!(f_final < soma_dist(&media), "mediana {f_final} vs média {}", soma_dist(&media));
1399
+ // convergida: a mediana "plena" coincide com a encadeada
1400
+ let m_plena = mediana_geometrica(&pontos, 200, 1e-12);
1401
+ assert!((soma_dist(&m_plena) - f_final).abs() < 1e-6);
1402
  }
1403
 
1404
+ /// S4-2 (integração): treino SOM em modo MedianaDura tem QE
1405
+ /// NÃO-CRESCENTE por época (teorema completo: Weiszfeld + blend convexo
1406
+ /// + re-atribuição) — a garantia que a crítica pediu e a média não dá.
1407
  #[test]
1408
+ fn s42b_qe_mediana_nao_cresce() {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1409
  let dev = Device::Cpu;
1410
+ let mut rng = crate::rng::RngDeterministico::novo(7);
1411
+ let dados: Vec<f32> = (0..60 * 4).map(|_| rng.normal(0.0, 1.5) as f32).collect();
1412
+ let t = Tensor::from_vec(dados, (60, 4), &dev).unwrap();
1413
  let cfg = CfgSom4D {
1414
+ nx: 2, ny: 2, nz: 1, nt: 2,
1415
+ epocas: 12,
1416
+ criterio: CriterioPrototipo4D::MedianaDura,
 
 
 
 
 
 
1417
  ..Default::default()
1418
  };
1419
  let som = treinar_som4d(&t, &cfg, &dev).unwrap();
1420
+ let qs: Vec<f64> = som.historia.iter().map(|(q, _)| *q).collect();
1421
+ for k in 1..qs.len() {
1422
+ assert!(qs[k] <= qs[k - 1] + 1e-9, "QE cresceu na época {k}: {} > {}", qs[k], qs[k - 1]);
1423
+ }
1424
+ assert!(som.eq_final < som.eq_inicial, "QE final {} >= inicial {}", som.eq_final, som.eq_inicial);
1425
+ // telemetria nova presente (S4-1′)
1426
+ assert!(!som.historia_eqm.is_empty());
1427
+ assert!(som.eqm_final >= 0.0 && som.e_sigma_final >= 0.0);
1428
  }
1429
 
1430
+ /// T-1′: cota de rastreio APERTADA sob deriva linear.
1431
+ /// δ=0.02, γ=0.9, η=0.1 ⇒ lag estacionário medido = cota
1432
+ /// δγ/(1−γ) + δ(1−η)/η = 0.18 + 0.18 = 0.36 (a cota da crítica
1433
+ /// δγ/(1−γ)+δ/η = 0.38 é válida porém frouxa; a antiga δ/(1−γ)=0.2 é
1434
+ /// FALSA — subestima).
1435
  #[test]
1436
+ fn t1_cota_apertada() {
1437
+ let (delta, gama, eta) = (0.02f64, 0.9f64, 0.1f64);
1438
+ let mut m = 0.0f64; // filtro
1439
+ let mut p = 0.0f64; // protótipo
1440
+ let t_transiente = 4000;
1441
+ let mut lag_medido = 0.0f64;
1442
+ for t in 1..=t_transiente {
1443
+ let mu = delta * t as f64; // rampa
1444
+ m = gama * m + (1.0 - gama) * mu;
1445
+ p = p + eta * (m - p);
1446
+ if t == t_transiente {
1447
+ lag_medido = delta * t as f64 - p;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1448
  }
1449
+ }
1450
+ let cota_apertada = delta * gama / (1.0 - gama) + delta * (1.0 - eta) / eta;
1451
+ let cota_critica = delta * gama / (1.0 - gama) + delta / eta;
1452
+ let cota_antiga = delta / (1.0 - gama);
1453
+ assert!((lag_medido - cota_apertada).abs() < 1e-6,
1454
+ "lag {lag_medido} != cota apertada {cota_apertada}");
1455
+ assert!(lag_medido <= cota_critica + 1e-9, "cota da crítica violada");
1456
+ assert!(cota_antiga < lag_medido - 1e-6, "cota antiga subestima (errata confirmada)");
 
 
 
 
 
 
 
 
 
 
 
 
1457
  }
1458
 
1459
+ /// H-1′(c): com pin_slot0=true, EQ_hierárquico ≤ EQ_grosso EXATO
1460
+ /// (teorema construtivo — vira garantia formal, não conjectura).
1461
  #[test]
1462
+ fn h1_pin_slot0_teorico() {
 
 
1463
  let dev = Device::Cpu;
1464
  let mut rng = crate::rng::RngDeterministico::novo(21);
1465
+ let dados: Vec<f32> = (0..80 * 4).map(|_| rng.normal(0.0, 2.0) as f32).collect();
1466
+ let t = Tensor::from_vec(dados, (80, 4), &dev).unwrap();
1467
+ let cfg = CfgHSom { pin_slot0: true, ..Default::default() };
1468
+ let h = treinar_hsom(&t, &cfg, &dev).unwrap();
1469
+ assert!(h.eq_hierarquico <= h.eq_grosso + 1e-9,
1470
+ "H-1′(c) violado: EQ_hier {} > EQ_grosso {}", h.eq_hierarquico, h.eq_grosso);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1471
  }
1472
+ }
src/telemetria.rs CHANGED
@@ -200,11 +200,11 @@ impl TelemetryHub {
200
  if inclinacoes.is_empty() {
201
  return (0.0, 0.0, "amostra_insuficiente");
202
  }
203
- inclinacoes.sort_by(|a, b| a.total_cmp(b));
204
  let incl = inclinacoes[inclinacoes.len() / 2];
205
  // intercepto pela mediana dos resíduos
206
  let mut res_intercept: Vec<f64> = pts.iter().map(|(x, y)| y - incl * x).collect();
207
- res_intercept.sort_by(|a, b| a.total_cmp(b));
208
  let b0 = res_intercept[res_intercept.len() / 2];
209
  // R² do ajuste robusto (1 − SS_res/SS_tot)
210
  let media_y: f64 = pts.iter().map(|(_, y)| y).sum::<f64>() / n as f64;
@@ -392,76 +392,6 @@ impl TelemetryHub {
392
  /// simplesmente omitidas (painel ADITIVO — sem acoplamento rígido).
393
 
394
  /// Painel v0.9.0 — despacho SIMD + contexto das medições da r-34.
395
- /// v0.10.0 — painel agregado das críticas DeepSeek (r-35).
396
- pub fn painel_v100(&self) -> serde_json::Value {
397
- let mut p = self.painel_v090();
398
- if let Some(obj) = p.as_object_mut() {
399
- obj.insert(
400
- "v100_nota".into(),
401
- serde_json::json!(
402
- "análise/prova/teste das críticas DeepSeek (5 arquivos): J-1′ sela sharp \
403
- (kink da RAIZ, não da dobradiça; softplus refutado — j1d); S4-1′ Φ do kernel \
404
- não-crescente incondicional (contraexemplo QE reproduzido; mediana de Weiszfeld \
405
- opt-in); T-1′ termo δ/η confirmado (η configurável); H-1′ cota ótima \
406
- (√QE+√R)² + reservar_grosso teorema; T-P5′ cota m_extra com identidade exata \
407
- (fórmula DeepSeek refutada); T-P1′ causalidade contrafactual; A.0′ viés STE \
408
- ≤ M·Δ/2; A.1′ coerência de Welch por nível; B.1 TC plug-in MM; C.3′ errata \
409
- (média ≤ sup); bug v100-1 (máscara de covariância invertida) corrigido"
410
- ),
411
- );
412
- }
413
- p
414
- }
415
-
416
- /// **v0.11.0 (r-43):** painel da fase elástica — módulos novos
417
- /// (raciocinio_elástico RE-1..RE-8, asm/tratamento, M-R5′ guloso,
418
- /// V-2′ soundness condicional) + agregação u64 com estouro detectado
419
- /// por Carry Flag (kernel `soma_u64_cheia` — tratamento.txt §2).
420
- pub fn painel_v110(&self) -> serde_json::Value {
421
- let mut p = self.painel_v100();
422
- // agregação CHECADA dos passos de ajuste (kernel add/jc): telemetria
423
- // corrompida/huge produz estado AUDITÁVEL, não wraparound silencioso
424
- let passos: Vec<u64> = self.eventos_ajuste.iter().map(|e| e.passo as u64).collect();
425
- let soma_passos = match crate::asm::soma_u64_cheia(&passos) {
426
- Ok(s) => serde_json::json!(s),
427
- Err(e) => serde_json::json!(format!("ERRO-CF: {e}")), // nunca silencioso
428
- };
429
- if let Some(obj) = p.as_object_mut() {
430
- obj.insert("asm".into(), serde_json::json!(crate::asm::relatorio()));
431
- obj.insert(
432
- "elastico".into(),
433
- serde_json::json!({
434
- "gate_compressao": self.ema("elastico_compressao_ok", 0.9),
435
- "massa_removida_ema": self.ema("elastico_massa_removida", 0.9),
436
- "rollback_ema": self.ema("elastico_rollback", 0.9),
437
- "certificados": self.eventos_ajuste.iter()
438
- .filter(|e| e.parametro == "elastico_compressao").count(),
439
- }),
440
- );
441
- obj.insert(
442
- "ajustes_agregados".into(),
443
- serde_json::json!({
444
- "n_eventos": self.eventos_ajuste.len(),
445
- "soma_passos": soma_passos,
446
- "soma_checada_cf": true,
447
- }),
448
- );
449
- obj.insert(
450
- "v110_nota".into(),
451
- serde_json::json!(
452
- "r-36..r-42 (provas v0.11): S4-1′/S4-2/T-1′/H-1′(pin slot) SOM; J-1′/J-3′ JEPA; \
453
- A.0′/A.1′/B.1/C.3′ NCM; T-P1′/T-P5′(identidade exata)/T-P6′ Pensamento; \
454
- N-2/V-2′(ECE_aceito + cota condicional L1/p_a)/V-3 Verificador; M-R1′/M-R5′\
455
- (guloso inteiro ótimo — contraexemplo −4,3%)/F-9′ MoE+FNH; RE-1..RE-8 \
456
- raciocínio elástico com certificado de compressão; tratamento.txt: \
457
- Rust Result + Assembly por flags (CF/PF/ZF), module::error, sem unwrap \
458
- em produção"
459
- ),
460
- );
461
- }
462
- p
463
- }
464
-
465
  pub fn painel_v090(&self) -> serde_json::Value {
466
  let mut p = self.painel_v070(None);
467
  if let Some(obj) = p.as_object_mut() {
 
200
  if inclinacoes.is_empty() {
201
  return (0.0, 0.0, "amostra_insuficiente");
202
  }
203
+ inclinacoes.sort_by(|a, b| a.partial_cmp(b).unwrap());
204
  let incl = inclinacoes[inclinacoes.len() / 2];
205
  // intercepto pela mediana dos resíduos
206
  let mut res_intercept: Vec<f64> = pts.iter().map(|(x, y)| y - incl * x).collect();
207
+ res_intercept.sort_by(|a, b| a.partial_cmp(b).unwrap());
208
  let b0 = res_intercept[res_intercept.len() / 2];
209
  // R² do ajuste robusto (1 − SS_res/SS_tot)
210
  let media_y: f64 = pts.iter().map(|(_, y)| y).sum::<f64>() / n as f64;
 
392
  /// simplesmente omitidas (painel ADITIVO — sem acoplamento rígido).
393
 
394
  /// Painel v0.9.0 — despacho SIMD + contexto das medições da r-34.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
395
  pub fn painel_v090(&self) -> serde_json::Value {
396
  let mut p = self.painel_v070(None);
397
  if let Some(obj) = p.as_object_mut() {
src/tokenizador.rs CHANGED
@@ -167,99 +167,6 @@ impl TokenizadorConceitos {
167
  }
168
  }
169
 
170
- /// **TC intra-nível (v0.10.0, crítica DeepSeek B.1 — Teos B.1-R/B.1-T
171
- /// em r-35 §4.3):** estimador plug-in da MÉDIA da informação mútua por
172
- /// PAR de posições DENTRO de cada nível, sobre os códigos duros
173
- /// induzidos pelo tokenizador (medida INCONDICIONAL — a condicional
174
- /// em c_{<ℓ} não é estimável no tamanho do nosso minibatch; ver r-35
175
- /// §4.3 pela análise honesta do que é mensurável).
176
- ///
177
- /// Correção de Miller–Madow: `MÎ ← max(0, MI_plug − (K−1)²/(2m))`
178
- /// (vício do plug-in em tabelas K×K com m amostras). Devolve, por
179
- /// nível, a média de MÎ sobre os pares amostrados (nats). Com
180
- /// independência intra-nível perfeita ⇒ 0.
181
- ///
182
- /// Uso: telemetria/avaliação (V6 do n-04). A PENALIDADE λ_TC·TC na
183
- /// perda do GERADOR é refutada em r-35 (Teo B.1-R: no-ópera no ótimo
184
- /// do CE); a alavanca correta é o lado do TOKENIZADOR (Teo B.1-T).
185
- pub fn tc_intra_nivel(&self, ids: &Tensor, max_pares: usize) -> Result<Vec<f64>> {
186
- self.tc_intra_nivel_com_piso(ids, max_pares).map(|(tc, _)| tc)
187
- }
188
-
189
- /// Versão com o PISO DE RESOLUÇÃO do estimador (v0.10.0): devolve
190
- /// (tc_por_nivel, piso_mm_por_nivel) — o viés do plug-in em tabelas
191
- /// K×K com m amostras é ≈ (K−1)²/(2m) nats (Miller–Madow); MI abaixo
192
- /// disso NÃO é resolvível. `tc = 0` com piso `r` significa
193
- /// `TC_par < r` (cota superior honesta), não "independência provada".
194
- pub fn tc_intra_nivel_com_piso(
195
- &self,
196
- ids: &Tensor,
197
- max_pares: usize,
198
- ) -> Result<(Vec<f64>, Vec<f64>)> {
199
- let dev = ids.device();
200
- let cod = self.codificar_congelado(ids)?;
201
- let b = cod.ids[0].dims()[0];
202
- let m = b as f64;
203
- let mut saida = Vec::with_capacity(self.niveis.len());
204
- let mut pisos = Vec::with_capacity(self.niveis.len());
205
- for (i, &n_l) in self.niveis.iter().enumerate() {
206
- let k = self.quants[i].w.as_tensor().dims()[0];
207
- let mm_corr = ((k - 1) * (k - 1)) as f64 / (2.0 * m);
208
- let plano = cod.ids[i].reshape((b, n_l))?.detach();
209
- let dados = plano.flatten_all()?.to_vec1::<u32>()?;
210
- // pares determinísticos: (0,1),(0,2),...,(1,2),... até max_pares
211
- let mut pares: Vec<(usize, usize)> = Vec::new();
212
- 'pares: for a in 0..n_l {
213
- for c in (a + 1)..n_l {
214
- pares.push((a, c));
215
- if pares.len() >= max_pares.max(1) {
216
- break 'pares;
217
- }
218
- }
219
- }
220
- if pares.is_empty() {
221
- saida.push(0.0);
222
- pisos.push(0.0);
223
- continue;
224
- }
225
- let mut soma = 0.0f64;
226
- for &(a, c) in &pares {
227
- // histograma conjunto K×K + marginais
228
- let mut conj = vec![0u32; k * k];
229
- let mut ma = vec![0u32; k];
230
- let mut mc = vec![0u32; k];
231
- for r in 0..b {
232
- let va = dados[r * n_l + a] as usize;
233
- let vc = dados[r * n_l + c] as usize;
234
- if va < k && vc < k {
235
- conj[va * k + vc] += 1;
236
- ma[va] += 1;
237
- mc[vc] += 1;
238
- }
239
- }
240
- let mi_plug: f64 = (0..k)
241
- .flat_map(|x| (0..k).map(move |y| (x, y)))
242
- .filter_map(|(x, y)| {
243
- let nxy = conj[x * k + y];
244
- if nxy == 0 || ma[x] == 0 || mc[y] == 0 {
245
- None
246
- } else {
247
- let pxy = nxy as f64 / m;
248
- let px = ma[x] as f64 / m;
249
- let py = mc[y] as f64 / m;
250
- Some(pxy * (pxy / (px * py)).ln())
251
- }
252
- })
253
- .sum();
254
- soma += (mi_plug - mm_corr).max(0.0);
255
- }
256
- saida.push(soma / pares.len() as f64);
257
- pisos.push(mm_corr);
258
- }
259
- let _ = &dev;
260
- Ok((saida, pisos))
261
- }
262
-
263
  /// Reconstrói ẑ a partir de códigos (para corrupção κ e amostragem —
264
  /// o gerador nunca vê os vetores contínuos, apenas c (C.3)).
265
  pub fn reconstruir_de_codigos(&self, ids: &[Tensor], ate_nivel: usize, b: usize, dev: &Device) -> Result<Vec<Tensor>> {
@@ -485,9 +392,9 @@ impl TokenizadorConceitos {
485
  }
486
  let txt = serde_json::to_string(&serde_json::Value::Object(obj))
487
  .map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?;
488
- // v0.11.0 (restaurado da v0.10.0): checkpoint ATÔMICO completo —
489
- // tmp→fsync→rename→fsync(dir) + manifesto SHA-256 (Teo CP-1/CP-2)
490
- crate::checkpoint::salvar_atomico(caminho, &txt)?;
491
  Ok(())
492
  }
493
  }
 
167
  }
168
  }
169
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
170
  /// Reconstrói ẑ a partir de códigos (para corrupção κ e amostragem —
171
  /// o gerador nunca vê os vetores contínuos, apenas c (C.3)).
172
  pub fn reconstruir_de_codigos(&self, ids: &[Tensor], ate_nivel: usize, b: usize, dev: &Device) -> Result<Vec<Tensor>> {
 
392
  }
393
  let txt = serde_json::to_string(&serde_json::Value::Object(obj))
394
  .map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?;
395
+ let tmp = format!("{caminho}.tmp");
396
+ std::fs::write(&tmp, txt).map_err(|e| candle_core::Error::Msg(format!("io: {e}")))?;
397
+ std::fs::rename(&tmp, caminho).map_err(|e| candle_core::Error::Msg(format!("rename: {e}")))?;
398
  Ok(())
399
  }
400
  }
src/treino.rs CHANGED
@@ -54,22 +54,7 @@ impl AdamWManual {
54
  let n = g.len();
55
  let m = self.m.entry(i).or_insert(vec![0f32; n]);
56
  let v = self.v.entry(i).or_insert(vec![0f32; n]);
57
- // v0.11.0 (tratamento.txt §1): extração SEM panic — falha
58
- // estrutural (impossível por construção: dtype f32 do próprio
59
- // var) é logada e a variável é pulada; nunca aborta o treino
60
- // silenciosamente (o "fundo" mata processos com panic sem
61
- // rastro de erro/OOM — log é o único rastro sobrevivente)
62
- let dados = match var
63
- .as_tensor()
64
- .flatten_all()
65
- .and_then(|t| t.to_vec1::<f32>())
66
- {
67
- Ok(d) => d,
68
- Err(e) => {
69
- log::error!("AdamW: extração da variável {i} falhou: {e} — pulada");
70
- continue;
71
- }
72
- };
73
  let mut novos = vec![0f32; n];
74
  crate::simd::passo_adamw(
75
  &dados, &g, m, v, &mut novos, self.lr, self.beta1, self.beta2,
@@ -77,15 +62,8 @@ impl AdamWManual {
77
  );
78
  let forma = var.as_tensor().shape();
79
  let dev = var.as_tensor().device();
80
- let novo_t = match Tensor::from_vec(novos, forma.clone(), dev)
81
- .and_then(|t| t.reshape(forma))
82
- {
83
- Ok(t) => t,
84
- Err(e) => {
85
- log::error!("AdamW: reconstrução da variável {i} falhou: {e} — pulada");
86
- continue;
87
- }
88
- };
89
  let _ = var.set(&novo_t);
90
  }
91
  }
@@ -103,39 +81,6 @@ impl AdamWManual {
103
 
104
  /// Clip global por norma (in-place nos grads achatados).
105
  pub fn clipar(grads: &mut [Option<Vec<f32>>], teto: f64) {
106
- // v0.11.0 (tratamento.txt §2): varredura NaN em ASSEMBLY (PF do
107
- // ucomiss) ANTES da norma — diagnóstico LOCALIZADO (tensor e
108
- // índice do primeiro NaN), substituindo a detecção difusa da soma
109
- // f64. A guarda `is_finite` abaixo permanece como rede de segurança
110
- // (defesa em profundidade — mesma filosofia do rollback RE-2).
111
- let mut nan_achado: Option<(usize, usize)> = None;
112
- for (ti, g) in grads.iter().enumerate() {
113
- if let Some(gv) = g {
114
- match crate::asm::primeiro_nan_f32(gv) {
115
- Ok(Some(idx)) => {
116
- nan_achado = Some((ti, idx));
117
- break;
118
- }
119
- Err(e) => {
120
- // pré-condição estrutural: não deve ocorrer — logado,
121
- // nunca silencioso (tratamento.txt §1)
122
- log::error!("varredura NaN falhou: {e}");
123
- }
124
- Ok(None) => {}
125
- }
126
- }
127
- }
128
- if let Some((ti, idx)) = nan_achado {
129
- log::warn!(
130
- "grad não-finito: NaN no tensor {ti}, índice {idx} (kernel ucomiss/jp) — passo zerado"
131
- );
132
- for g in grads.iter_mut().flatten() {
133
- for x in g.iter_mut() {
134
- *x = 0.0;
135
- }
136
- }
137
- return;
138
- }
139
  let norma = Self::norma_global(grads);
140
  if !norma.is_finite() {
141
  // gradiente explodido (inf/nan): zera o passo — seguro por
@@ -277,13 +222,6 @@ pub struct ResumoFase {
277
  pub perplexidade_codebook: f64,
278
  pub monotonia_prefixo: f64,
279
  pub escore_aprendizado: f64,
280
- /// v0.10.0 (A.1′): coerência de Welch máxima dos codebooks.
281
- pub coerencia_max: f64,
282
- /// v0.10.0 (B.1): correlação total intra-nível média (plug-in MM).
283
- pub tc_intra_nivel_medio: f64,
284
- /// v0.10.0: piso de resolução do estimador (Miller–Madow) — tc=0 com
285
- /// piso r significa TC < r (cota superior), não independência provada.
286
- pub tc_resolucao_nats: f64,
287
  }
288
 
289
  /// FASE A — tokenizador (n-04 §4): nested dropout + commitment + GSQ + RCO.
@@ -345,16 +283,9 @@ pub fn treinar_fase_a(
345
  if passo % a_cada == 0 || passo == cfg.treino.passos_fase_a - 1 {
346
  let perp: f64 = tok.quants.iter().map(|q| q.perplexidade_uso()).sum::<f64>() / tok.quants.len().max(1) as f64;
347
  let dort: f64 = tok.quants.iter().map(|q| q.delta_ort_ultimo).fold(0f64, f64::max);
348
- // v0.10.0 (A.1′): coerência de Welch dos codebooks
349
- let coh: f64 = tok
350
- .quants
351
- .iter()
352
- .map(|q| q.coerencia().unwrap_or(f64::NAN))
353
- .fold(f64::MIN, f64::max);
354
  hub.registrar_multi(&[
355
  ("codebook_perplexidade_media", perp),
356
  ("delta_ort_max", dort),
357
- ("coerencia_welch_max", coh),
358
  ("escore_aprendizado", hub.escore_aprendizado()),
359
  ]);
360
  if cfg.telemetria.deteccao_aprendizado {
@@ -388,27 +319,6 @@ pub fn treinar_fase_a(
388
  let perp: f64 = tok.quants.iter().map(|q| q.perplexidade_uso()).sum::<f64>() / tok.quants.len().max(1) as f64;
389
  let dort = tok.quants.iter().map(|q| q.delta_ort_ultimo).fold(0f64, f64::max);
390
  let acc = { let (_, m) = tok.perda_fase_a(&ids_val, &mut rng)?; m.acc_recon };
391
- // v0.10.0 (B.1): TC intra-nível plug-in (Miller–Madow) numa amostra
392
- // MAIOR (16 lotes — o piso de resolução do estimador cai com m) —
393
- // linha de base para a alavanca do tokenizador (Teo B.1-T)
394
- let mut ids_tc: Option<Tensor> = None;
395
- for _ in 0..16 {
396
- let l = dados.lote(cfg.treino.lote, &mut rng, &dev)?;
397
- ids_tc = Some(match ids_tc {
398
- None => l,
399
- Some(a) => Tensor::cat(&[a, l], 0)?,
400
- });
401
- }
402
- let (tc_niveis, pisos) = ids_tc
403
- .and_then(|t| tok.tc_intra_nivel_com_piso(&t, 16).ok())
404
- .unwrap_or_default();
405
- let tc_medio = tc_niveis.iter().sum::<f64>() / tc_niveis.len().max(1) as f64;
406
- let tc_resolucao = pisos.iter().sum::<f64>() / pisos.len().max(1) as f64;
407
- let coh_max = tok
408
- .quants
409
- .iter()
410
- .map(|q| q.coerencia().unwrap_or(f64::NAN))
411
- .fold(f64::MIN, f64::max);
412
  if let Some(c) = caminho_checkpoint {
413
  tok.salvar(c)?;
414
  }
@@ -423,9 +333,6 @@ pub fn treinar_fase_a(
423
  perplexidade_codebook: perp,
424
  monotonia_prefixo: monotonia,
425
  escore_aprendizado: hub.escore_aprendizado(),
426
- coerencia_max: coh_max,
427
- tc_intra_nivel_medio: tc_medio,
428
- tc_resolucao_nats: tc_resolucao,
429
  })
430
  }
431
 
@@ -547,9 +454,6 @@ pub fn treinar_fase_b(
547
  perplexidade_codebook: 0.0,
548
  monotonia_prefixo: 0.0,
549
  escore_aprendizado: hub.escore_aprendizado(),
550
- coerencia_max: f64::NAN, // fase B: codebooks congelados (medidos na A)
551
- tc_intra_nivel_medio: f64::NAN,
552
- tc_resolucao_nats: f64::NAN,
553
  })
554
  }
555
 
 
54
  let n = g.len();
55
  let m = self.m.entry(i).or_insert(vec![0f32; n]);
56
  let v = self.v.entry(i).or_insert(vec![0f32; n]);
57
+ let dados = var.as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap();
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
58
  let mut novos = vec![0f32; n];
59
  crate::simd::passo_adamw(
60
  &dados, &g, m, v, &mut novos, self.lr, self.beta1, self.beta2,
 
62
  );
63
  let forma = var.as_tensor().shape();
64
  let dev = var.as_tensor().device();
65
+ let novo_t = Tensor::from_vec(novos, forma.clone(), dev).unwrap()
66
+ .reshape(forma).unwrap();
 
 
 
 
 
 
 
67
  let _ = var.set(&novo_t);
68
  }
69
  }
 
81
 
82
  /// Clip global por norma (in-place nos grads achatados).
83
  pub fn clipar(grads: &mut [Option<Vec<f32>>], teto: f64) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
84
  let norma = Self::norma_global(grads);
85
  if !norma.is_finite() {
86
  // gradiente explodido (inf/nan): zera o passo — seguro por
 
222
  pub perplexidade_codebook: f64,
223
  pub monotonia_prefixo: f64,
224
  pub escore_aprendizado: f64,
 
 
 
 
 
 
 
225
  }
226
 
227
  /// FASE A — tokenizador (n-04 §4): nested dropout + commitment + GSQ + RCO.
 
283
  if passo % a_cada == 0 || passo == cfg.treino.passos_fase_a - 1 {
284
  let perp: f64 = tok.quants.iter().map(|q| q.perplexidade_uso()).sum::<f64>() / tok.quants.len().max(1) as f64;
285
  let dort: f64 = tok.quants.iter().map(|q| q.delta_ort_ultimo).fold(0f64, f64::max);
 
 
 
 
 
 
286
  hub.registrar_multi(&[
287
  ("codebook_perplexidade_media", perp),
288
  ("delta_ort_max", dort),
 
289
  ("escore_aprendizado", hub.escore_aprendizado()),
290
  ]);
291
  if cfg.telemetria.deteccao_aprendizado {
 
319
  let perp: f64 = tok.quants.iter().map(|q| q.perplexidade_uso()).sum::<f64>() / tok.quants.len().max(1) as f64;
320
  let dort = tok.quants.iter().map(|q| q.delta_ort_ultimo).fold(0f64, f64::max);
321
  let acc = { let (_, m) = tok.perda_fase_a(&ids_val, &mut rng)?; m.acc_recon };
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
322
  if let Some(c) = caminho_checkpoint {
323
  tok.salvar(c)?;
324
  }
 
333
  perplexidade_codebook: perp,
334
  monotonia_prefixo: monotonia,
335
  escore_aprendizado: hub.escore_aprendizado(),
 
 
 
336
  })
337
  }
338
 
 
454
  perplexidade_codebook: 0.0,
455
  monotonia_prefixo: 0.0,
456
  escore_aprendizado: hub.escore_aprendizado(),
 
 
 
457
  })
458
  }
459
 
src/verificador.rs CHANGED
@@ -205,17 +205,38 @@ pub fn calibrar_temperatura_newton(
205
 
206
  /// ECE (Expected Calibration Error) por faixas de confiança.
207
  pub fn ece(confs: &[f64], corretos: &[bool], n_faixas: usize) -> f64 {
 
 
 
 
 
 
 
 
 
 
 
 
208
  if confs.is_empty() || confs.len() != corretos.len() {
209
  return f64::NAN;
210
  }
211
- let n = confs.len() as f64;
 
 
 
 
 
 
 
 
 
212
  let mut total = 0f64;
213
  for b in 0..n_faixas {
214
  let (lo, hi) = (b as f64 / n_faixas as f64, (b + 1) as f64 / n_faixas as f64);
215
  let mut soma_conf = 0f64;
216
  let mut soma_acerto = 0f64;
217
  let mut m = 0usize;
218
- for (c, ok) in confs.iter().zip(corretos.iter()) {
219
  let c1 = c.min(0.999_999);
220
  if *c >= lo && c1 < hi {
221
  soma_conf += c;
@@ -230,150 +251,54 @@ pub fn ece(confs: &[f64], corretos: &[bool], n_faixas: usize) -> f64 {
230
  total
231
  }
232
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
233
  /// **V-3:** limiar τ_c = quantil 1−ε das confianças retidas (ordem estatística).
234
  pub fn limiar_por_erro(confs: &[f64], epsilon: f64) -> f64 {
235
  let mut v = confs.to_vec();
236
  if v.is_empty() {
237
  return 1.0;
238
  }
239
- v.sort_by(|a, b| a.total_cmp(b));
240
  let idx = (((1.0 - epsilon.clamp(0.0, 1.0)) * v.len() as f64).ceil() as usize)
241
  .saturating_sub(1)
242
  .min(v.len() - 1);
243
  v[idx]
244
  }
245
 
246
- /// **V-2′ (v0.11.0, r-40):** relatório de soundness CONDICIONAL ao aceite.
247
- ///
248
- /// Errata da v0.6.0: a cota `P(erro|aceito) ≤ 1−τ_c + ECE` só vale com ECE
249
- /// medido NO CONJUNTO ACEITO; com ECE global o correto é
250
- /// `P(erro|A) ≤ 1−τ_c + L₁/p_a` com `p_a = P(A)` (condicionamento:
251
- /// `E[X|A] ≤ E[X]/P(A)` para X ≥ 0).
252
- ///
253
- /// **Teorema (r-40).** Seja `A = {conf ≥ τ_c}`, `p_a = P(A) > 0` e
254
- /// `L₁ = E|1{acerto} − conf|` (calibração L1; o ECE por faixas é seu
255
- /// estimador com viés O(1/faixas)). Então
256
- /// `P(erro | A) ≤ (1−τ_c) + L₁/p_a`.
257
- /// Prova. `P(erro|A) = 1 − E[1{acerto}|A] ≤ 1 − E[conf|A] +
258
- /// E[|1{acerto}−conf| | A] ≤ 1 − τ_c + L₁/p_a`. ∎
259
- /// Com `ece_aceito` (faixas restritas a conf ≥ τ_c) vale a forma limpa
260
- /// `P(erro|A) ≤ 1 − τ_c + ece_aceito`.
261
- #[derive(Debug, Clone)]
262
- pub struct RelatorioSoundness {
263
- /// τ_c usado (limiar de aceite).
264
- pub tau_c: f64,
265
- /// fração de aceites `p_a = P(conf ≥ τ_c)` (vem de graça do quantil V-3).
266
- pub p_aceite: f64,
267
- /// nº de amostras aceitas (denominador de P(erro|A)).
268
- pub n_aceito: usize,
269
- /// ECE medido SÓ nas amostras aceitas (a forma correta da cota limpa).
270
- pub ece_aceito: f64,
271
- /// calibração L1 global estimada (para a cota corrigida `L₁/p_a`).
272
- pub l1_global: f64,
273
- /// cota limpa `1 − τ_c + ece_aceito` (válida por construção).
274
- pub cota_limpa: f64,
275
- /// cota corrigida `1 − τ_c + L₁/p_a` (válida com ECE global).
276
- pub cota_corrigida: f64,
277
- /// erro empírico medido `P̂(erro|aceito)` no conjunto fornecido.
278
- pub p_erro_aceito: f64,
279
- /// true se o erro empírico respeita a cota limpa (sanidade do relatório).
280
- pub cota_limpa_respeitada: bool,
281
- }
282
-
283
- /// Constrói o relatório V-2′. `confs`/`corretos` = amostras retidas
284
- /// (exchangeability com produção — ver limitações r-40 §L1).
285
- pub fn relatorio_soundness(
286
- confs: &[f64],
287
- corretos: &[bool],
288
- n_faixas: usize,
289
- tau_c: f64,
290
- ) -> Result<RelatorioSoundness> {
291
- if confs.len() != corretos.len() {
292
- candle_core::bail!("relatorio_soundness: confs ({}) e corretos ({}) de tamanhos distintos", confs.len(), corretos.len());
293
- }
294
- let n = confs.len();
295
- if n == 0 {
296
- candle_core::bail!("relatorio_soundness: nenhuma amostra retida");
297
- }
298
- let aceitos: Vec<(f64, bool)> = confs
299
- .iter()
300
- .zip(corretos.iter())
301
- .filter(|(c, _)| **c >= tau_c)
302
- .map(|(c, ok)| (*c, *ok))
303
- .collect();
304
- let n_aceito = aceitos.len();
305
- let p_aceite = n_aceito as f64 / n as f64;
306
- // L1 global: E|1{acerto} − conf| (estimador empirico simples — sem faixas)
307
- let l1_global = confs
308
- .iter()
309
- .zip(corretos.iter())
310
- .map(|(c, ok)| (if *ok { 1.0 } else { 0.0 } - c).abs())
311
- .sum::<f64>()
312
- / n as f64;
313
- if n_aceito == 0 {
314
- // p_a = 0: a cota condicional é vazua — reportar honestamente
315
- return Ok(RelatorioSoundness {
316
- tau_c,
317
- p_aceite: 0.0,
318
- n_aceito: 0,
319
- ece_aceito: f64::NAN,
320
- l1_global,
321
- cota_limpa: f64::INFINITY,
322
- cota_corrigida: f64::INFINITY,
323
- p_erro_aceito: f64::NAN,
324
- cota_limpa_respeitada: true, // conjunto vazio: nada a violar
325
- });
326
- }
327
- let (confs_a, oks_a): (Vec<f64>, Vec<bool>) = aceitos.into_iter().unzip();
328
- // ECE com faixas RESTRITAS ao domínio aceito [τ_c, 1] — a forma correta
329
- let ece_a = ece_dominio(&confs_a, &oks_a, n_faixas, tau_c, 1.0);
330
- let erro_aceito = oks_a.iter().filter(|ok| !**ok).count() as f64 / n_aceito as f64;
331
- let cota_limpa = 1.0 - tau_c + ece_a;
332
- let cota_corrigida = 1.0 - tau_c + l1_global / p_aceite.max(1e-12);
333
- Ok(RelatorioSoundness {
334
- tau_c,
335
- p_aceite,
336
- n_aceito,
337
- ece_aceito: ece_a,
338
- l1_global,
339
- cota_limpa,
340
- cota_corrigida,
341
- p_erro_aceito: erro_aceito,
342
- cota_limpa_respeitada: erro_aceito <= cota_limpa + 1e-9,
343
- })
344
- }
345
-
346
- /// ECE por faixas em um domínio arbitrário [lo_dom, hi_dom] (V-2′): a
347
- /// versão pública `ece` é o caso especial [0,1]. As faixas particionam o
348
- /// DOMÍNIO (não [0,1]), para não inflar artificialmente o peso das faixas
349
- /// vazias fora do domínio.
350
- fn ece_dominio(confs: &[f64], corretos: &[bool], n_faixas: usize, lo_dom: f64, hi_dom: f64) -> f64 {
351
- if confs.is_empty() || confs.len() != corretos.len() {
352
- return f64::NAN;
353
- }
354
- let n = confs.len() as f64;
355
- let larg = (hi_dom - lo_dom).max(1e-12) / n_faixas as f64;
356
- let mut total = 0f64;
357
- for b in 0..n_faixas {
358
- let (lo, hi) = (lo_dom + b as f64 * larg, lo_dom + (b + 1) as f64 * larg);
359
- let mut soma_conf = 0f64;
360
- let mut soma_acerto = 0f64;
361
- let mut m = 0usize;
362
- for (c, ok) in confs.iter().zip(corretos.iter()) {
363
- let c1 = (*c).min(hi_dom - 1e-12);
364
- if *c >= lo && c1 < hi {
365
- soma_conf += c;
366
- soma_acerto += if *ok { 1.0 } else { 0.0 };
367
- m += 1;
368
- }
369
- }
370
- if m > 0 {
371
- total += (m as f64 / n) * (soma_conf / m as f64 - soma_acerto / m as f64).abs();
372
- }
373
- }
374
- total
375
- }
376
-
377
  /// Verificador NCM calibrado — o substituto de produção do oráculo.
378
  #[derive(Debug, Clone)]
379
  pub struct VerificadorNcm {
@@ -496,7 +421,9 @@ mod testes {
496
  let preds = lt.argmax(candle_core::D::Minus1).unwrap();
497
  let corretos: Vec<bool> = preds.eq(&at).unwrap().to_dtype(candle_core::DType::U32).unwrap()
498
  .flatten_all().unwrap().to_vec1::<u32>().unwrap().iter().map(|x| *x == 1).collect();
499
- let tau = limiar_por_erro(&confs, 0.20); // aceitar ~80%
 
 
500
  let mut erro_aceito = 0usize;
501
  let mut n_aceito = 0usize;
502
  for (c, ok) in confs.iter().zip(corretos.iter()) {
@@ -512,101 +439,34 @@ mod testes {
512
  assert!(p_erro <= cota, "P(erro|aceito)={p_erro:.4} ≤ 1−τ_c+ECE+folga={cota:.4} (τ_c={tau:.3}, ECE={e_depois:.4})");
513
  }
514
 
515
- /// **V-2′ (v0.11.0, r-40):** cota CONDICIONAL corrigida.
516
- /// (i) `P̂(erro|A) ≤ 1−τ_c + ÊCE_aceito` vale EXATAMENTE no empirico
517
- /// (triangular por faixa: `1−acc̄_b ≤ (1−conf̄_b) + |conf̄_b−acc̄_b|`
518
- /// com `conf̄_b ≥ τ_c`);
519
- /// (ii) `P̂(erro|A) ≤ 1−τ_c + L̂₁/p_a` idem (por amostra);
520
- /// (iii) ERRATA: a cota antiga `1−τ_c + ECE_global` PODE SER VIOLADA —
521
- /// contraexemplo construído (90% conf=0,5 calibrada + 10% conf=0,95
522
- /// superconfiante aceitos).
523
- #[test]
524
- fn v2_linha_cota_condicional_corrigida() {
525
- // simulador com viés senoidal (calibração imperfeita suave)
526
- let mut rng = crate::rng::RngDeterministico::novo(20261113);
527
- let n = 100_000usize;
528
- let (mut confs, mut corretos) = (Vec::with_capacity(n), Vec::with_capacity(n));
529
- for i in 0..n {
530
- // conf na diagonal + viés senoidal (superconfiante no topo)
531
- let u = i as f64 / n as f64;
532
- let c = (0.25 + 0.70 * u + 0.05 * (12.0 * u).sin()).clamp(0.01, 0.99);
533
- let p_real = (c - 0.06 * (6.0 * u).sin()).clamp(0.01, 0.99);
534
- confs.push(c);
535
- corretos.push(rng.uniforme() < p_real);
536
- }
537
- let tau = 0.90;
538
- let r = relatorio_soundness(&confs, &corretos, 20, tau).unwrap();
539
- assert!(r.n_aceito > 0, "deve haver aceites");
540
- assert!(r.p_aceite > 0.0 && r.p_aceite <= 1.0);
541
- // (i) cota limpa: exata no empirico (desigualdade triangular por faixa)
542
- assert!(
543
- r.p_erro_aceito <= r.cota_limpa + 1e-9,
544
- "P̂(erro|A)={:.4} ≤ 1−τ_c+ÊCE_aceito={:.4}",
545
- r.p_erro_aceito, r.cota_limpa
546
- );
547
- // (ii) cota corrigida com L1 global: exata (condicionamento X≥0)
548
- assert!(
549
- r.p_erro_aceito <= r.cota_corrigida + 1e-9,
550
- "P̂(erro|A)={:.4} ≤ 1−τ_c+L̂₁/p_a={:.4}",
551
- r.p_erro_aceito, r.cota_corrigida
552
- );
553
- // a cota corrigida é MAIS FRACA (maior) que a limpa quando p_a < 1
554
- assert!(r.cota_corrigida >= r.cota_limpa - 1e-9);
555
-
556
- // (iii) ERRATA da v0.6.0: ECE GLOBAL pode violar a cota antiga
557
- let (cg, og) = contraexemplo_ece_global();
558
- let ece_g = ece(&cg, &og, 10);
559
- let n_a = cg.iter().zip(og.iter()).filter(|(c, _)| **c >= 0.9).count();
560
- let e_a = cg.iter().zip(og.iter()).filter(|(c, _)| **c >= 0.9).filter(|(_, o)| !**o).count();
561
- let p_erro_a = e_a as f64 / n_a as f64;
562
- let cota_antiga = 1.0 - 0.9 + ece_g;
563
- assert!(
564
- p_erro_a > cota_antiga,
565
- "contraexemplo: P(erro|A)={p_erro_a:.4} > 1−τ_c+ECE_global={cota_antiga:.4} (a cota antiga é INVÁLIDA)"
566
- );
567
- // ... e o relatório V-2′ cobre este caso corretamente
568
- let r2 = relatorio_soundness(&cg, &og, 10, 0.9).unwrap();
569
- assert!(r2.cota_limpa_respeitada, "cota limpa V-2′ cobre o contraexemplo");
570
 
571
- fn contraexemplo_ece_global() -> (Vec<f64>, Vec<bool>) {
572
- // 90% conf=0,5 PERFEITAMENTE calibrada (não aceita) +
573
- // 10% conf=0,95 com acerto 0,80 (superconfiante, aceita):
574
- // ECE_global ≈ 0,1·|0,95−0,80| = 0,015 ⇒ cota antiga 0,115
575
- // < P(erro|A) = 0,20 ⇒ VIOLAÇÃO; ece_aceito = 0,15 ⇒ cota
576
- // limpa 0,25 ≥ 0,20 ✓
577
- let mut rng = crate::rng::RngDeterministico::novo(77);
578
- let mut c = Vec::with_capacity(20_000);
579
- let mut o = Vec::with_capacity(20_000);
580
- for i in 0..20_000 {
581
- if i % 10 == 0 {
582
- c.push(0.95);
583
- o.push(rng.uniforme() < 0.80);
584
- } else {
585
- c.push(0.50);
586
- o.push(rng.uniforme() < 0.50);
587
- }
588
- }
589
- (c, o)
590
- }
591
- }
592
-
593
- /// V-2′: casos degenerados — vazio, τ_c inalcançável, todos aceitos.
594
  #[test]
595
- fn v2b_casos_degenerados() {
596
- assert!(relatorio_soundness(&[], &[], 10, 0.9).is_err(), "vazio => Err");
597
- assert!(
598
- relatorio_soundness(&[0.5], &[true, false], 10, 0.9).is_err(),
599
- "tamanhos distintos => Err"
600
- );
601
- // τ_c = 1,0: nada é aceito (conf < 1) => relatório honesto com p_a = 0
602
- let r = relatorio_soundness(&[0.5, 0.8], &[true, false], 10, 1.0).unwrap();
603
- assert_eq!(r.n_aceito, 0);
604
- assert!(r.p_aceite == 0.0);
605
- assert!(r.cota_limpa.is_infinite(), "p_a=0 => cota vazia (honestidade)");
606
- // todos aceitos: ece_aceito == ece global no mesmo domínio
607
- let r2 = relatorio_soundness(&[0.95, 0.96, 0.94], &[true, false, true], 5, 0.0).unwrap();
608
- let eg = ece(&[0.95, 0.96, 0.94], &[true, false, true], 5);
609
- assert!((r2.ece_aceito - eg).abs() < 1e-12, "domínio total: ece_aceito == ece");
 
 
 
 
 
 
 
 
610
  }
611
 
612
  #[test]
@@ -775,110 +635,4 @@ mod testes {
775
  assert!(nll_n2 <= nll_12 + 1e-6, "N-4b: NLL não piora");
776
  assert!((1.0 / 8.0..=8.0).contains(&t_n2));
777
  }
778
- /// **N-5 (v0.10.0, pedido `aprimoramentos-arquitetura` §3):** casos
779
- /// extremos da salvaguarda de bisseção — T* EXATAMENTE nos limites do
780
- /// colchão [1/8, 8]. (i) modelo superconfiante ERRADO (margem enorme
781
- /// na classe errada): NLL estritamente decrescente em T em todo o
782
- /// colchão ⇒ mínimo na borda T* = 8 (resfria ao máximo) — exercita o
783
- /// early-return `dlo ≥ 0` do calibrar_temperatura_newton; (ii) modelo
784
- /// superconfiante CORRETO (margem enorme na classe certa): NLL
785
- /// estritamente crescente em T ⇒ mínimo na borda T* = 1/8 (aquece ao
786
- /// máximo) — exercita o early-return `dhi ≤ 0`. Em ambos: a resposta
787
- /// deve coincidir com o golden-section (V-1), nunca piorar a NLL(1) e
788
- /// não estourar o orçamento de avaliações.
789
- #[test]
790
- fn n5_t_estrela_nos_limites_do_colchao() {
791
- let dev = Device::Cpu;
792
- // (i) T* = 8: 1 classe errada com margem 30, alvo em outra
793
- let n = 64usize;
794
- let k = 10usize;
795
- let mut lm = vec![0f32; n * k];
796
- for i in 0..n {
797
- let classe_errada = (i % k as usize) as u32; // ≠ alvo
798
- lm[i * k + classe_errada as usize] = 30.0;
799
- }
800
- let lt = Tensor::from_vec(lm, (n, k), &dev).unwrap();
801
- let alvos: Vec<u32> = (0..n).map(|i| ((i % k as usize) as u32 + 1) % k as u32).collect();
802
- let at = Tensor::from_vec(alvos, (n,), &dev).unwrap();
803
- let (t_n, nll_1, nll_n, nav) = calibrar_temperatura_newton(&lt, &at, 40).unwrap();
804
- let (t_g, _, _) = calibrar_temperatura(&lt, &at).unwrap();
805
- assert!(
806
- (t_n - 8.0).abs() < 1e-9,
807
- "caso (i): T* newton = {t_n} (esperado exatamente 8 — borda)"
808
- );
809
- assert!(
810
- (t_g - 8.0).abs() < 1e-6,
811
- "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)"
812
- );
813
- assert!(nll_n <= nll_1 + 1e-6, "caso (i): NLL piorou ({nll_n} > {nll_1})");
814
- assert!(nav <= 40, "caso (i): orçamento estourado ({nav} avaliações)");
815
-
816
- // (ii) T* = 1/8: TODOS corretos com margem 100 (p_y = 1 mesmo a γ=8)
817
- let mut lm = vec![0f32; n * k];
818
- let alvos: Vec<u32> = (0..n).map(|i| (i % k as usize) as u32).collect();
819
- for (i, &a) in alvos.iter().enumerate() {
820
- lm[i * k + a as usize] = 100.0;
821
- }
822
- let lt = Tensor::from_vec(lm, (n, k), &dev).unwrap();
823
- let at = Tensor::from_vec(alvos, (n,), &dev).unwrap();
824
- let (t_n, nll_1, nll_n, nav) = calibrar_temperatura_newton(&lt, &at, 40).unwrap();
825
- let (t_g, _, _) = calibrar_temperatura(&lt, &at).unwrap();
826
- assert!(
827
- (t_n - 0.125).abs() < 1e-9,
828
- "caso (ii): T* newton = {t_n} (esperado exatamente 1/8 — borda)"
829
- );
830
- // HONESTO (medido): o golden NÃO resolve o caso degenerado (ii) —
831
- // a NLL é ~log(1+9e^{−100/T}), plana a ~1e-8 no colchão todo em
832
- // f32, e a busca por seção áurea para num ponto interior (medido:
833
- // T=5,31). O Newton acerta a borda EXATAMENTE pelo early-return
834
- // sinal-based (dhi ≤ 0 em γ=8) — e sua NLL é ≤ à do golden.
835
- // Este é um dos "casos extremos" pedidos: a salvaguarda não só
836
- // sobrevive à borda como SUPERSTIMA o golden nela.
837
- let (_, _, nll_g) = calibrar_temperatura(&lt, &at).unwrap();
838
- assert!(
839
- nll_n <= nll_g + 1e-6,
840
- "caso (ii): NLL newton {nll_n} > golden {nll_g} (T_n={t_n}, T_g={t_g})"
841
- );
842
- assert!(nll_n <= nll_1 + 1e-6, "caso (ii): NLL piorou ({nll_n} > {nll_1})");
843
- assert!(nav <= 40, "caso (ii): orçamento estourado ({nav} avaliações)");
844
- }
845
-
846
- /// **N-5b (v0.10.0):** caso MISTO degenerado — metade da amostra quer
847
- /// a borda fria, metade a quente (NLL quase plana no colchão): o
848
- /// Newton com bisseção deve terminar DENTRO do colchão com n_aval
849
- /// limitado (sem oscilação infinita) e a NLL ≤ NLL(1).
850
- #[test]
851
- fn n5b_caso_misto_quase_plano() {
852
- let dev = Device::Cpu;
853
- let n = 128usize;
854
- let k = 4usize;
855
- let mut lm = vec![0f32; n * k];
856
- let mut alvos = Vec::new();
857
- for i in 0..n {
858
- let a = (i % k) as u32;
859
- alvos.push(a);
860
- if i % 2 == 0 {
861
- lm[i * k + a as usize] = 0.05; // sinal fraco correto
862
- } else {
863
- let errada = (a + 1) % k as u32;
864
- lm[i * k + errada as usize] = 0.05; // sinal fraco errado
865
- }
866
- }
867
- let lt = Tensor::from_vec(lm, (n, k), &dev).unwrap();
868
- let at = Tensor::from_vec(alvos, (n,), &dev).unwrap();
869
- let (t_n, nll_1, nll_n, nav) = calibrar_temperatura_newton(&lt, &at, 40).unwrap();
870
- assert!(
871
- (0.125..=8.0).contains(&t_n),
872
- "T* = {t_n} fora do colchão [1/8, 8]"
873
- );
874
- assert!(nll_n <= nll_1 + 1e-6, "NLL piorou ({nll_n} > {nll_1})");
875
- assert!(nav <= 40, "orçamento estourado ({nav})");
876
- // golden concorda em NLL dentro de 1e-3 (mínimo quase plano)
877
- let (t_g, _, nll_g) = calibrar_temperatura(&lt, &at).unwrap();
878
- assert!(
879
- nll_n <= nll_g + 1e-3,
880
- "newton NLL {nll_n} muito pior que golden {nll_g} (T_n={t_n}, T_g={t_g})"
881
- );
882
- }
883
-
884
  }
 
205
 
206
  /// ECE (Expected Calibration Error) por faixas de confiança.
207
  pub fn ece(confs: &[f64], corretos: &[bool], n_faixas: usize) -> f64 {
208
+ ece_filtrado(confs, corretos, n_faixas, None)
209
+ }
210
+
211
+ /// v0.11 (r-40 V-2′): ECE no conjunto ACEITO — faixas RESTRITAS a
212
+ /// `conf ≥ τ_c`. Errata r-40: a cota limpa `P(erro|aceito) ≤ 1−τ_c+ECE`
213
+ /// só vale com ECE medido NO CONJUNTO ACEITO; com ECE global o correto é
214
+ /// a cota condicional (ver `soundness_aceite`).
215
+ pub fn ece_aceito(confs: &[f64], corretos: &[bool], n_faixas: usize, tau_c: f64) -> f64 {
216
+ ece_filtrado(confs, corretos, n_faixas, Some(tau_c))
217
+ }
218
+
219
+ fn ece_filtrado(confs: &[f64], corretos: &[bool], n_faixas: usize, tau: Option<f64>) -> f64 {
220
  if confs.is_empty() || confs.len() != corretos.len() {
221
  return f64::NAN;
222
  }
223
+ let selecionados: Vec<(f64, bool)> = confs
224
+ .iter()
225
+ .zip(corretos.iter())
226
+ .filter(|(c, _)| tau.map_or(true, |t| **c >= t))
227
+ .map(|(c, ok)| (*c, *ok))
228
+ .collect();
229
+ if selecionados.is_empty() {
230
+ return 0.0;
231
+ }
232
+ let n = confs.len() as f64; // peso GLOBAL: Σ_b (n_b/n) — n do conjunto todo
233
  let mut total = 0f64;
234
  for b in 0..n_faixas {
235
  let (lo, hi) = (b as f64 / n_faixas as f64, (b + 1) as f64 / n_faixas as f64);
236
  let mut soma_conf = 0f64;
237
  let mut soma_acerto = 0f64;
238
  let mut m = 0usize;
239
+ for (c, ok) in selecionados.iter() {
240
  let c1 = c.min(0.999_999);
241
  if *c >= lo && c1 < hi {
242
  soma_conf += c;
 
251
  total
252
  }
253
 
254
+ /// v0.11 (r-40 V-2′): soundness do aceite SEM oráculo — as DUAS cotas.
255
+ ///
256
+ /// **Teorema (V-2′, correto).** Seja A = {conf ≥ τ_c}, p_a = P(A) > 0 e
257
+ /// L₁ = E|1{acerto} − conf| (calibração L1 global). Então:
258
+ /// `P(erro|A) ≤ (1−τ_c) + L₁/p_a` (condicionamento: E[X|A] ≤ E[X]/P(A)).
259
+ /// Com ECE medido NO CONJUNTO ACEITO (faixas restritas), vale a cota
260
+ /// limpa `P(erro|A) ≤ (1−τ_c) + ECE_aceito`.
261
+ /// Devolve (p_erro_medido, cota_condicional, cota_limpa, p_a).
262
+ pub fn soundness_aceite(
263
+ confs: &[f64],
264
+ corretos: &[bool],
265
+ tau_c: f64,
266
+ n_faixas: usize,
267
+ ) -> (f64, f64, f64, f64) {
268
+ let n = confs.len().max(1) as f64;
269
+ let mut erro_aceito = 0usize;
270
+ let mut n_aceito = 0usize;
271
+ let mut l1 = 0.0f64;
272
+ for (c, ok) in confs.iter().zip(corretos.iter()) {
273
+ l1 += (if *ok { 1.0 } else { 0.0 } - c).abs();
274
+ if *c >= tau_c {
275
+ n_aceito += 1;
276
+ if !ok {
277
+ erro_aceito += 1;
278
+ }
279
+ }
280
+ }
281
+ let p_a = n_aceito as f64 / n;
282
+ let p_erro = if n_aceito == 0 { 0.0 } else { erro_aceito as f64 / n_aceito as f64 };
283
+ let l1_medio = l1 / n;
284
+ let cota_cond = (1.0 - tau_c) + if p_a > 0.0 { l1_medio / p_a } else { f64::INFINITY };
285
+ let cota_limpa = (1.0 - tau_c) + ece_aceito(confs, corretos, n_faixas, tau_c);
286
+ (p_erro, cota_cond, cota_limpa, p_a)
287
+ }
288
+
289
  /// **V-3:** limiar τ_c = quantil 1−ε das confianças retidas (ordem estatística).
290
  pub fn limiar_por_erro(confs: &[f64], epsilon: f64) -> f64 {
291
  let mut v = confs.to_vec();
292
  if v.is_empty() {
293
  return 1.0;
294
  }
295
+ v.sort_by(|a, b| a.partial_cmp(b).unwrap());
296
  let idx = (((1.0 - epsilon.clamp(0.0, 1.0)) * v.len() as f64).ceil() as usize)
297
  .saturating_sub(1)
298
  .min(v.len() - 1);
299
  v[idx]
300
  }
301
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
302
  /// Verificador NCM calibrado — o substituto de produção do oráculo.
303
  #[derive(Debug, Clone)]
304
  pub struct VerificadorNcm {
 
421
  let preds = lt.argmax(candle_core::D::Minus1).unwrap();
422
  let corretos: Vec<bool> = preds.eq(&at).unwrap().to_dtype(candle_core::DType::U32).unwrap()
423
  .flatten_all().unwrap().to_vec1::<u32>().unwrap().iter().map(|x| *x == 1).collect();
424
+ let tau = limiar_por_erro(&confs, 0.20); // ε=0.2 ⇒ aceita ~20%
425
+ // (errata r-40/V-3: o comentário antigo dizia "~80%" — trocado;
426
+ // o quantil controla a TAXA DE ACEITE ≈ ε, não 1−ε)
427
  let mut erro_aceito = 0usize;
428
  let mut n_aceito = 0usize;
429
  for (c, ok) in confs.iter().zip(corretos.iter()) {
 
439
  assert!(p_erro <= cota, "P(erro|aceito)={p_erro:.4} ≤ 1−τ_c+ECE+folga={cota:.4} (τ_c={tau:.3}, ECE={e_depois:.4})");
440
  }
441
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
442
 
443
+ /// V-2′ (r-40): as DUAS cotas de soundness em simulação com viés
444
+ /// senoidal de calibração (n grande) — a cota condicional (L1/p_a)
445
+ /// e a cota limpa (ECE no conjunto aceito) ambas dominam o erro medido.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
446
  #[test]
447
+ fn v2b_soundness_cotas_corrigidas() {
448
+ let mut rng = crate::rng::RngDeterministico::novo(97);
449
+ let n = 200_000usize;
450
+ let tau = 0.85f64;
451
+ let mut confs = Vec::with_capacity(n);
452
+ let mut corretos = Vec::with_capacity(n);
453
+ for _ in 0..n {
454
+ // conf "ideal" U(0,1) com viés senoidal (má calibração global)
455
+ let u = rng.uniforme();
456
+ let conf = (u + 0.05 * (10.0 * u).sin()).clamp(0.0, 1.0);
457
+ // acerto com prob. = conf real (calibração condicional ok)
458
+ let acerto = rng.uniforme() < conf;
459
+ confs.push(conf);
460
+ corretos.push(acerto);
461
+ }
462
+ let (p_erro, cota_cond, cota_limpa, p_a) = soundness_aceite(&confs, &corretos, tau, 15);
463
+ assert!(p_a > 0.05, "taxa de aceite razoável (p_a={p_a})");
464
+ assert!(p_erro <= cota_cond + 1e-9,
465
+ "P(erro|A)={p_erro:.4} > cota condicional {cota_cond:.4}");
466
+ assert!(p_erro <= cota_limpa + 1e-9,
467
+ "P(erro|A)={p_erro:.4} > cota limpa {cota_limpa:.4}");
468
+ // a cota limpa é mais justa que a condicional nesta simulação
469
+ assert!(cota_limpa <= cota_cond + 1e-9);
470
  }
471
 
472
  #[test]
 
635
  assert!(nll_n2 <= nll_12 + 1e-6, "N-4b: NLL não piora");
636
  assert!((1.0 / 8.0..=8.0).contains(&t_n2));
637
  }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
638
  }