v0.7.0: FNH gate de punição + árvore de pesos indexada (arestas duplas) + quebra-cabeça do Pensamento + NLP/NLG + decodificador especulativo + auto-ajuste SOM limitado + correções v070-1/2/3 — 73/73 gates, 84/84 cargo, provas r-28..r-32 (part 7)
f4c204d verified | //! PROVAS EXECUTÁVEIS (gates de integração) do KHTST_RUST v0.7.0. | |
| //! | |
| //! Regra da casa (r-08 §1): *contar a estrutura não é verificar a função* — | |
| //! toda verificação precisa de um `assert` que FALHE se o invariante quebrar. | |
| //! Os 54 testes unitários vivem inline em cada módulo; ESTE arquivo contém os | |
| //! GATES DE INTEGRAÇÃO entre módulos (vazamentos, paridades, neutralidades | |
| //! e os gates novos da v0.7.0: FNH, árvore de pesos, quebra-cabeça, NLP/NLG). | |
| //! | |
| //! Histórico: os gates G1/G2/G4/G10 da v0.3.0 migraram para a suíte Python | |
| //! (V4 máscara 0 vazamentos, V10 paridade NFE=L) e para testes inline dos | |
| //! módulos (ssd, quantizador, mascaras); os gates G9/G12 da mistura de planos | |
| //! tornaram-se obsoletos com a remoção da CabecaMistura (v0.4.0 — a mistura | |
| //! vive hoje no verificador, ver F_mistura_verificador.md e verificador.rs). | |
| //! | |
| //! | gate | o que prova | módulos | | |
| //! |---|---|---| | |
| //! | G5 | nascimento neutro do FiLM (γ=β=ξ=ζ=0 ⇒ identidade) | gerador+tronco | | |
| //! | M8 | PCGrad não-piora (⟨g_comb, g_i⟩ ≥ 0 ∀i) | perdas+treino | | |
| //! | G13 | FNH: R∈SO(n) exato + neutralidade com punição baixa | fnh | | |
| //! | G14 | FNH: gate de punição monotoneidade + migração de escala idempotente | fnh | | |
| //! | G15 | árvore de pesos: partição de índices + simetria das arestas duplas | arvore_pesos | | |
| //! | G16 | árvore: agregação fundo-topo = soma global (indução na árvore) | arvore_pesos | | |
| //! | G17 | quebra-cabeça: todo aceito tem confiança ≥ τ_c (soundness V-2) | pensamento+verificador | | |
| //! | G18 | NLP/NLG: nascimento neutro (Δ=0 bit-a-bit) | nlp+nlg | | |
| //! | G19 | decodificador especulativo: inocuidade (distribuição preservada) | nlg | | |
| //! | G20 | rotação no Pensamento: ortogonalidade preservada pós-ciclo | pensamento+stiefel | | |
| use candle_core::{Device, Result, Tensor}; | |
| /// G5 — NASCIMENTO NEUTRO: com o tronco recém-construído (γ=0, β=0, ξ=0, | |
| /// ζ=0), aplicar_film é a IDENTIDADE bit-a-bit, qualquer que seja o resumo. | |
| fn gate_g5_nascimento_neutro_film() -> Result<()> { | |
| use khtst_rust::config::ConfigKhtst; | |
| use khtst_rust::gerador::GeradorConceitos; | |
| let mut cfg = ConfigKhtst::default(); | |
| cfg.modelo.vocab = 64; | |
| cfg.modelo.d_modelo = 32; | |
| cfg.modelo.n_camadas = 2; | |
| cfg.modelo.n_cabecas = 4; | |
| cfg.modelo.d_ff = 64; | |
| cfg.modelo.comprimento_ctx = 8; | |
| cfg.ncm.niveis = vec![2, 4, 8]; | |
| cfg.ncm.d_lat = 8; | |
| cfg.ncm.k_por_nivel = 8; | |
| cfg.ncm.ativo = true; | |
| cfg.modelo.mtp.ativo = false; | |
| cfg.validar().expect("config do gate G5"); | |
| let dev = Device::Cpu; | |
| let ger = GeradorConceitos::novo(&cfg, &dev)?; | |
| let x = Tensor::randn(0f32, 1f32, (2, 4, cfg.modelo.d_modelo), &dev)?; | |
| let resumo = Tensor::randn(0f32, 1f32, (2, cfg.modelo.d_modelo), &dev)?; | |
| for nivel in 1..=cfg.l_niveis() { | |
| let y = ger.tronco.aplicar_film(&x, &resumo, nivel)?; | |
| let dif = (&x - &y)?.abs()?.max_all()?.to_scalar::<f32>()?; | |
| assert_eq!(dif, 0.0, "G5: FiLM deve ser identidade no nascimento (nível {nivel})"); | |
| } | |
| Ok(()) | |
| } | |
| /// M8 — PCGrad projeta contra os gradientes ORIGINAIS (invariante de | |
| /// não-piora: ⟨g_combinado, g_i⟩ ≥ 0 para toda perda i). | |
| fn gate_m8_pcgrad_nao_piora() { | |
| let g1 = vec![Some(vec![1.0f32]), Some(vec![-2.0])]; | |
| let g2 = vec![Some(vec![-1.0f32]), Some(vec![0.5])]; | |
| let combinado = khtst_rust::treino::pcgrad_achatado(vec![g1.clone(), g2.clone()]); | |
| let ip = |a: &Vec<Option<Vec<f32>>>, b: &Vec<Option<Vec<f32>>>| -> f64 { | |
| let mut s = 0f64; | |
| for (x, y) in a.iter().zip(b.iter()) { | |
| if let (Some(x), Some(y)) = (x, y) { | |
| s += x.iter().zip(y.iter()).map(|(p, q)| *p as f64 * *q as f64).sum::<f64>(); | |
| } | |
| } | |
| s | |
| }; | |
| let ip1 = ip(&combinado, &g1); | |
| let ip2 = ip(&combinado, &g2); | |
| assert!(ip1 >= -1e-9, "⟨g, g1⟩ = {ip1} ≥ 0 (não-piora)"); | |
| assert!(ip2 >= -1e-9, "⟨g, g2⟩ = {ip2} ≥ 0 (não-piora)"); | |
| } | |