PowerMachine commited on
Commit
326dec4
·
verified ·
1 Parent(s): b7bbfef

Delete tests/test_aurora_v3.py

Browse files
Files changed (1) hide show
  1. tests/test_aurora_v3.py +0 -327
tests/test_aurora_v3.py DELETED
@@ -1,327 +0,0 @@
1
- # -*- coding: utf-8 -*-
2
- """Testes v3 — verificações de PROPRIEDADES dos Teoremas do doc 11:
3
- ortogonalidade exata de Cayley, limites de gradiente serial, gating convexo,
4
- convergência recursiva com corte, Hutchinson diag-H (contra quadrática
5
- analítica), cotas de Bernstein/PAC-Bayes, K adaptativo (máscara + economia),
6
- PRS V8 (histerese, percentil robusto, SGDR), memória interna (escrita
7
- conficiente, evicção, VQ, contratos), LPT (4/3-aprox) e causalidade.
8
- """
9
- from __future__ import annotations
10
-
11
- import math
12
- import sys
13
- import os
14
-
15
- sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
16
-
17
- import torch
18
- import torch.nn.functional as F
19
-
20
- from aurora.config import Config
21
- from aurora.memoria.interna import MemoriaInterna, QuantizadorVetorialEMA, PERMISSOES
22
- from aurora.nucleo.modelo import AURORAModel
23
- from aurora.percepcao.microunidades import (ComposicaoMicroUnidades, ConvCausal,
24
- GestorCrescimento, GRUCausal,
25
- RotacaoCayley, BiGRUNaoCausal)
26
- from aurora.treino.confianca import (AgenteConfianca, PosteriorBeta,
27
- mascara_k_adaptativa)
28
- from aurora.treino.prs_v8 import PRSV8
29
- from aurora.treino.mtp import MTPAurora
30
-
31
- _falhas = []
32
-
33
-
34
- def verifica(nome: str, cond: bool, detalhe: str = ""):
35
- marca = "✓" if cond else "✗"
36
- print(f" {marca} {nome} {detalhe}")
37
- if not cond:
38
- _falhas.append(nome)
39
-
40
-
41
- torch.manual_seed(2026)
42
-
43
- print("== Rotação de Cayley: ortogonalidade EXATA (doc 11 §11.7) ==")
44
- rot = RotacaoCayley(32)
45
- R = rot.matriz()
46
- err = float((R.t() @ R - torch.eye(32)).abs().max())
47
- verifica("Cayley: ‖RᵀR−I‖_max < 1e-5 (exata, sem truncamento)", err < 1e-5, f"({err:.2e})")
48
- det = float(torch.linalg.det(R))
49
- verifica("Cayley: det(R) = +1 (SO(n))", abs(det - 1.0) < 1e-4, f"({det:.4f})")
50
-
51
- print("== Conv causal + GRU causal: causalidade ==")
52
- conv = ConvCausal(32, kernel=3)
53
- x = torch.randn(1, 16, 32)
54
- y = conv(x)
55
- x2 = x.clone()
56
- x2[0, 10:] = 7.0
57
- y2 = conv(x2)
58
- verifica("ConvCausal: futuro não muda passado", float((y[:, :10] - y2[:, :10]).abs().max()) < 1e-6)
59
- gru = GRUCausal(32, 16)
60
- y = gru(x)
61
- x2 = x.clone()
62
- x2[0, 10:] = 7.0
63
- y2 = gru(x2)
64
- verifica("GRUCausal: futuro não muda passado", float((y[:, :10] - y2[:, :10]).abs().max()) < 1e-6)
65
- bigru = BiGRUNaoCausal(32)
66
- yb = bigru(x)
67
- x2[0, 10:] = 7.0
68
- yb2 = bigru(x2)
69
- verifica("BiGRU (não causal, encoders): futuro SÍ afeta passado (contexto total)",
70
- float((yb[:, :5] - yb2[:, :5]).abs().max()) > 1e-4)
71
-
72
- print("== Composição serial com resíduo: gradiente em [1−ΣγL, 1+ΣγL] (Teorema 11.1) ==")
73
- stem0 = ConvCausal(64, kernel=3)
74
- stem1 = GRUCausal(64, 32)
75
- with torch.no_grad():
76
- for p in list(stem0.parameters()) + list(stem1.parameters()):
77
- p.mul_(0.05) # L pequena → cota inferior positiva
78
- if p.dim() == 1:
79
- p.zero_()
80
- g_stem = 1.0 / math.sqrt(2.0) # γ = 1/√n (Corolário 11.2)
81
-
82
-
83
- def cadeia(z):
84
- y = z + g_stem * stem0(z) # resíduo serial 1
85
- y = y + g_stem * stem1(y) # resíduo serial 2
86
- return y
87
-
88
-
89
- x = torch.randn(1, 24, 64)
90
- J = torch.autograd.functional.jacobian(cadeia, x, vectorize=True)
91
- J = J.reshape(24 * 64, 24 * 64)
92
- s = torch.linalg.svdvals(J)
93
- sigma_min, sigma_max = float(s.min()), float(s.max())
94
- verifica("serial com resíduo: σ_min(J) ≥ 1−ΣγL (gradiente não desaparece)",
95
- sigma_min > 0.5, f"(σ_min={sigma_min:.3f})")
96
- verifica("serial: σ_max(J) ≤ 1+ΣγL (não explode)", sigma_max < 1.6, f"(σ_max={sigma_max:.3f})")
97
-
98
- print("== Gating convexo + refino recursivo (Teoremas 11.2/11.4) ==")
99
- comp2 = ComposicaoMicroUnidades(64, {"d_gru": 32, "d_ramo": 32, "d_refino": 48,
100
- "gamma_rec": 0.5, "k_rec_max": 4})
101
- y = comp2(torch.randn(2, 12, 64), tarefa="instrucao")
102
- alpha = comp2.ultimo_alpha
103
- verifica("gating convexo: Σα = 1, α ≥ 0", abs(float(alpha.sum()) - 1.0) < 1e-5 and bool((alpha >= 0).all()))
104
- verifica("recursiva respeita k_max", comp2.ultimo_passos_rec <= comp2.k_rec_max)
105
- verifica("forma de saída (B,T,d)", y.shape == (2, 12, 64))
106
- # temperatura por confiança: h baixo → α mais plano (mais exploração)
107
- comp2.gate.eval()
108
- comp2.registrar_confianca(1.0)
109
- a_conf = comp2(torch.randn(1, 8, 64)).sum()
110
- alpha_conf = comp2.ultimo_alpha.clone()
111
- comp2.registrar_confianca(0.0)
112
- comp2(torch.randn(1, 8, 64))
113
- alpha_expl = comp2.ultimo_alpha
114
- entropia = lambda a: float(-(a * (a + 1e-9).log()).sum())
115
- verifica("confiança baixa → α mais PLANO (exploração, doc 11 §8)",
116
- entropia(alpha_expl) >= entropia(alpha_conf) - 1e-4,
117
- f"(H_conf={entropia(alpha_conf):.3f} ≤ H_expl={entropia(alpha_expl):.3f})")
118
-
119
- print("== Crescimento: expandir/podar e LPT (Teorema 11.5, Prop. 11.3) ==")
120
- n0 = len(comp2.nome_ramos)
121
- idx = comp2.expandir("conv")
122
- verifica("expandir adiciona ramo", len(comp2.nome_ramos) == n0 + 1 and idx == n0)
123
- gate_ok = comp2.gate[2].weight.shape[0] == len(comp2.nome_ramos)
124
- verifica("gate cresce com nova coluna (uso inicial ~0)", gate_ok)
125
- y2 = comp2(torch.randn(1, 8, 64))
126
- verifica("forward após expansão ok", y2.shape == (1, 8, 64))
127
- podou = comp2.podar(idx)
128
- y3 = comp2(torch.randn(1, 8, 64))
129
- verifica("podar desativa ramo (forward segue)", podou and y3.shape == (1, 8, 64))
130
- ordem, makespan = GestorCrescimento.ordem_lpt([1.0, 6.0, 2.0, 3.0], n_unidades=2)
131
- verifica("LPT: ordem por custo decrescente", ordem == [1, 3, 2, 0])
132
- # cota 4/3: em instância {6,5,5,4,4,3,3,3} com 3 unidades, OPT=10, LPT ≤ 13.33
133
- _, mk = GestorCrescimento.ordem_lpt([6, 5, 5, 4, 4, 3, 3, 3], n_unidades=3)
134
- verifica("LPT: makespan ≤ (4/3)·ÓTIMO", mk <= (4.0 / 3.0) * 10.0 + 1e-9, f"({mk:.1f} ≤ 13.33)")
135
-
136
- print("== Hutchinson diag-H correto (Lema 11.1, contra quadrática analítica) ==")
137
- P = torch.nn.Parameter(torch.randn(6, 4))
138
- A = torch.randn(24, 24)
139
- H_analitica = A.t() @ A + torch.eye(24)
140
-
141
-
142
- def perda_quadratica():
143
- v = P.flatten()
144
- return 0.5 * v @ H_analitica @ v
145
-
146
-
147
- class _CompFake:
148
- """Adapter: expõe .ramos como lista de um 'módulo' com os parâmetros."""
149
-
150
- def __init__(self, params):
151
- from torch import nn as _nn
152
- self.ramos = _nn.ModuleList([_nn.Linear(1, 1, bias=False)]) # dummy p/ .parameters compat
153
- # substitui parâmetros reais: hack de teste — parametriza via attribute
154
- self._params = [P]
155
- self.nome_ramos = ["mlp"]
156
- self.ramo_ativo = torch.ones(1)
157
- self.uso_ema = torch.tensor([0.5])
158
- self.expandir = lambda *a, **k: 0
159
- self.podar = lambda *a, **k: False
160
-
161
-
162
- class _GestorDiag(GestorCrescimento):
163
- def _diag_hessiano(self, perda_fn):
164
- g = torch.autograd.grad(perda_fn(), [P], create_graph=True)[0]
165
- g_flat = g.reshape(-1) # (24,)
166
- diag_flat = torch.zeros(24)
167
- for _ in range(64):
168
- v = torch.randn_like(g_flat).sign()
169
- hv = torch.autograd.grad((g_flat * v).sum(), [P],
170
- retain_graph=True)[0].reshape(-1)
171
- diag_flat += (v * hv).detach() / 64.0
172
- return diag_flat, float(diag_flat.abs().sum())
173
-
174
-
175
- g = _GestorDiag([_CompFake([P])], {})
176
- diag, total = g._diag_hessiano(perda_quadratica)
177
- diag = diag.flatten() if isinstance(diag, torch.Tensor) else diag
178
- if isinstance(diag, torch.Tensor):
179
- erro_relativo = float((diag - torch.diag(H_analitica)).abs().max()
180
- / torch.diag(H_analitica).abs().max())
181
- verifica("Hutchinson: diag estimada ≈ diag analítica (err_rel < 0.35)",
182
- erro_relativo < 0.35, f"({erro_relativo:.3f})")
183
- else:
184
- verifica("Hutchinson: diag estimada ≈ diag analítica", False, "(tipo inesperado)")
185
-
186
- print("== AgenteConfiança: Beta, Bernstein e calibração (Teoremas 11.8) ==")
187
- post = PosteriorBeta()
188
- torch.manual_seed(7)
189
- for _ in range(400):
190
- post.atualizar(int(torch.rand(1) < 0.7), int(torch.rand(1) >= 0.7))
191
- lo, hi = post.bernstein(delta=0.05)
192
- verifica("Bernstein: θ*=0.7 ∈ [μ̂−ε, μ̂+ε]", lo <= 0.7 <= hi, f"([{lo:.3f}, {hi:.3f}])")
193
- verifica("posterior converge à média real", abs(post.media - 0.7) < 0.08, f"({post.media:.3f})")
194
- ag = AgenteConfianca()
195
- feats = torch.tensor([2.0, 0.3, 1.0, 0.0])
196
- h1 = float(ag(feats, perda_atual=2.0))
197
- h2 = float(ag(feats, perda_atual=3.5)) # perda subiu → punição assimétrica
198
- verifica("κ assimétrico: perda subindo NÃO sobe h", h2 <= h1 + 0.35,
199
- f"(h1={h1:.3f}, h2={h2:.3f})")
200
- hp = AgenteConfianca.confianca_posicional(logits=torch.randn(2, 8, 100) * 5)
201
- verifica("h_posicional ∈ [0,1] com forma (B,T)", hp.shape == (2, 8) and bool((hp >= 0).all()) and bool((hp <= 1).all()))
202
-
203
- print("== MTP K adaptativo: máscara e economia (Teorema 11.6) ==")
204
- mtp = MTPAurora(32, k_cabecas=3)
205
- h = torch.randn(2, 16, 32)
206
- emb = torch.randn(64, 32)
207
- alvo = torch.randint(0, 64, (2, 16))
208
- p_sem = mtp.perda(h, emb, alvo)
209
- h_conf = torch.zeros(2, 16) # confiança 0 → K_t = 1 em toda posição
210
- p_com = mtp.perda(h, emb, alvo, h_conf=h_conf)
211
- termos = mtp.ultimos["termos_ce"]
212
- verifica("K adaptativo: menos termos de CE com h=0 (economia ~2/3)",
213
- termos > 0 and termos < (2 * 15 * 3) * 0.45, f"({termos:.0f} de 90)")
214
- h_conf2 = torch.ones(2, 16)
215
- mtp.perda(h, emb, alvo, h_conf=h_conf2)
216
- termos2 = mtp.ultimos["termos_ce"]
217
- verifica("K adaptativo: h=1 mantém todos os K termos", termos2 >= termos * 1.5)
218
- masc = mascara_k_adaptativa(torch.tensor([[0.0, 0.5, 1.0]]), 1, 4)
219
- esperada = torch.tensor([[[1., 0., 0., 0.], [1., 1., 0., 0.], [1., 1., 1., 1.]]])
220
- verifica("máscara K_t = clamp(round(K_min+(K_max−K_min)h))", bool((masc == esperada).all()))
221
-
222
- print("== PRS V8 (Teoremas 11.7a–f) ==")
223
- prs = PRSV8({"warmup": 2, "T_ciclo": 50})
224
- t_up = prs.trust
225
- prs.atualizar_trust(True)
226
- subida = prs.trust - t_up
227
- prs.atualizar_trust(False)
228
- queda = t_up - prs.trust
229
- verifica("7.1 histerese: η_up > η_down (recuperação ≠ queda)", subida > queda)
230
- for _ in range(30):
231
- prs.passo_batch(2.0 if _ % 2 else 1.0)
232
- clip_antigo = prs.clip_atual
233
- for _ in range(6):
234
- prs.clip(50.0) # outliers
235
- clip_outlier = prs.clip_atual
236
- for _ in range(20):
237
- prs.clip(1.0) # regime normal volta
238
- clip_normal = prs.clip_atual
239
- verifica("7.3 percentil robusto: outlier não relaxa clip além do cap 5×base",
240
- clip_outlier <= prs.clip_base * 5.0 + 1e-6 and clip_normal < clip_outlier,
241
- f"(outlier={clip_outlier:.2f}, normal={clip_normal:.2f})")
242
- lrs = [prs.lr(t) for t in range(120)]
243
- verifica("7.2 SGDR: existem restarts (lr sobe após vale)",
244
- max(lrs[60:]) > max(lrs[50:60]) * 0.9)
245
- verifica("7.5 streak: recompensa log cresce sem saturar",
246
- (1 + prs.coef_streak * math.log1p(100)) > (1 + prs.coef_streak * math.log1p(10)))
247
-
248
- print("== Memória interna (doc 11 §9) ==")
249
- mem = MemoriaInterna(d=32, n_slots=8, h_escrita=0.5, idade_compressao_s=0.0)
250
- z1 = torch.randn(32)
251
- verifica("escrita conficiente rejeita h < h_escrita", not mem.escrever(z1, 0.3, origem="percepcao"))
252
- verifica("escrita conficiente aceita h ≥ h_escrita", mem.escrever(z1, 0.8, origem="percepcao"))
253
- try:
254
- mem.escrever(z1, 0.9, origem="raciocinio")
255
- verifica("contrato: raciocinio NÃO escreve (Teorema §10)", False)
256
- except PermissionError:
257
- verifica("contrato: raciocinio NÃO escreve (Teorema §10)", True)
258
- try:
259
- mem.escrever(z1, 0.9, origem="percepcao")
260
- mem.consultar(z1, origem="treino")
261
- # treino pode consultar — ok; agora tenta consolidar como percepcao (proibido)
262
- try:
263
- mem.comprimir_antigos(origem="percepcao")
264
- verifica("contrato: percepcao não consolida", False)
265
- except PermissionError:
266
- verifica("contrato: percepcao não consolida", True)
267
- except Exception as e:
268
- verifica("memória: operações básicas", False, str(e))
269
- for i in range(10):
270
- mem.escrever(torch.randn(32), 0.6 + 0.04 * (i % 5), origem="percepcao")
271
- verifica("evicção respeita n_slots", len(mem.slots) <= 8)
272
- rec = mem.consultar(z1, m=3, origem="nucleo")
273
- verifica("consulta devolve o próprio z como top-1", rec["indices"] and
274
- float(torch.cdist(rec["vetores"][0].unsqueeze(0), z1.unsqueeze(0))) < 1e-5)
275
- n_comp = mem.comprimir_antigos(origem="treino")
276
- verifica("compressão VQ de antigos (idade=0)", n_comp > 0)
277
- verifica("codebook: entropia de uso finita", 0.0 <= mem.vq.entropia_uso() <= math.log(64))
278
- economia = mem.estatisticas()["economia_bits_por_slot"]
279
- verifica("economia teórica 1 − log₂N/(32d) > 0.99", economia > 0.99, f"({economia:.4f})")
280
- q = QuantizadorVetorialEMA(32, 8)
281
- Z = torch.randn(16, 8)
282
- qq, perda_vq, idx = q(Z)
283
- verifica("VQ-EMA: saída com straight-through e perda finita",
284
- qq.shape == Z.shape and torch.isfinite(perda_vq))
285
-
286
- print("== Modelo integrado v3 (BlocoV3 + confiança + MTP adaptativo) ==")
287
- cfg = Config()
288
- modelo = AURORAModel(cfg, usar_multimodal=False)
289
- modelo.train()
290
- ids = torch.randint(0, 8000, (2, 48))
291
- alvo = torch.randint(0, 8000, (2, 48)); alvo[:, 0] = -100
292
- logits, perda = modelo(ids, alvo=alvo, tarefa="instrucao")
293
- verifica("forward v3 com BlocoV3: perda finita", torch.isfinite(perda))
294
- modelo.registrar_confianca(0.2)
295
- verifica("registrar_confianca propaga aos compositores",
296
- all(abs(b.composto._confianca - 0.2) < 1e-6 for b in modelo.blocos))
297
- h_conf = AgenteConfianca.confianca_posicional(logits)
298
- p_mtp = modelo.mtp_do_trunk(ids, alvo, h_conf=h_conf)
299
- verifica("MTP adaptativo integrado ao trunk", p_mtp is not None and torch.isfinite(p_mtp))
300
- met = modelo.metricas_estruturais()
301
- verifica("telemetria v3: uso/alpha/passos_rec por compositor",
302
- any(k.startswith("micra") for k in met))
303
-
304
- print("== Causalidade do modelo completo ==")
305
- modelo.eval()
306
- with torch.no_grad():
307
- ids_a = torch.randint(0, 8000, (1, 24))
308
- la, _ = modelo(ids_a[:, :16])
309
- lb, _ = modelo(ids_a)
310
- verifica("modelo causal: prefixo idêntico", float((la[0, :8] - lb[0, :8]).abs().max()) < 1e-4)
311
-
312
- print("== GestorCrescimento integrado (sonda real no modelo) ==")
313
- gcfg = {"tau_expand": 1e9, "tau_prune": 1e9, "eps_gate": 0.99, "janela_uso": 2,
314
- "n_max_ramos": 5, "n_sondas": 1}
315
- gestor = GestorCrescimento(modelo.compositores, gcfg, hub=None)
316
- for b in modelo.blocos:
317
- b.composto.uso_ema = torch.tensor([0.01, 0.01, 0.01, 0.01]) # tudo "pouco usado"
318
- res = gestor.verificar(1, lambda: modelo(ids, alvo=alvo, tarefa="lm")[1])
319
- acoes = [a["acao"] for a in res["acoes"]]
320
- verifica("gestor executa expandir/podar sem erro", all(any(k in a for k in ("expandir", "podar", "manter", "bloqueada")) for a in acoes),
321
- str(acoes))
322
-
323
- print()
324
- if _falhas:
325
- print(f"===== v3: {len(_falhas)} FALHAS: {_falhas} =====")
326
- sys.exit(1)
327
- print("===== v3: todas as verificações OK =====")