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 +1 -1
- README.md +12 -30
- docs/memoria-ncm-khtst/n-02-provas-teoria.md +13 -0
- docs/memorias/r-19-provas-som-v050.md +11 -1
- docs/memorias/r-20-provas-jepa-v050.md +11 -1
- docs/memorias/r-21-provas-pensamento-v050.md +11 -1
- docs/memorias/r-23-provas-verificador-ncm-v060.md +0 -2
- docs/memorias/r-25-provas-moe-redirecionavel-v060.md +0 -3
- docs/memorias/r-35-analise-criticas-deepseek-v011.md +88 -0
- docs/memorias/r-37-provas-jepa-v011.md +1 -1
- docs/memorias/r-41-provas-moe-fnh-v011.md +0 -7
- docs/memorias/r-43-resultados-v011.md +106 -0
- resultados/bench_v011.json +22 -0
- resultados/suite_v011_final.json +181 -62
- resultados/telemetria_fase_c.jsonl +104 -61
- resultados/treino_v011.json +784 -0
- scripts/73_treino_v011.py +223 -0
- scripts/74_suite_v011.py +174 -0
- scripts/75_publicar_v011.py +162 -0
- src/asm_x86.rs +463 -0
- src/bin/bench_v011.rs +126 -0
- src/bin/bench_v090.rs +1 -1
- src/controlador.rs +4 -4
- src/fnh.rs +66 -17
- src/gerador.rs +3 -3
- src/jepa.rs +354 -328
- src/lib.rs +463 -412
- src/moe_redirecionavel.rs +52 -141
- src/nlg.rs +2 -2
- src/pensamento/combinador.rs +137 -0
- src/pensamento/mod.rs +84 -0
- src/pensamento/motor.rs +726 -0
- src/pensamento/quebra.rs +237 -0
- src/pensamento/raciocinio_elastico.rs +760 -0
- src/quantizador.rs +179 -120
- src/simd.rs +10 -2
- src/som4d.rs +319 -511
- src/telemetria.rs +2 -72
- src/tokenizador.rs +3 -96
- src/treino.rs +3 -99
- src/verificador.rs +88 -334
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
|
| 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.
|
| 2 |
-
|
| 3 |
-
> **v0.
|
| 4 |
-
>
|
| 5 |
-
>
|
| 6 |
-
>
|
| 7 |
-
>
|
| 8 |
-
>
|
| 9 |
-
>
|
| 10 |
-
> com
|
| 11 |
-
>
|
| 12 |
-
>
|
| 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 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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
|
| 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 |
-
"
|
| 6 |
-
"
|
| 7 |
-
"
|
| 8 |
-
"
|
| 9 |
-
"
|
| 10 |
-
"
|
| 11 |
-
"
|
| 12 |
-
"
|
| 13 |
-
"
|
| 14 |
-
"
|
| 15 |
-
"
|
| 16 |
-
"
|
| 17 |
-
"
|
| 18 |
-
"
|
| 19 |
-
"
|
| 20 |
-
"
|
| 21 |
-
"
|
| 22 |
-
"
|
| 23 |
-
"
|
| 24 |
-
"
|
| 25 |
-
"
|
| 26 |
-
"
|
| 27 |
-
"
|
| 28 |
-
"
|
| 29 |
-
"
|
| 30 |
-
"
|
| 31 |
-
"
|
| 32 |
-
"
|
| 33 |
-
"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 34 |
},
|
| 35 |
"medicoes": {
|
| 36 |
-
"
|
| 37 |
-
|
| 38 |
-
|
| 39 |
-
|
| 40 |
-
"
|
| 41 |
-
"
|
| 42 |
-
"
|
| 43 |
-
"
|
| 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 |
-
"
|
| 51 |
-
"
|
| 52 |
-
"
|
|
|
|
| 53 |
},
|
| 54 |
-
"
|
| 55 |
-
"
|
| 56 |
-
"
|
| 57 |
-
"certificados": 8,
|
| 58 |
-
"rollbacks": 0
|
| 59 |
},
|
| 60 |
-
"
|
| 61 |
-
"
|
| 62 |
-
"
|
| 63 |
-
"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 64 |
},
|
| 65 |
-
"
|
| 66 |
-
"qe_inicial": 5.001,
|
| 67 |
-
"qe_media_6ep": 3.9475,
|
| 68 |
-
"qe_mediana_6ep": 5.001
|
| 69 |
-
}
|
| 70 |
},
|
| 71 |
-
"veredito": "
|
| 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.
|
| 3 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 4 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 5 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 6 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 7 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 8 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 9 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 10 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 11 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 12 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 13 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 14 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 15 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 16 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 17 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 18 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 19 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 20 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 21 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 22 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 23 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 24 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 25 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 26 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 27 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 28 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 29 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 30 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 31 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 32 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 33 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 34 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 35 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 36 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 37 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 38 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 39 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 40 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 41 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 42 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 43 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 44 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 45 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 46 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 47 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 48 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 49 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 50 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 51 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 52 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 53 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 54 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 55 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 56 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 57 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 58 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 59 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 60 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 61 |
-
{"tipo":"ajuste","dados":{"passo":
|
| 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.
|
| 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.
|
| 99 |
let idx = ((self.clip_percentil / 100.0) * (v.len() - 1) as f64).round() as usize;
|
| 100 |
let novo = v[idx.min(v.len() - 1)].max(0.25);
|
| 101 |
if (novo - self.clip).abs() / self.clip > 0.3 {
|
|
@@ -187,7 +187,7 @@ impl AutoAjustePensamento {
|
|
| 187 |
return self.tau_c; // amostra insuficiente — mantém (honesto)
|
| 188 |
}
|
| 189 |
let mut v = self.confs_retidas.clone();
|
| 190 |
-
v.sort_by(|a, b| a.
|
| 191 |
let idx = (((1.0 - epsilon.clamp(0.0, 0.5)) * v.len() as f64).ceil() as usize)
|
| 192 |
.saturating_sub(1)
|
| 193 |
.min(v.len() - 1);
|
|
@@ -215,7 +215,7 @@ impl AutoAjustePensamento {
|
|
| 215 |
if razoes.len() < 4 {
|
| 216 |
return self.orcamento_b;
|
| 217 |
}
|
| 218 |
-
razoes.sort_by(|a, b| a.
|
| 219 |
let rho = razoes[razoes.len() / 2]; // mediana (robusto)
|
| 220 |
let delta0 = self.ganhos_por_iteracao.iter().cloned().fold(f64::MIN, f64::max).max(1e-9);
|
| 221 |
// B* = ceil( ln(c·(1−ρ)/Δ) / ln(ρ) ) — ótimo do custo marginal
|
|
@@ -236,7 +236,7 @@ impl AutoAjustePensamento {
|
|
| 236 |
return self.n_tentativas;
|
| 237 |
}
|
| 238 |
let mut v = self.acordos.clone();
|
| 239 |
-
v.sort_by(|a, b| a.
|
| 240 |
let a_med = v[v.len() / 2];
|
| 241 |
// lema do acordo: a = p² + (1−p)² ⇒ p = (1 + √(2a−1))/2 (a ≥ 1/2)
|
| 242 |
let p_chapeu = if a_med >= 0.5 {
|
|
|
|
| 95 |
pub fn clip_corrente(&mut self, hub: &mut TelemetryHub) -> f64 {
|
| 96 |
if self.normas_grad.len() >= 32 {
|
| 97 |
let mut v = self.normas_grad.clone();
|
| 98 |
+
v.sort_by(|a, b| a.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) ⇒
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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 |
-
|
| 250 |
-
|
| 251 |
-
|
| 252 |
Ok(())
|
| 253 |
}
|
| 254 |
|
|
|
|
| 246 |
}
|
| 247 |
let txt = serde_json::to_string(&serde_json::Value::Object(obj))
|
| 248 |
.map_err(|e| candle_core::Error::Msg(format!("serde: {e}")))?;
|
| 249 |
+
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.
|
| 153 |
-
|
| 154 |
-
///
|
| 155 |
-
|
| 156 |
-
///
|
| 157 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 158 |
}
|
| 159 |
|
| 160 |
impl NucleoJepa {
|
|
@@ -210,19 +183,20 @@ impl NucleoJepa {
|
|
| 210 |
m,
|
| 211 |
lambda_vc,
|
| 212 |
gamma_vc,
|
| 213 |
-
|
| 214 |
-
|
| 215 |
-
|
| 216 |
})
|
| 217 |
}
|
| 218 |
|
| 219 |
-
/// v0.
|
| 220 |
-
///
|
| 221 |
-
///
|
| 222 |
-
pub fn
|
| 223 |
-
self.
|
| 224 |
-
self.
|
| 225 |
-
self.
|
|
|
|
| 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
|
| 275 |
-
///
|
| 276 |
-
///
|
| 277 |
-
///
|
| 278 |
-
///
|
| 279 |
-
///
|
| 280 |
-
///
|
| 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 |
-
|
| 289 |
-
|
| 290 |
-
|
| 291 |
-
|
| 292 |
-
|
| 293 |
-
|
| 294 |
-
|
| 295 |
-
|
| 296 |
-
|
| 297 |
-
|
| 298 |
-
|
| 299 |
-
|
| 300 |
-
|
| 301 |
-
|
| 302 |
-
|
| 303 |
-
|
| 304 |
-
|
| 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 |
-
|
| 314 |
-
//
|
| 315 |
-
//
|
| 316 |
-
//
|
| 317 |
-
//
|
| 318 |
-
//
|
| 319 |
-
//
|
| 320 |
-
// contraexemplo foi exposto pelo teste de compatibilidade j1e
|
| 321 |
-
// (falsificação pedida pela crítica DeepSeek) — o gate agora valida
|
| 322 |
-
// contra a referência CORRETA. Efeito da correção: o termo passa a
|
| 323 |
-
// DESCORRELACIONAR dimensões (sua função provada); a dobradiça
|
| 324 |
-
// continua responsável pelo anti-colapso (J-1′).
|
| 325 |
let cov = (centr.transpose(0, 1)?.matmul(¢r)? / n)?; // (d, d)
|
| 326 |
let mask_fora = {
|
| 327 |
-
let mut m = vec![
|
| 328 |
for i in 0..d {
|
| 329 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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.
|
| 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.
|
| 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.
|
| 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.
|
| 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|
|
| 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.
|
| 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(¢r)? / 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(¢r)? / 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
|
| 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 |
-
|
| 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 |
-
|
| 135 |
-
|
| 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 |
-
|
| 167 |
-
|
| 168 |
-
|
| 169 |
-
|
| 170 |
-
|
|
|
|
| 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 |
-
|
|
|
|
|
|
|
|
|
|
| 258 |
})
|
| 259 |
}
|
| 260 |
|
| 261 |
fn estatisticas(&self) -> PyResult<PyObject> {
|
| 262 |
let s = self.ponte.estatisticas();
|
| 263 |
Python::with_gil(|py| {
|
| 264 |
-
|
|
|
|
|
|
|
|
|
|
| 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).
|
|
|
|
| 781 |
}
|
| 782 |
|
| 783 |
// ===========================================================================
|
|
@@ -810,11 +750,10 @@ struct CfgSom4DJ {
|
|
| 810 |
eta0: f64, eta1: f64,
|
| 811 |
semente: u64,
|
| 812 |
espalhada: bool,
|
| 813 |
-
/// v0.
|
| 814 |
-
|
| 815 |
-
|
| 816 |
-
|
| 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 |
-
|
| 886 |
-
|
| 887 |
-
|
| 888 |
-
|
| 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 {
|
| 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 |
-
|
| 925 |
-
"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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.
|
| 1008 |
-
if let Some(x) = o.get("
|
| 1009 |
-
c.
|
| 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 |
-
|
|
|
|
|
|
|
| 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 |
-
|
|
|
|
| 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 |
-
|
|
|
|
| 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 |
-
|
| 1367 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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)).
|
| 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 |
-
|
|
|
|
|
|
|
|
|
|
| 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).
|
| 1525 |
-
let ce = candle_nn::loss::cross_entropy(&logits, &at_t).
|
| 1526 |
-
let g = treino::grads_achatados(&ce, &[w_var.clone()]).
|
| 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).
|
| 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).
|
| 1539 |
-
.flatten_all().
|
| 1540 |
-
let corretos: Vec<bool> = logits_val.argmax(candle_core::D::Minus1).
|
| 1541 |
-
.eq(&at_v).
|
| 1542 |
-
.flatten_all().
|
| 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>().
|
| 1650 |
-
let y0 = moe.atencao.fwd(&x).
|
| 1651 |
-
let dif0 = (&y0 - &x).
|
| 1652 |
-
.to_scalar::<f32>().
|
| 1653 |
// abre o gate (mecanismo ativo)
|
| 1654 |
-
moe.atencao.gate.set(&candle_core::Tensor::new(1.0f32, &dev).
|
| 1655 |
// M-R1: invariância sob redirecionamento
|
| 1656 |
-
let s_enc = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).
|
| 1657 |
let carga_antes: usize = s_enc.carga.iter().sum();
|
| 1658 |
-
let perda_antes = s_enc.perda_aux.to_scalar::<f32>().
|
| 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).
|
| 1662 |
let carga_depois: usize = s_enc2.carga.iter().sum();
|
| 1663 |
-
let perda_depois = s_enc2.perda_aux.to_scalar::<f32>().
|
| 1664 |
// M-R3: paralelismo medido (enc ∥ dec em 2 threads)
|
| 1665 |
-
let (_e, _dc, t_par, t_seq, speedup) = moe.fwd_ambos_par(&x).
|
| 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)).
|
| 1925 |
-
let conf_base = verif.confianca_1d(&logits_fn(&base).
|
| 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)).
|
| 1942 |
-
let conf_base_ood = verif.confianca_1d(&logits_fn(&base_ood).
|
| 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).
|
| 2679 |
-
let at = Tensor::from_vec(av, (n,), &dev).
|
| 2680 |
let t0 = Instant::now();
|
| 2681 |
-
let (t_g, _, nll_g) = verificador::calibrar_temperatura(<, &at).
|
| 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(<, &at, 40).
|
| 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).
|
| 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).
|
| 2696 |
-
.
|
| 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().
|
| 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().
|
| 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).
|
| 2736 |
-
let moe = moe_redirecionavel::MoeRedirecionavel::novo(dm, em, 2, nm, &dev).
|
| 2737 |
-
let s_ref = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).
|
| 2738 |
-
let s_vet = moe.fwd_vetorizado(&x, moe_redirecionavel::Papel::Codificador).
|
| 2739 |
let dif_moe = (&s_ref.saida - &s_vet.saida)
|
| 2740 |
-
.
|
| 2741 |
.abs()
|
| 2742 |
-
.
|
| 2743 |
.max_all()
|
| 2744 |
-
.
|
| 2745 |
.to_scalar::<f32>()
|
| 2746 |
-
.
|
| 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).
|
| 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).
|
| 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)
|
| 2762 |
} else {
|
| 2763 |
-
moe.fwd(&x, moe_redirecionavel::Papel::Codificador)
|
| 2764 |
};
|
| 2765 |
-
let
|
| 2766 |
-
let
|
|
|
|
|
|
|
|
|
|
| 2767 |
let mut nr = 0.0;
|
| 2768 |
for v in moe.roteador.vars() {
|
| 2769 |
if let Some(g) = gs.get(&v) {
|
| 2770 |
-
|
|
|
|
|
|
|
| 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 |
-
|
|
|
|
|
|
|
| 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).
|
| 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).
|
| 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 |
-
/// **
|
| 2850 |
-
///
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 2851 |
#[pyfunction]
|
| 2852 |
-
|
| 2853 |
-
|
| 2854 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 2855 |
|
| 2856 |
-
//
|
| 2857 |
-
|
| 2858 |
-
|
| 2859 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 2860 |
}
|
| 2861 |
|
| 2862 |
-
|
| 2863 |
-
|
| 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!(
|
|
|
|
| 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(<, &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(<, &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.
|
| 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.
|
| 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′ (
|
| 493 |
-
///
|
| 494 |
-
///
|
| 495 |
-
///
|
| 496 |
-
///
|
| 497 |
-
///
|
| 498 |
-
///
|
| 499 |
-
///
|
| 500 |
-
///
|
| 501 |
-
///
|
| 502 |
-
///
|
|
|
|
|
|
|
| 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 |
-
|
|
|
|
|
|
|
|
|
|
| 509 |
let mut c = vec![1usize; m];
|
| 510 |
-
for _ in m..
|
| 511 |
-
// maior ganho marginal Δ
|
| 512 |
-
// empate ⇒
|
| 513 |
let (mut imax, mut gmax) = (0usize, f64::NEG_INFINITY);
|
| 514 |
-
for i in
|
| 515 |
let ci = c[i] as f64;
|
| 516 |
-
let ganho =
|
| 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.
|
| 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 |
-
|
| 1108 |
-
///
|
| 1109 |
-
///
|
| 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
|
| 1115 |
q.iter().zip(c).map(|(qi, ci)| qi * qi / *ci as f64).sum()
|
| 1116 |
};
|
| 1117 |
-
//
|
| 1118 |
-
|
| 1119 |
-
let
|
| 1120 |
-
let
|
| 1121 |
-
|
| 1122 |
-
|
| 1123 |
-
|
| 1124 |
-
|
| 1125 |
-
|
| 1126 |
-
|
| 1127 |
-
|
| 1128 |
-
|
| 1129 |
-
|
| 1130 |
-
|
| 1131 |
-
|
| 1132 |
-
|
| 1133 |
-
|
| 1134 |
-
|
| 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.
|
| 166 |
let med = ordenado[n / 2];
|
| 167 |
for (i, c) in candidatos.iter().enumerate() {
|
| 168 |
let lp = logps[i] - med;
|
|
@@ -258,7 +258,7 @@ impl DecodificadorEspeculativo {
|
|
| 258 |
let take = self.c_por_cabeca.min(self.c_por_cabeca.saturating_sub(k).max(1));
|
| 259 |
let v = lg.flatten_all().unwrap().to_vec1::<f32>().unwrap();
|
| 260 |
let mut idx: Vec<usize> = (0..v.len()).collect();
|
| 261 |
-
idx.sort_by(|&a, &b| v[b].
|
| 262 |
for t in idx.into_iter().take(take) {
|
| 263 |
if !candidatos.contains(&t) {
|
| 264 |
candidatos.push(t);
|
|
|
|
| 162 |
}
|
| 163 |
// normaliza logp por z-score robusto (mediana)
|
| 164 |
let mut ordenado = logps.to_vec();
|
| 165 |
+
ordenado.sort_by(|a, b| a.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 |
-
|
| 116 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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
|
| 68 |
-
|
| 69 |
-
|
| 70 |
-
///
|
| 71 |
-
///
|
| 72 |
-
|
| 73 |
-
///
|
| 74 |
-
///
|
| 75 |
-
|
| 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)>, // (
|
| 165 |
-
/// v0.
|
| 166 |
-
///
|
| 167 |
-
///
|
| 168 |
-
|
| 169 |
-
|
| 170 |
-
///
|
| 171 |
-
///
|
|
|
|
|
|
|
| 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 |
-
|
| 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
|
| 348 |
-
///
|
| 349 |
-
///
|
| 350 |
-
///
|
| 351 |
-
/// `
|
| 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
|
| 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
|
| 477 |
-
|
| 478 |
-
|
| 479 |
-
|
| 480 |
-
|
| 481 |
-
|
| 482 |
-
|
| 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 |
-
|
| 491 |
-
|
| 492 |
-
|
| 493 |
-
|
| 494 |
-
|
| 495 |
-
|
| 496 |
-
|
| 497 |
-
|
| 498 |
-
|
| 499 |
-
|
| 500 |
-
|
| 501 |
-
|
| 502 |
-
|
| 503 |
-
|
| 504 |
-
|
| 505 |
-
|
| 506 |
-
|
| 507 |
-
|
| 508 |
-
|
| 509 |
-
|
| 510 |
-
|
| 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′
|
| 534 |
-
let
|
| 535 |
-
|
| 536 |
-
|
|
|
|
|
|
|
|
|
|
| 537 |
}
|
| 538 |
}
|
| 539 |
let (eq_final, te_final) = eq_te(&prototipos);
|
| 540 |
-
|
| 541 |
-
|
| 542 |
-
let
|
| 543 |
-
|
| 544 |
-
|
| 545 |
-
|
| 546 |
-
|
| 547 |
-
|
| 548 |
-
|
| 549 |
-
|
| 550 |
-
|
| 551 |
-
|
| 552 |
-
|
| 553 |
-
|
| 554 |
-
|
| 555 |
-
|
| 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
|
| 578 |
-
eq_final
|
| 579 |
te_final,
|
| 580 |
-
historia
|
| 581 |
-
|
|
|
|
| 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
|
| 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′,
|
| 743 |
-
/// `
|
| 744 |
-
///
|
| 745 |
-
///
|
| 746 |
-
///
|
| 747 |
-
///
|
| 748 |
-
///
|
| 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 =
|
| 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.
|
| 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].
|
| 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.
|
| 1103 |
-
///
|
| 1104 |
-
///
|
| 1105 |
-
///
|
| 1106 |
-
///
|
| 1107 |
-
///
|
| 1108 |
-
|
| 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 |
-
|
| 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
|
| 1143 |
-
///
|
| 1144 |
-
///
|
| 1145 |
-
/// `
|
| 1146 |
-
/// (
|
| 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 |
-
|
| 1192 |
-
|
|
|
|
|
|
|
| 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
|
| 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.
|
| 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.
|
| 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
|
| 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 |
-
//
|
| 1420 |
-
|
| 1421 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1422 |
#[test]
|
| 1423 |
-
fn
|
| 1424 |
-
|
| 1425 |
-
|
| 1426 |
-
//
|
| 1427 |
-
|
| 1428 |
-
|
| 1429 |
-
|
| 1430 |
-
|
| 1431 |
-
|
| 1432 |
-
|
| 1433 |
-
|
| 1434 |
-
|
| 1435 |
-
|
| 1436 |
-
|
| 1437 |
-
|
| 1438 |
-
|
| 1439 |
-
|
| 1440 |
-
|
| 1441 |
-
|
| 1442 |
};
|
| 1443 |
-
let
|
| 1444 |
-
|
| 1445 |
-
|
| 1446 |
-
|
| 1447 |
-
|
| 1448 |
-
|
| 1449 |
-
|
| 1450 |
-
|
| 1451 |
-
|
| 1452 |
-
|
| 1453 |
-
|
| 1454 |
-
|
| 1455 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1456 |
}
|
| 1457 |
|
|
|
|
|
|
|
| 1458 |
#[test]
|
| 1459 |
-
fn
|
| 1460 |
-
|
| 1461 |
-
|
| 1462 |
-
|
| 1463 |
-
|
| 1464 |
-
|
| 1465 |
-
|
| 1466 |
-
|
| 1467 |
-
|
| 1468 |
-
|
| 1469 |
-
|
| 1470 |
-
|
| 1471 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1472 |
}
|
| 1473 |
-
|
| 1474 |
-
|
| 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
|
| 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
|
| 1533 |
-
let
|
|
|
|
| 1534 |
let cfg = CfgSom4D {
|
| 1535 |
-
nx: 2, ny:
|
| 1536 |
-
epocas:
|
| 1537 |
-
|
| 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 |
-
|
| 1548 |
-
|
| 1549 |
-
|
| 1550 |
-
|
| 1551 |
-
|
| 1552 |
-
)
|
|
|
|
|
|
|
| 1553 |
}
|
| 1554 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1555 |
#[test]
|
| 1556 |
-
fn
|
| 1557 |
-
|
| 1558 |
-
|
| 1559 |
-
|
| 1560 |
-
|
| 1561 |
-
let
|
| 1562 |
-
|
| 1563 |
-
let
|
| 1564 |
-
|
| 1565 |
-
|
| 1566 |
-
|
| 1567 |
-
|
| 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 |
-
|
| 1595 |
-
|
| 1596 |
-
|
| 1597 |
-
let
|
| 1598 |
-
|
| 1599 |
-
|
| 1600 |
-
|
| 1601 |
-
|
| 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
|
| 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
|
| 1623 |
-
|
| 1624 |
-
|
| 1625 |
-
|
| 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.
|
| 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.
|
| 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 |
-
|
| 489 |
-
|
| 490 |
-
|
| 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 |
-
|
| 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 =
|
| 81 |
-
.
|
| 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
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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
|
| 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.
|
| 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); //
|
|
|
|
|
|
|
| 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 |
-
|
| 572 |
-
|
| 573 |
-
|
| 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
|
| 596 |
-
|
| 597 |
-
|
| 598 |
-
|
| 599 |
-
|
| 600 |
-
);
|
| 601 |
-
|
| 602 |
-
|
| 603 |
-
|
| 604 |
-
|
| 605 |
-
|
| 606 |
-
|
| 607 |
-
|
| 608 |
-
|
| 609 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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(<, &at, 40).unwrap();
|
| 804 |
-
let (t_g, _, _) = calibrar_temperatura(<, &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(<, &at, 40).unwrap();
|
| 825 |
-
let (t_g, _, _) = calibrar_temperatura(<, &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(<, &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(<, &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(<, &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 |
}
|