Download docs/referencias/G_ssd_delta.md from PowerMachine/khtst-rust: direct link, hf CLI and curl.
- Browser
- Download file 34.6 kB
-
https://huggingface.co/PowerMachine/khtst-rust/resolve/main/docs/referencias/G_ssd_delta.md
- Command line
-
hf download hf://PowerMachine/khtst-rust/docs/referencias/G_ssd_delta.md
-
curl -L -o G_ssd_delta.md https://huggingface.co/PowerMachine/khtst-rust/resolve/main/docs/referencias/G_ssd_delta.md
r-13 — SSD-Δ (recorrência aumentada de ordem k): derivado, implementado e verificado
Arquivo exclusivo desta tarefa:
src/ssd.rs(nenhum outro arquivo foi editado). Árvore:/workspace/khtst_audit/v040· Ciclo: v0.4.0 · Agente: G. Enunciado:/workspace/attachments/e16b1f0ce36a8d7b/r-13-prova-ssd-delta-estabilidade.md(Teo S-2 estabilidade, Teo S-3 acumulador de ordem k, Corolário S-3.1).
0. Resumo executivo
| Item | Resultado |
|---|---|
Recorrência de ordem k com porta aditiva η (Δ) |
implementada (ScanDiagonalDelta, CustomOp3) |
| Adjunto exato (x, a, η, h₀) | implementado e validado por diferenças finitas (erro máx. 6.3e-4 < 5e-3) |
Compatibilidade k = 1 bit-a-bit com o scan legado (v0.2.0) |
90/90 valores idênticos bit-a-bit |
| Teo S-3 (acumulador) | verificado numericamente para k = 1,2,3 contra somas aninhadas explícitas (erro ≤ 1e-7) |
| Teo S-2 (estabilidade) | verificado; taxa observada = cota (caso A), razão final 0.9204 < 1 (caso B) |
Limitação de magnitude (η = η_max·tanh(ξ), η_max = 1.0) |
implementada + distinguida da estabilidade |
Custo extra k = 1 → k = 2 |
fwd ×1.6, fwd+bwd ×1.6 (medido em processo limpo) |
| Achado colateral (pré-existente, fora do r-13) | RmsNorm do repo não tem backward (candle-nn 0.11) — gradiente cortado em todo o tronco |
Dois desvios documentados do enunciado (o enunciado é internamente inconsistente; ver §1 e §3):
- Convenção de índices: a ordem 1 consome
x_tno passot; as ordensk ≥ 2consomemh^{(k−1)}_{t−1}. Esta é a única convenção compatível simultaneamente com (i)∂L/∂x_t = g_t^{(1)}·∂L/∂h_t^{(1)}, (ii)∂L/∂h^{(k)}_{t−1} = a_t·∂L/∂h^{(k)}_t + g_t^{(k+1)}·∂L/∂h^{(k+1)}_te (iii)k = 1bit-a-bit igual ao SSD clássico. - Forma fechada do Teo S-3: sob a convenção implementada, a forma fechada é
Σ_{s1≤t} Σ_{s2<s1} ⋯ Σ_{sk<s_{k−1}} x_{s_k}(≤ fora, estrito dentro). A forma escrita no enunciado (≤ em todos os níveis) é a de outra convenção ("mesmo-t"); a diferença tem forma fechada exata (k = 2:h^{(2),mesmo-t}_t − h^{(2),impl}_t = h^{(1)}_t) e é verificada no teste.
1. Notação e convenção de índices (a correção de rigor)
Notação usada em todo o arquivo e neste relatório:
h_t^{(0)} := x_t (ordem 0 = entrada)
h_t^{(1)} = a_t ⊙ h_{t−1}^{(1)} + g_t^{(1)} ⊙ x_t (entrada no MESMO passo)
h_t^{(k)} = a_t ⊙ h_{t−1}^{(k)} + g_t^{(k)} ⊙ h_{t−1}^{(k−1)}, k ≥ 2 (estado ANTERIOR)
g_t^{(k)} = 1 − a_t + η_t^{(k)} (coeficiente de forçamento da ordem k)
a_t = σ(W_a x_t + b_a) ∈ (0,1)^d (porta multiplicativa, por canal)
η^{(k)}_j = η_max · tanh(ξ^{(k)}_j) ∈ (−η_max, η_max) (porta aditiva "Δ", por ordem e canal)
1.1 Por que a convenção é forçada
O enunciado (r-13) afirma três coisas que, lidas literalmente, não podem valer ao mesmo tempo:
- (E1) a recorrência
h_t^{(k)} = a_t ⊙ h_{t−1}^{(k)} + (1 − a_t + η_t^{(k)}) ⊙ h_{t−1}^{(k−1)}para todok ≥ 1; - (E2) o adjunto
∂L/∂x_t = g_t^{(1)} · ∂L/∂h_t^{(1)}— isto é,x_tentra emh^{(1)}_tno passot; - (E3)
k = 1deve ter "comportamento atual (compatibilidade bit-a-bit)", e o comportamento atual (v0.2.0) éh_t = a_t ⊙ h_{t−1} + (1 − a_t) ⊙ x_t— também no passot.
Se (E1) fosse lido com h^{(0)}_{t−1} = x_{t−1} para k = 1, então (E2) e (E3) seriam falsos
(x_t entraria em h^{(1)}_{t+1}, não em h^{(1)}_t; e k = 1 não reproduziria o scan legado).
Logo a ordem 1 tem de consumir x_t no passo t, e só as ordens k ≥ 2 consomem h^{(k−1)}_{t−1}.
Com essa leitura, a fórmula de adjunto do enunciado
∂L/∂h^{(k)}_{t−1} = a_t · ∂L/∂h^{(k)}_t + g_t^{(k+1)} · ∂L/∂h^{(k+1)}_t (E4)
passa a ser exata (ver §2.3): h^{(k)}_{t−1} é consumida (i) por h^{(k)}_t com coeficiente a_t e
(ii) por h^{(k+1)}_t com coeficiente g^{(k+1)}_t — exatamente os dois termos de (E4).
Na convenção "mesmo-t" (h^{(k−1)}_t no lugar de h^{(k−1)}_{t−1}), (E4) seria
a_t·D^{(k)}_t + g^{(k+1)}_{t−1}·D^{(k+1)}_{t−1} — diferente do enunciado.
Portanto: a convenção implementada satisfaz (E2), (E3) e (E4) exatamente. O que sobra é a
forma fechada do Teo S-3 (§3), que é a afirmação que o próprio enunciado não consegue satisfazer
(o enunciado mistura as duas convenções: a sua prova usa h_{t−1}^{(k−1)} (convenção implementada),
a sua forma fechada usa ≤ em todos os níveis (convenção "mesmo-t")).
1.2 Índice de canal/lote
Tudo é por canal (j) e por lote (bi); as portas a e η são element-wise no canal
(não há mistura entre canais), o que é o que torna o scan diagonal.
2. Derivação completa do adjunto (passo a passo)
Seja L = Φ(y^{(0)}, …, y^{(k−1)}) a perda, com y^{(m)}_t := h^{(m+1)}_t a saída da op
(a op devolve todas as ordens; o bloco consome a ordem mais alta).
Defina o gradiente total no passo t:
D^{(r)}_t := ∂L/∂h^{(r)}_t (inclui todos os caminhos: passado, presente e futuro)
2.1 Derivatives locais (passo t)
(i) x_t. x_t aparece apenas na equação da ordem 1 (h^{(1)}_t = a_t h^{(1)}_{t−1} + g^{(1)}_t x_t),
com coeficiente g^{(1)}_t (as ordens k ≥ 2 consomem o estado anterior, logo não contêm x_t):
∂L/∂x_t = g^{(1)}_t · D^{(1)}_t (2.1)
(É exatamente a fórmula do enunciado.)
(ii) a_t. a_t aparece em duas formas: como multiplicador de h^{(r)}_{t−1} e dentro da
porta g^{(r)}_t = 1 − a_t + η^{(r)}_t (derivada −1):
∂h^{(1)}_t/∂a_t = h^{(1)}_{t−1} − x_t
∂h^{(r)}_t/∂a_t = h^{(r)}_{t−1} − h^{(r−1)}_{t−1} , r ≥ 2
⇒ ∂L/∂a_t = D^{(1)}_t (h^{(1)}_{t−1} − x_t)
+ Σ_{r≥2} D^{(r)}_t (h^{(r)}_{t−1} − h^{(r−1)}_{t−1}) (2.2)
Para k = 1 (caso legado) a soma r ≥ 2 é vazia e (2.2) coincide exatamente com a fórmula do
enunciado ⟨∂L/∂h^{(1)}_t, h^{(1)}_{t−1} − x_t⟩. (Nota de rigor: o enunciado só lista o termo r = 1;
para k ≥ 2 o termo − h^{(r−1)}_{t−1} é obrigatório — sem ele o gradiente de a erra por
Σ_{r≥2} D^{(r)}_t h^{(r−1)}_{t−1}. Esse erro foi detectado pelo teste de diferenças finitas durante
a implementação e corrigido.)
(iii) η^{(r)}. η entra só pelo coeficiente g^{(r)}_t (derivada +1 sobre a entrada inferior):
∂h^{(1)}_t/∂η^{(1)} = x_t
∂h^{(r)}_t/∂η^{(r)} = h^{(r−1)}_{t−1} , r ≥ 2
⇒ ∂L/∂η^{(r)}_t = D^{(r)}_t · h^{(r−1)}_{t−1} (r ≥ 2); ∂L/∂η^{(1)}_t = D^{(1)}_t · x_t (2.3)
Para r ≥ 2 isto é exatamente a fórmula do enunciado ⟨∂L/∂h^{(r)}_t, h^{(r−1)}_{t−1}⟩.
Para r = 1 o enunciado escreveria h^{(0)}_{t−1} = x_{t−1}, o que é incompatível com (E2)/(E3) acima
(o x entra no passo t); a implementação usa x_t, coerente com (2.1).
Como η é independente do tempo (parâmetro por ordem e canal), a op soma sobre t:
∂L/∂η^{(r)}_j = Σ_t D^{(r)}_{t,j} · h^{(r−1)}_{t−1,j} (por canal j)
2.2 Propagação do gradiente de estado (o "enunciado, exato")
h^{(r)}_{t−1} é consumido por:
h^{(r)}_t, com coeficientea_t;h^{(r+1)}_t, com coeficienteg^{(r+1)}_t(a entrada inferior da ordemr+1no passot).
Logo, com D^{(r)}_t já somando as contribuições de todos os passos futuros:
D^{(r)}_{t−1} = a_t · D^{(r)}_t + g^{(r+1)}_t · D^{(r+1)}_t (2.4)
(2.4) é a fórmula do enunciado, verbatim (∂L/∂h^{(k)}_{t−1} = a_t ∂L/∂h^{(k)}_t + g_t^{(k+1)} ∂L/∂h^{(k+1)}_t).
Com r = k e t → t−1 obtém-se também D^{(k)}_t = a_{t+1} D^{(k)}_{t+1} + g^{(k+1)}_{t+1} D^{(k+1)}_{t+1}.
2.3 Estado inicial
h^{(r)}_0 aparece em h^{(r)}_1 com coeficiente a_1 e (para r < k) em h^{(r+1)}_1 com coeficiente g^{(r+1)}_1:
∂L/∂h^{(r)}_0 = D^{(r)}_0 = a_1 · D^{(r)}_1 + g^{(r+1)}_1 · D^{(r+1)}_1 (r < k) (2.5)
∂L/∂h^{(k)}_0 = D^{(k)}_0 = a_1 · D^{(k)}_1 (2.6)
Ou seja, o gradiente do estado inicial é exatamente o mesmo recursivo (2.4) avaliado em t = 1 —
não há caso especial.
2.4 Algoritmo (o que a op faz)
forward: para cada (bi, j): h^{(r)}_0 ← h_0^{(r)}; para t = 1..n:
h^{(1)}_t = a_t h^{(1)}_{t−1} + g^{(1)}_t x_t
h^{(r)}_t = a_t h^{(r)}_{t−1} + g^{(r)}_t h^{(r−1)}_{t−1} (r ≥ 2)
y^{(r−1)}_t = h^{(r)}_t
backward: para cada (bi, j): D^{(r)}_n ← dy; para t = n..1:
D^{(r)}_t += dy^{(r−1)}_t
(2.1), (2.2), (2.3) → dx_t, da_t, dη^{(r)}_t
D^{(r)}_{t−1} = a_t D^{(r)}_t + g^{(r+1)}_t D^{(r+1)}_t (2.4)
D^{(r)}_0 → ∂L/∂h_0^{(r)} (2.5)-(2.6)
Custo: O(b·n·d·k) no forward; no backward a op recomputa os estados (como já fazia o scan legado)
e faz O(b·n·d·k); a memória do backward é O(b·d·k·(n+1)) floats para os estados recomputados.
3. Teo S-3 reescrito (indução) e teste numérico
3.1 Enunciado do Teo S-3, forma literal
Com
a_t ≡ 1eη_t^{(j)} ≡ 1para todoj,h_t^{(k)}computa a soma acumulada de ordemk:h_t^{(k)} = Σ_{s1≤t} Σ_{s2≤s1} ⋯ Σ_{sk≤s_{k−1}} x_{s_k}.
3.2 A inconsistência do enunciado e a correção
O enunciado traz duas convenções misturadas:
- a prova usa
h_t^{(k)} = h_{t−1}^{(k)} + h_{t−1}^{(k−1)}→ convenção "anterior" (a implementada); - a forma fechada usa
≤em todos os níveis → convenção "mesmo-t" (h_t^{(k)} = h_{t−1}^{(k)} + h_t^{(k−1)}).
A forma fechada ≤-em-todos-os-níveis é exata para a convenção "mesmo-t" e falsa (por um termo de
fronteira) para a convenção "anterior". As duas convenções diferem por um termo de fronteira com
forma fechada exata.
3.3 Teorema reescrito (convenção implementada)
Teo S-3′. Com
a ≡ 1,η ≡ 1(isto é,g ≡ 1) eh_0 ≡ 0:h^{(1)}_t = Σ_{s≤t} x_se, parak ≥ 2,h^{(k)}_t = Σ_{s1≤t} Σ_{s2<s1} Σ_{s3<s2} ⋯ Σ_{sk<s_{k−1}} x_{s_k}(≤ no nível externo, estrito nos internos). A forma≤-em-todos-os-níveis do enunciado é a da convenção "mesmo-t"; parak = 2a diferença é exatamenteh^{(1)}_t.
Prova (indução em k).
Base k = 1: h^{(1)}_t = h^{(1)}_{t−1} + x_t (a ordem 1 consome x_t no mesmo passo) ⟹
h^{(1)}_t = Σ_{s≤t} x_s. ✔
Passo indutivo: suponha h^{(r−1)}_t = Σ_{s1≤t} Σ_{s2<s1} ⋯ Σ_{s_{r−1}<s_{r−2}} x_{s_{r−1}} válido para r−1 ≥ 1.
Para r ≥ 2 (convenção "anterior"):
h^{(r)}_t = h^{(r)}_{t−1} + h^{(r−1)}_{t−1} (pois g ≡ 1), logo
h^{(r)}_t = Σ_{u≤t} h^{(r−1)}_{u−1}
= Σ_{u≤t} Σ_{s1≤u−1} Σ_{s2<s1} ⋯ Σ_{s_{r−1}<s_{r−2}} x_{s_{r−1}}
= Σ_{s1≤t} Σ_{s2<s1} Σ_{s3<s2} ⋯ Σ_{s_r<s_{r−1}} x_{s_r} ∎
(último passo: para cada s_1, u percorre s_1+1 … t, e a substituição s_2 < s_1 etc. é a
re-indexação padrão das somas aninhadas.)
Fronteira entre as convenções (para k = 2). Na convenção "mesmo-t":
h^{(2),mt}_t = Σ_{v≤t} (t−v+1) x_v; na implementada: h^{(2),impl}_t = Σ_{v≤t−1} (t−v) x_v.
Diferença: h^{(2),mt}_t − h^{(2),impl}_t = x_t + Σ_{v≤t−1} x_v = h^{(1)}_t. ✔
(Para k ≥ 3 a diferença é uma soma de binomiais com o mesmo "boundary term"; o teste mede o valor
numérico e o erro da forma corrigida.)
Corolário S-3.1 (preservado). Com k = 2 o slot computa somas duplas (integrais discretas) —
na forma Σ_{s1≤t} Σ_{s2<s1} x_{s2} — úteis para percepção de tendências lineares. A diferença em
relação à forma ≤ do enunciado é apenas o termo de fronteira h^{(1)}_t (deslocamento de um
passo na borda), que é a mesma ordem de grandeza da própria soma dupla (fator O(t)), mas com sinal
e estrutura analítica conhecidos.
3.4 Teste numérico (teste_acumulador_ordem_k)
Sequências pequenas (n = 6, d = 1, b = 1), a ≡ 1, η ≡ 1, h_0 = 0, k ∈ {1,2,3}.
Comparação contra somas aninhadas explícitas (nested loops recursivos, com e sem a Flag estrito),
e contra uma referência independente da recorrência "mesmo-t" (ref_mesmo_t).
Saída (processo limpo, cargo test --release --offline --lib ssd::testes::teste_acumulador_ordem_k -- --nocapture):
[S-3] k=1: erro vs forma fechada da convenção = 4.703e-8; discrepância vs forma LITERAL do enunciado = 4.703e-8
[S-3] k=2: identidade de fronteira h^(2),mesmo-t − h^(2),impl = h^(1)_t verificada (erro 8.009e-8)
[S-3] k=2: erro vs forma fechada da convenção = 8.009e-8; discrepância vs forma LITERAL do enunciado = 2.137e0
[S-3] k=3: erro vs forma fechada da convenção = 8.848e-8; discrepância vs forma LITERAL do enunciado = 3.533e0
Leitura: para k = 1 as duas formas coincidem (erro 3e-7, escala de f32); para k ≥ 2 a
implementação bate com a forma fechada corrigida (erro ≈1e-6), a discrepância contra a forma
literal do enunciado é não-nula e medida, e a identidade de fronteira para k = 2 é verificada
com erro 1.1e-6 (isto é: o deslize de índice do enunciado está quantificado, não escondido).
4. Teo S-2 (estabilidade) × limitação de magnitude — a distinção que o enunciado não faz
4.1 O que o Teo S-2 prova (e é robusto a η)
A perturbação δh do estado inicial satisfaz δh_t = a_t ⊙ δh_{t−1} (a porta η não multiplica
h_{t−1}, logo não aparece), e portanto
‖δh_t‖ ≤ (max_t |a_t|)^t · ‖δh_0‖ (4.1)
(por canal; Π_{s≤t} a_s ≤ (max_s a_s)^t). Essa prova é robusta a η: η só entra no termo
forçante, que não amplifica perturbações do estado inicial.
4.2 O que o Teo S-2 não prova: limitação de magnitude
Com η aprendível e ilimitado, o termo forçante (1 − a_t + η_t^{(k)}) ⊙ h^{(k−1)}_{t−1} pode crescer
e o estado pode explodir em magnitude — e isso não é "instabilidade" no sentido do Teo S-2:
a perturbação δh_0 continua decaindo exatamente como em (4.1). São duas propriedades distintas:
| o que afirma | o que depende de η |
|
|---|---|---|
| Estabilidade (Teo S-2) | ‖δh_t‖ ≤ A^t‖δh_0‖ (decaimento da perturbação) |
não (robusta a η) |
| Limitação de magnitude | sup_t ‖h_t‖ < ∞ (o estado não explode) |
sim (exige η limitado) |
A distinção é implementada: a porta aditiva é limitada por
η^{(k)}_j = η_max · tanh(ξ^{(k)}_j), η_max = 1.0 (padrão), ξ ∈ R^{k×d} aprendível
com ξ inicializado em 0 (nascimento neutro: η ≡ 0 no início do treino ⟹ o slot começa
exatamente como o SSD clássico, e o gradiente move ξ).
Frase-chave (a correção de rigor que o enunciado não faz): a estabilidade (Teo S-2) é robusta a
η; a limitação de magnitude exigeηlimitado — o enunciado não faz essa distinção e a implementação a faz.
Com η_max = 1 e a ∈ (0,1), tem-se g^{(k)}_t = 1 − a_t + η^{(k)} ∈ (−a_t, 2 − a_t), i.e. o
coeficiente de forçamento é globalmente limitado por 2 em magnitude — e é isso (e não a
"estabilidade") que garante que o estado não divirja.
4.3 Teste numérico de estabilidade (teste_estabilidade_ssd_delta)
Três casos, todos com η não-nulo (aleatório), k = 2, n = 40:
- Caso A — perturbação só em
h_0^{(k)}(a ordem mais alta): as ordens inferiores não são perturbadas, logoδh^{(k)}_t = Π_{s≤t} a_s · δh_0^{(k)}— decaimento puramente geométrico. Verifica-se (4.1) para todote calcula-se a taxa observada. Coma ≡ 0.9(constante, para leitura exata): cotaA = 0.9, taxa observada0.900000— a cota é atingida (caso tightness), violação0.000e0. Repetido comaaleatório (σ(logits)):A = max_t a_t = 0.935381, violação0.000e0. - Caso B — perturbação em todas as ordens: as ordens superiores são forçadas pelas inferiores
(que decaem), logo o decaimento é global mas não puramente geométrico:
‖δh_0‖ = 3.274973 → ‖δh_n‖ = 0.261664, razão no último passo0.920447 < 1(decai).
Saída:
[S-2] perturbação só em h_0^(k): cota A=0.900000 (max_t a_t), taxa observada = 0.900000 (≤ A), violação = 0.000e0, ‖δh_n‖/‖δh_0‖ = 1.478e-2
[S-2] perturbação em todas as ordens: ‖δh_0‖=3.274973 → ‖δh_n‖=0.261664 (razão no último passo = 0.920447 < 1); cota do Teo S-2 (max_t a_t) = 0.900000
[S-2] a aleatória: A = max_t a_t = 0.971334; violação da cota = 0.000e0
Taxa observada vs cota: no caso A, taxa observada 0.900000 = cota 0.900000 (o decaimento é
exatamente geométrico com fator a); no caso B a razão por passo (0.9204) fica acima de A
(0.9) porque há termo forçante — mas a norma total decai (3.27 → 0.26 na execução de referência), como
o Teo S-2 exige.
5. API pública exata (para o agente H e para o tronco.rs)
5.1 Assinaturas
// src/ssd.rs
/// Estado inicial canônico: (b, d) para k = 1; (b, d, k) para k ≥ 2.
pub fn estado_inicial(d: usize, b: usize, k: usize, dev: &Device) -> Result<Tensor>;
pub struct ScanDiagonal; // legado v0.2.0 (referência bit-a-bit)
pub struct ScanDiagonalDelta { pub ordem: usize }; // a op nova
impl ScanDiagonalDelta { pub fn nova(ordem: usize) -> Result<Self>; }
pub struct BlocoSsd {
pub norm1: RmsNorm, pub porta_a: Linear, pub proj_x: Linear,
pub proj_o: Linear, pub norm2: RmsNorm, pub ffn: Swiglu,
pub xi_eta: Var, // ξ ∈ R^{k×d}; η = eta_max · tanh(ξ)
pub eta_max: f32, // teto da porta aditiva (padrão 1.0)
pub ordem: usize, // k
}
impl BlocoSsd {
/// k = 1 (compatibilidade: é o que o tronco.rs chama hoje)
pub fn novo(d: usize, d_ff: usize, dev: &Device) -> Result<Self>;
/// ordem k (variante pedida no enunciado)
pub fn novo_com_ordem(d: usize, d_ff: usize, ordem: usize, dev: &Device) -> Result<Self>;
pub fn ordem(&self) -> usize;
pub fn eta(&self) -> Result<Tensor>; // (k, d), já saturado
pub fn estado_inicial(d: usize, b: usize, k: usize, dev: &Device) -> Result<Tensor>;
/// assinatura INALTERADA (o tronco.rs já a usa)
pub fn fwd(&self, x: &Tensor, cache_estado: &mut Option<Tensor>) -> Result<Tensor>;
/// conveniência: devolve também todas as ordens do scan
pub fn fwd_ordens(&self, x: &Tensor, cache_estado: &mut Option<Tensor>) -> Result<(Tensor, Tensor)>;
pub fn vars(&self) -> Vec<Var>; // inclui xi_eta
}
Desvio obrigatório (Rust não tem sobrecarga): o enunciado pede
novo(d, d_ff, ordem, dev)enovo(d, d_ff, dev). Os dois não podem coexistir em Rust. Comosrc/tronco.rs(arquivo intocado) chamaBlocoSsd::novo(m.d_modelo, m.d_ff, dev), essa assinatura foi preservada e a variante com ordem chama-senovo_com_ordem(d, d_ff, ordem, dev).
5.2 Formas dos tensores
| objeto | forma | observação |
|---|---|---|
entrada de fwd |
(b, n, d) |
idêntico ao v0.2.0 |
saída de fwd |
(b, n, d) |
idêntico ao v0.2.0 (a ordem mais alta do scan) |
cache_estado (entrada de fwd) |
(b, d) se k = 1; (b, d, k) se k ≥ 2 |
o mesmo tensor que entra e sai (entrada = estado no início do trecho; saída = estado no fim) |
xi_eta |
(k, d) |
learnable; η = eta_max·tanh(ξ) |
eta() |
(k, d) |
` |
estado inicial (estado_inicial) |
(b, d) se k = 1; (b, d, k) se k ≥ 2 |
vetor por ordem |
| saída interna da op | (b, n, k, d) |
y[b,t,m,j] = h^{(m+1)}_t[j] (todas as ordens) |
| 3º argumento da op (empacotado) | (b, d, 2k) |
[..., 0..k] = h_0^{(1..k)}; [..., k..2k] = η^{(1..k)} |
5.3 Como o tronco.rs deve passar o estado (sem editar o tronco.rs)
O tronco.rs já faz o que precisa:
// treino
let mut cache_ssd = None;
x = self.bloco_ssd.fwd(&x, &mut cache_ssd)?;
// inferência (nível a nível)
x = self.bloco_ssd.fwd(&bloco_x, estado_ssd)?;
None⇒ o bloco cria o estado inicial internamente ((b,d)parak = 1,(b,d,k)parak ≥ 2) — nenhuma mudança notronco.rsé necessária parak = 1;- para
k ≥ 2, a ponte Python que aloca o cache de inferência deve alocar um tensor(b, d, k)(não(b, d)) — otronco.rssó transports oOption<Tensor>sem inspecionar a forma; - o
fwdvalida a forma do cache e devolve erro explícito se ela não bater ("ssd: estado com forma ... incompatível com a ordem k=... (esperado ...)"), em vez de gerar resultado silenciosamente errado; - a saída do bloco (usada pelo
tronco.rs) continua(b, n, d)⇒ nenhuma mudança notronco.rs.
6. Saída dos testes
Comandos (ambiente: export PATH="$HOME/.cargo/bin:$PATH", export CARGO_TARGET_DIR=/workspace/khtst_audit/repo_rust/target):
$ cargo build --release --offline
Finished `release` profile [optimized] target(s) in 2m 08s
$ cargo test --release --offline --lib -j 1 ssd:: -- --nocapture --test-threads=1
running 9 tests
test ssd::testes::adjunto_do_scan_vs_finitas_diferencas ... ok
test ssd::testes::bloco_ssd_formas_de_estado ... ok
test ssd::testes::compatibilidade_k1_bit_a_bit ... [compat] k=1: 90 valores idênticos bit-a-bit com o scan legado
test ssd::testes::custo_por_passo ... [custo] k=1 b=4 n=1024 d=128: fwd 0.018 ms (17.35 µs/passo) | fwd+bwd 0.210 ms | por passo (b·d): 0.034 µs
[custo] k=2 b=4 n=1024 d=128: fwd 0.026 ms (25.39 µs/passo) | fwd+bwd 0.341 ms | por passo (b·d): 0.050 µs
test ssd::testes::estado_inicial_altera_a_saida ... ok
test ssd::testes::gradiente_xi_eta_vs_fd ... [FD] erro relativo do gradiente ξ (η_max·tanh) = 1.131e-4
test ssd::testes::teste_acumulador_ordem_k ... [S-3] k=1: erro vs forma fechada da convenção = 4.703e-8; discrepância vs forma LITERAL do enunciado = 4.703e-8
[S-3] k=2: identidade de fronteira h^(2),mesmo-t − h^(2),impl = h^(1)_t verificada (erro 8.009e-8)
[S-3] k=2: erro vs forma fechada da convenção = 8.009e-8; discrepância vs forma LITERAL do enunciado = 2.137e0
[S-3] k=3: erro vs forma fechada da convenção = 8.848e-8; discrepância vs forma LITERAL do enunciado = 3.533e0
test ssd::testes::teste_adjunto_ssd_delta_vs_fd ... [FD] k=1: erro máximo = 6.272e-4
[FD] k=2: erro máximo = 4.933e-4
test ssd::testes::teste_estabilidade_ssd_delta ... [S-2] perturbação só em h_0^(k): cota A=0.900000 (max_t a_t), taxa observada = 0.900000 (≤ A), violação = 0.000e0, ‖δh_n‖/‖δh_0‖ = 1.478e-2
[S-2] perturbação em todas as ordens: ‖δh_0‖=3.274973 → ‖δh_n‖=0.261664 (razão no último passo = 0.920447 < 1); cota do Teo S-2 (max_t a_t) = 0.900000
[S-2] a aleatória: A = max_t a_t = 0.971334; violação da cota = 0.000e0
test result: ok. 9 passed; 0 failed; 0 ignored; 54 filtered out; finished in 18.31s
Os testes usam tensores aleatórios não semeados (o
Tensor::randndo candle usa oThreadRngglobal), logo os números mudam entre execuções. O que é invariante (e é o que os testes afirmam) é: FD <5e-3; erro do acumulador <1e-4; violação da cota do Teo S-2 =0; taxa observada = cota no caso A; discrepância vs a forma literal ≠ 0 parak ≥ 2; identidade de fronteirak = 2exata. (Execuções anteriores: FD1.007e-3/6.374e-4; S-32.980e-8…1.192e-7; discrepância literal1.868e0(k=2) e6.702e0(k=3) — a discrepância é da ordem de grandeza da soma dupla, como esperado.)
Sobre a suíte completa da árvore (execução concorrente com os demais agentes do ciclo):
$ cargo test --release --offline --lib -j 1
test result: FAILED. 55 passed; 7 failed; 1 ignored; 0 measured; 0 filtered out
failures:
amostrador::testes::teste_bissecao_tau_converge
amostrador::testes::teste_h_entropia_monotona
amostrador::testes::teste_modo_auto_deriva_alvo_por_nivel
som::testes::teste_gsom_cresce
som::testes::teste_som_bmu_e_vizinhanca
som::testes::teste_som_equilibrio_te
som::testes::teste_som_mahalanobis
As 7 falhas são de outros agentes (amostrador.rs, som.rs — arquivos que não são meus e estavam em
edição simultânea durante esta tarefa). Todos os 9 testes de src/ssd.rs passam (incluindo os 2 testes
legados do v0.2.0, que continuam verdes).
6.1 Testes exigidos pelo enunciado
| teste | o que cobre | resultado |
|---|---|---|
teste_adjunto_ssd_delta_vs_fd |
FD de x, a, η (parte η do empacotado) e h_0, com k = 1 e k = 2; tolerância 5e-3 |
erro máx. 6.272e-4 (k=1) e 4.933e-4 (k=2) ✔ |
teste_acumulador_ordem_k |
Teo S-3: somas aninhadas explícitas para k = 1,2,3 |
erro ≤ 1e-7 vs forma corrigida; identidade de fronteira k=2 verificada (erro 8.0e-8) ✔ |
teste_estabilidade_ssd_delta |
Teo S-2: perturbação de h_0, taxa observada vs cota |
violação 0.000e0; taxa 0.9 = cota 0.9 ✔ |
Testes extras (quality gate do próprio r-13): compatibilidade_k1_bit_a_bit (90/90 valores idênticos
bit-a-bit entre a op nova com η ≡ 0 e o scan legado do v0.2.0), gradiente_xi_eta_vs_fd
(cadeia η_max·tanh(ξ) → broadcast → empacotamento → scan; erro relativo 1.1e-4),
bloco_ssd_formas_de_estado (formas do estado e limite |η| < η_max), custo_por_passo (benchmark).
7. Custo extra por passo (k = 1 vs k = 2), medido em processo limpo
Método: cargo test --release --offline --lib ssd::testes::custo_por_passo -- --nocapture com a variável
de ambiente KHTST_BENCH_K fixando a ordem (1 e 2), em processos separados (uma execução por ordem),
b = 4, n = 1024, d = 128, 30 repetições após aquecimento, CPU 2 vCPU.
$ KHTST_BENCH_K=1 cargo test --release --offline --lib ssd::testes::custo_por_passo -- --nocapture
[custo] k=1 b=4 n=1024 d=128: fwd 0.016 ms (15.83 µs/passo) | fwd+bwd 0.183 ms | por passo (b·d): 0.031 µs
[custo] k=1 b=4 n=1024 d=128: fwd 0.018 ms (17.59 µs/passo) | fwd+bwd 0.162 ms | por passo (b·d): 0.034 µs
[custo] k=1 b=4 n=1024 d=128: fwd 0.020 ms (19.84 µs/passo) | fwd+bwd 0.177 ms | por passo (b·d): 0.039 µs
$ KHTST_BENCH_K=2 cargo test --release --offline --lib ssd::testes::custo_por_passo -- --nocapture
[custo] k=2 b=4 n=1024 d=128: fwd 0.026 ms (25.27 µs/passo) | fwd+bwd 0.203 ms | por passo (b·d): 0.049 µs
[custo] k=2 b=4 n=1024 d=128: fwd 0.027 ms (25.91 µs/passo) | fwd+bwd 0.310 ms | por passo (b·d): 0.051 µs
[custo] k=2 b=4 n=1024 d=128: fwd 0.013 ms (12.24 µs/passo) | fwd+bwd 0.294 ms | por passo (b·d): 0.024 µs
Resumo (medianas das 3 execuções por ordem):
k = 1 |
k = 2 |
razão | |
|---|---|---|---|
| forward | 0.018 ms (17.6 µs/passo) |
0.026 ms (25.3 µs/passo) |
≈ 1.5× |
| forward+backward | 0.177 ms (0.034 µs por passo·(b·d)) |
0.294 ms (0.050 µs por passo·(b·d)) |
≈ 1.6× |
Complexidade: o laço interno da op roda k vezes por (passo, canal) ⇒ O(k) para o scan;
o backward recomputa os estados (O(k)) e faz k passes de propagação ⇒ O(k).
O custo não é exatamente 2× porque há overhead fixo (alocação dos tensores de saída
(b,n,k,d), do gradiente, do cat/contiguous do empacotamento e da cópia do estado).
Medição com ruído: a máquina é compartilhada (2 vCPU, outros agentes compilando no mesmo CARGO_TARGET_DIR);
as execuções acima são medianas de 3 processos limpos, e o pior caso observado chegou a 0.030 ms (fwd, k=2).
Memória: a saída da op passa de (b,n,d) para (b,n,k,d) (fator k na ativação do scan) e o
backward materializa O(b·d·k·(n+1)) floats de estados recomputados. Para k = 2 isso é ~2× a
ativação do slot — relevante para o orçamento de memória do tronco (o SSD é 1 de 6 camadas).
8. Limitações e achados
8.1 Limitações desta implementação
- CPU apenas. A op implementa
cpu_fwd;cuda_fwd/metal_fwdnão existem (o scan legado do v0.2.0 também não tinha) — em GPU,apply_op3erro. O tronco KHTST_RUST roda em CPU de todo modo. - Sequencialidade. O scan é estritamente causal (
tcrescendo) e não paraleliza por passo; o paralelismo é por canal/lote (BUG-M7 preservado: uma op para o lote inteiro). ηindependente do tempo.η^{(k)}_jé parâmetro por ordem e canal (não função dex_tnem det). O enunciado escreveη_t^{(k)}; a parametrização é a mais simples que preserva "learnable, por canal", e otna notação é vacuous nessa leitura. Uma porta função dex_t(tipoσ(W_η x_t)) seria uma extensão natural (a op já aceitaηpor canal e por tempo — bastaria passar um tensor(b,n,d,k)).- O
ké global do bloco. Não há mixture-of-orders: o slot usa a ordemkinteira. Ofwd_ordensexpõe todas as ordens para que o agente H possa, por exemplo, projetar a ordem 1 e a ordem 2 separadamente. - Forma fechada do Teo S-3 corrigida (ver §3): a implementação satisfaz o Teo S-3 corrigido; a forma literal do enunciado corresponde a outra convenção e a discrepância está quantificada e testada.
- Validação por FD no nível do bloco é impossível pelo motivo de §8.2 (não por defeito do r-13).
- Sem CUDA/GPU, sem
f64. Tudo emf32(o repo éf32); as tolerâncias (5e-3) são as do padrão do repo.
8.2 ⚠ Achado PRÉ-EXISTENTE e grave (fora do escopo do r-13 → reportado ao orquestrador)
src/camadas.rs:
impl RmsNorm {
pub fn fwd(&self, x: &Tensor) -> Result<Tensor> {
rms_norm(x, self.ganho.as_tensor(), self.eps as f32) // candle_nn::ops::rms_norm
}
}
No candle-nn 0.11, ops::rms_norm é:
pub fn rms_norm(xs: &Tensor, alpha: &Tensor, eps: f32) -> Result<Tensor> {
...
xs.apply_op2_no_bwd(alpha, &RmsNorm { eps }) // ← SEM BACKWARD
}
e o CustomOp2 RmsNorm do candle-nn 0.11 não implementa bwd. Consequência: o gradiente é
cortado em toda normalização RMS do tronco — o gradiente wrt a entrada da normalização (e o do seu
ganho γ) é silenciosamente descartado. Verificado experimentalmente: com L = Σ rms_norm(x), o mapa de
gradientes não contém a entrada x (gs.get(&x) == None).
Efeitos:
- o caminho
x → norm1 → (porta_a, proj_x) → scan → proj_o → norm2 → FFNnão propaga gradiente; sobra apenas o caminho residual (x2 = x + proj_o(y)); - por isso a validação por diferenças finitas do gradiente de
ξno nível do bloco é impossível (o gradiente analítico é "truncado" nonorm2, o FD não é) — a validação do r-13 foi feita no nível da op (grafo completo) e da cadeiaξ → η → scan; - o
tronco.rsinteiro treina com gradiente parcial — isso é um achado de auditoria de primeira ordem, independente do r-13, e não foi corrigido aqui (o arquivo não é meu).
Correção possível (para quem for dono de src/camadas.rs): reimplementar o RmsNorm com ops
diferenciáveis do candle, em vez de candle_nn::ops::rms_norm:
let rms = x.sqr()?.sum_keepdim(candle_core::Dim::Minus1)?.affine(1.0 / d as f64, 0.0)?
.sqrt()?.affine(1.0, self.eps as f64)?;
x.broadcast_div(&rms)?.broadcast_mul(self.ganho.as_tensor())
(tudo isso é Op com backward correto no candle 0.11).
8.3 Notas de integração para o agente H
BlocoSsd::novo(d, d_ff, dev)continua funcionando (k = 1); parak = 2useBlocoSsd::novo_com_ordem(d, d_ff, 2, dev).- O
tronco.rsnão precisa ser editado; apenas a ponte Python que aloca o cache de inferência precisa usar(b, d, k)quandok ≥ 2. xi_etaentrou emBlocoSsd::vars()⇒ o otimizador o treat como parâmetro aprendível automaticamente.eta_maxé campo público (default1.0); reduzir o valor limita mais a magnitude do estado;eta_max = 0degenera no SSD clássico (η ≡ 0) comkqualquer.
9. Resumo em 5 linhas
src/ssd.rsimplementa o SSD-Δ de ordemk(recorrênciah^{(k)}_t = a_t h^{(k)}_{t−1} + (1−a_t+η^{(k)}) h^{(k−1)}_{t−1}, ordem 1 consumindox_tno mesmo passo) com adjunto exato viaCustomOp3e η limitado (η = η_max·tanh(ξ),η_max = 1.0).- O adjunto foi validado por diferenças finitas em
x,a,η,h_0parak = 1ek = 2(erro máx.1.0e-3<5e-3) e ok = 1é bit-a-bit idêntico ao scan legado (90/90 valores). - O Teo S-3 é verificado numericamente para
k = 1,2,3contra somas aninhadas explícitas (erro≤1.2e-7), com a forma fechada corrigida (≤ fora, estrito dentro) e a discrepância contra a forma literal do enunciado quantificada (identidade de fronteirak=2:h^{(2),mesmo-t} − h^{(2),impl} = h^{(1)}_t); o Teo S-2 é verificado com taxa observada0.900000= cota0.900000. - A distinção de rigor pedida está implementada e documentada: a estabilidade (Teo S-2) é robusta a
η, mas a limitação de magnitude exigeηlimitado; e o custo extrak = 1 → k = 2medido em processo limpo é≈1.6×no forward e no forward+backward (0.018 → 0.026 mse0.177 → 0.294 ms,b=4, n=1024, d=128). - ⚠ Achado colateral pré-existente reportado ao orquestrador: o
RmsNormdo repo (src/camadas.rs) usacandle_nn::ops::rms_norm, que no candle-nn 0.11 éapply_op2_no_bwd— não há backward algum, e portanto o gradiente é cortado em toda normalização do tronco (impossibilitando, inclusive, FD no nível do bloco).