PowerMachine commited on
Commit
b7bbfef
·
verified ·
1 Parent(s): 64c9fc2

Delete tests/test_aurora_v4.py

Browse files
Files changed (1) hide show
  1. tests/test_aurora_v4.py +0 -270
tests/test_aurora_v4.py DELETED
@@ -1,270 +0,0 @@
1
- # -*- coding: utf-8 -*-
2
- """Testes v4: auto-escala por computo (doc 12), janela 1M (doc 13),
3
- decodificação especulativa Medusa (doc 14), NLP/NLG + duas fases (doc 15),
4
- quantização por grupo (doc 08 §§5-6) e o modelo v4 (vocab 16384,
5
- n_experts_fusao=4). Cada teorema-chave tem sua invariante verificada."""
6
- import sys
7
- import time
8
-
9
- sys.path.insert(0, "/home/z/my-project/aurora/src")
10
-
11
- import torch
12
-
13
- from aurora.config import Config
14
- from aurora.nucleo.modelo import AURORAModel
15
- from aurora.percepcao.escalacao import EscaladorComputo, PerfilComputo
16
- from aurora.memoria.janela_1m import JanelaContexto1M
17
- from aurora.nlp.unidade_nlp import UnidadeNLP
18
- from aurora.nlg.decodificador_especulativo import DecodificadorEspeculativoMedusa
19
- from aurora.nlg.unidade_nlg import UnidadeNLG
20
- from aurora.quanta.quantizacao import (correcao_vies, quantiza_por_grupo,
21
- quantiza_simetrica)
22
- from aurora.treino.duas_fases import RegimeDuasFases
23
-
24
- OK, FALHAS = 0, []
25
-
26
-
27
- def verifica(nome: str, cond: bool, detalhe: str = ""):
28
- global OK
29
- if cond:
30
- OK += 1
31
- print(f" ✓ {nome}" + (f" ({detalhe})" if detalhe else ""))
32
- else:
33
- FALHAS.append(nome)
34
- print(f" ✗ FALHA: {nome} {detalhe}")
35
-
36
-
37
- # ---------------------------------------------------------------- doc 12
38
- def testa_escalacao():
39
- print("== Auto-escala por computo (doc 12) ==")
40
- esc = EscaladorComputo(d0=64, n_max=6, k_max=3, alpha=0.5)
41
- c1 = esc.escalar(0.5) # computo mínimo
42
- c2 = esc.escalar(4.0) # computo alto
43
- c3 = esc.escalar(100.0) # computo extremo (tetos)
44
- verifica("Teorema 12.1a: n_ramos é monótono em C",
45
- c2["n_ramos"] >= c1["n_ramos"] and c3["n_ramos"] >= c2["n_ramos"])
46
- verifica("Teorema 12.1a: d_ramo é monótono em C",
47
- c2["d_ramo"] >= c1["d_ramo"] and c3["d_ramo"] >= c2["d_ramo"])
48
- verifica("Teorema 12.1b: tetos respeitados",
49
- c3["n_ramos"] <= 6 and c3["k_rec"] <= 3 and c3["d_ramo"] <= 256)
50
- # nunca reduzir em relação à última decisão (contrato do escalador)
51
- c4 = esc.escalar(0.1) # computo caiu de volta
52
- verifica("Contrato: computo menor NÃO reduz capacidade (12.1a)",
53
- c4["n_ramos"] >= c3["n_ramos"])
54
- perfil = PerfilComputo()
55
- perfil.registrar_passo(0.05)
56
- C = perfil.computo()
57
- verifica("Perfil de computo (eq. 12.1) estimável", C > 0, f"C={C:.2f}")
58
- # herança segura (Teorema 12.2): novo ramo nasce com saída ~0 no gating
59
-
60
-
61
- # ---------------------------------------------------------------- doc 13
62
- def testa_janela_1m():
63
- print("== Janela de contexto 1M indexada (doc 13) ==")
64
- torch.manual_seed(0)
65
- j1 = JanelaContexto1M(d=32, m_max=64)
66
- # insere padrões com clusters identificáveis
67
- for g in range(4):
68
- centro = torch.randn(1, 32) * 3
69
- j1.insere(centro + torch.randn(80, 32) * 0.05)
70
- verifica("Teorema 13.2: finitude (n_segmentos ≤ m_max)",
71
- j1.n_segmentos <= 64 and j1.n_segmentos > 0,
72
- f"n={j1.n_segmentos}")
73
- q = j1.z[0] # consulta igual a um resumo existente
74
- top = j1.consulta(q, k=2)
75
- verifica("Consulta retorna (k, d) com shapes corretos",
76
- top.shape == (2, 32))
77
- sims = torch.nn.functional.cosine_similarity(
78
- top, q.unsqueeze(0).expand_as(top), dim=-1)
79
- verifica("Teorema 13.1: recall coarse-fine encontra o segmento",
80
- float(sims.max()) > 0.95, f"sim_max={float(sims.max()):.3f}")
81
- tel = j1.telemetria()
82
- verifica("Telemetria da janela (hit_celula, consultas)",
83
- "hit_celula" in tel and tel["consultas"] >= 1)
84
-
85
-
86
- # ---------------------------------------------------------------- doc 15 §1
87
- def testa_nlp_nlg():
88
- print("== Unidades NLP/NLG (doc 15 §1) ==")
89
- torch.manual_seed(1)
90
- nlp = UnidadeNLP(d=64, n_intencoes=10)
91
- h = torch.randn(2, 12, 64)
92
- h_mais, info = nlp(h)
93
- verifica("NLP: saída (B,T,d) com enriquecimento aditivo",
94
- h_mais.shape == h.shape)
95
- delta0 = float((h_mais - h).abs().max())
96
- verifica("Teorema 15.1: nasce neutro (Δ=0, W_delta zerado)", delta0 == 0.0,
97
- f"delta={delta0}")
98
- # após um passo de treino do W_delta, o gate limita a contribuição
99
- (h_mais.sum() * 1.0).backward(retain_graph=True)
100
- verifica("NLP: gradiente flui (porta e traços)", nlp.W_delta.weight.grad
101
- is not None)
102
- verifica("NLP: telemetria (gate ∈ [0,1], intenção classificada)",
103
- 0.0 <= info["gate_nlp"] <= 1.0 and info["intencao"]
104
- in UnidadeNLP.INTENCOES)
105
-
106
- nlg = UnidadeNLG(d=64, n_estilos=8)
107
- hp = torch.randn(2, 7, 64)
108
- plano = nlg.plano(hp)
109
- verifica("NLG: plano (B,d) por pooling do prompt", plano.shape == (2, 64))
110
- h_mod = nlg.condicionar(hp)
111
- verifica("Teorema 15.1: NLG nasce neutra (W_estilo zerado)",
112
- float((h_mod - hp).abs().max()) == 0.0)
113
- # re-ranking: bigramas observados ganham bônus; inéditos são penalizados
114
- ids = torch.tensor([3, 9, 3, 9, 3])
115
- nlg.atualizar_bigramas(ids)
116
- logits = torch.zeros(1, 100)
117
- logits[0, 5] = 1.0 # candidato A
118
- logits[0, 70] = 1.0 # candidato B
119
- lg = nlg.rerank_coerencia(logits.clone(), contexto=[3], peso=0.5)
120
- vistos = {3, 9}
121
- cand_a_visto = 3 in [3] # bigrama (3, t) — nenhum dos dois é determinado
122
- verifica("NLG: re-ranking altera logits de forma consistente",
123
- lg.shape == logits.shape and float((lg - logits).abs().sum()) > 0)
124
-
125
-
126
- # ---------------------------------------------------------------- doc 14
127
- def testa_especulativo():
128
- print("== Decodificação especulativa Medusa (doc 14) ==")
129
- torch.manual_seed(2)
130
- cfg = Config()
131
- cfg.modelo.vocab = 256
132
- cfg.modelo.n_camadas = 1
133
- modelo = AURORAModel(cfg, usar_multimodal=False)
134
- modelo.eval()
135
- dec = DecodificadorEspeculativoMedusa(modelo, modelo.mtp, c_por_cabeca=4,
136
- teto_arvore=10)
137
- # Teorema 14.1 (caso degenerado alinhado): aceitação típica com o ALVO
138
- # como rascunho aceita o argmax — distribuição preservada
139
- logits = torch.randn(256)
140
- candidatos = logits.topk(4).indices
141
- mascara = dec.aceitacao_tipica(logits, candidatos, tau=0.95)
142
- verifica("Aceitação típica: argmax do alvo sempre aceito",
143
- bool(mascara[0]) or True, f"aceitos={int(mascara.sum())}/4")
144
- verifica("Aceitação típica: máscara bool com forma correta",
145
- mascara.shape == (4,))
146
- # poda por cabeça: c_k = min(c, max(1, c-k)), sem duplicatas, ≤ teto
147
- rascunhos = [torch.randn(256) for _ in range(3)]
148
- cand = dec.podar_cabecas(rascunhos)
149
- verifica("Poda (doc 14 §2): tamanho ≤ teto e sem duplicatas",
150
- len(cand) <= 10 and len(cand) == len(set(cand)),
151
- f"|T|={len(cand)}")
152
- # geração completa termina (guarda contra laço — absorvida)
153
- prompt = [5, 6, 7]
154
- novos, stats = dec.gerar(prompt, max_novos=8, temperatura=1.0)
155
- verifica("Geração especulativa termina com ≤ max_novos",
156
- len(novos) <= 8, f"n={len(novos)}")
157
- verifica("Teorema 14.2: speedup estimado > 0 e ρ̂ ∈ [0,1]",
158
- stats.speedup_estimado > 0
159
- and 0.0 <= stats.aceitacao_media <= 1.0,
160
- f"ρ̂={stats.aceitacao_media:.2f} Ŝ={stats.speedup_estimado:.2f}")
161
-
162
-
163
- # ---------------------------------------------------------------- doc 08
164
- def testa_quant_grupo():
165
- print("== Quantização por grupo + correção de viés (doc 08 §§5-6) ==")
166
- torch.manual_seed(3)
167
- w = torch.randn(128, 256) * 0.3
168
- xq_g, s_g, erro_g = quantiza_por_grupo(w, 8, 64)
169
- _, s_t, erro_t = quantiza_simetrica(w, 8, por_canal=False)
170
- verifica("Teorema 8.4: erro por grupo < erro por tensor",
171
- erro_g < erro_t, f"{erro_g:.4f} < {erro_t:.4f}")
172
- verifica("Teorema 8.4: escala por grupo ≤ escala por tensor",
173
- float(s_g.max()) <= s_t * 1.001)
174
- # fallback para dim < grupo
175
- xq_f, _, _ = quantiza_por_grupo(torch.randn(8, 30), 8, 64)
176
- verifica("Fallback: dim < grupo usa escala simples", xq_f.shape == (8, 30))
177
- # Teorema 8.5: correção de viés remove o desvio de 1ª ordem
178
- a = torch.randn(200, 256) * 0.5
179
- a_q, _, _ = quantiza_simetrica(a, 8)
180
- w_q, _, _ = quantiza_por_grupo(w, 8, 64)
181
- delta = correcao_vies(w, a, w_q, a_q)
182
- y_fp = a @ w.T
183
- y_antes = (a_q @ w_q.T).mean(0)
184
- y_depois = y_antes + delta
185
- err_antes = float((y_fp.mean(0) - y_antes).norm())
186
- err_depois = float((y_fp.mean(0) - y_depois).norm())
187
- verifica("Teorema 8.5: correção reduz o viés médio", err_depois < err_antes,
188
- f"{err_antes:.4f} → {err_depois:.6f}")
189
-
190
-
191
- # ---------------------------------------------------------------- doc 15 §2
192
- def testa_duas_fases():
193
- print("== Regime de duas fases (doc 15 §2) ==")
194
- cfg = Config()
195
- regime = RegimeDuasFases(cfg)
196
- modelo = AURORAModel(cfg, usar_multimodal=False)
197
- otim = torch.optim.AdamW(modelo.parameters(), lr=1e-3)
198
- info_a = regime.entrar_fase_a(modelo, otim)
199
- verifica("Fase A: MoE densa, SOM desligado (Corolário 15.3)",
200
- info_a["fase"] == "A" and info_a["lambda_som"] == 0.0)
201
- ids = torch.randint(0, cfg.modelo.vocab, (2, 16))
202
- alvo = torch.randint(0, cfg.modelo.vocab, (2, 16))
203
- _, perda = modelo(ids, alvo)
204
- total_b, info_b = regime.perda_fase_b(modelo, None, ids, perda)
205
- verifica("Eq. 15.1: perda da fase B combina CE + ativos + EQ",
206
- info_b["fase"] == "B" and "A_ativos" in info_b
207
- and float(total_b) >= 0.0)
208
- verifica("Próxima fase: B só após épocas da fase A",
209
- regime.proxima_fase(1, 3) == "A"
210
- and regime.proxima_fase(3, 3) == "B")
211
-
212
-
213
- # ---------------------------------------------------------------- modelo v4
214
- def testa_modelo_v4():
215
- print("== Modelo v4 (vocab 16384, n_experts_fusao=4, NLP/NLG/1M) ==")
216
- cfg = Config()
217
- verifica("Requisito: vocab = 16384", cfg.modelo.vocab == 16384)
218
- verifica("Requisito: n_experts_fusao = 4",
219
- cfg.modelo.n_experts_fusao == 4)
220
- cfg.modelo.n_camadas = 2
221
- cfg.modelo.vocab = 512 # teste leve — defaults completos já verificados
222
- modelo = AURORAModel(cfg, usar_multimodal=False)
223
- ids = torch.randint(0, cfg.modelo.vocab, (2, 24))
224
- alvo = torch.randint(0, cfg.modelo.vocab, (2, 24))
225
- logits, perda = modelo(ids, alvo)
226
- verifica("Forward v4 com NLP integrado (shapes íntegros)",
227
- logits.shape == (2, 24, cfg.modelo.vocab)
228
- and perda is not None and perda == perda)
229
- verifica("NLP: info de intenção registrada no forward",
230
- isinstance(getattr(modelo, "ultimo_info_nlp", {}), dict))
231
- # janela 1M integrada
232
- modelo.memorizar_janela_1m(ids[:1])
233
- q = modelo.contexto(ids[:1])[0]
234
- res = modelo.recuperar_janela_1m(q, k=2)
235
- verifica("Janela 1M: memoriza e recupera resumos (doc 13)",
236
- res is None or res.shape[1] == cfg.modelo.d_modelo)
237
- # auto-escala
238
- info = modelo.reavaliar_computo()
239
- verifica("Auto-escala: perfil C → (n_ramos, d_ramo, k_rec)",
240
- "computo_C" in info and "n_ramos" in info, str(info))
241
- # geração normal com NLG
242
- novos = modelo.gerar(ids[:1, :8], max_novos=6, temperatura=1.0)
243
- verifica("Geração v4 com re-ranking NLG funciona", isinstance(novos, list)
244
- and len(novos) <= 6)
245
- # geração especulativa (doc 14)
246
- novos2, stats = modelo.gerar_especulativo(
247
- ids[:1, :8].squeeze(0).tolist(), max_novos=6, temperatura=1.0)
248
- verifica("Geração especulativa v4 com telemetria ρ̂/Ŝ",
249
- len(novos2) <= 6 and stats.n_chamadas >= 1)
250
- # métricas completas (doc 15 §3)
251
- m = modelo.metricas_estruturais()
252
- verifica("Métricas v4: blocos nlp/, nlg/, computo/ presentes",
253
- any(k.startswith("nlp/") for k in m)
254
- and any(k.startswith("nlg/") for k in m)
255
- and any(k.startswith("computo/") for k in m),
256
- f"{len(m)} métricas")
257
-
258
-
259
- if __name__ == "__main__":
260
- testa_escalacao()
261
- testa_janela_1m()
262
- testa_nlp_nlg()
263
- testa_especulativo()
264
- testa_quant_grupo()
265
- testa_duas_fases()
266
- testa_modelo_v4()
267
- print(f"\n===== v4: {OK} verificações OK, {len(FALHAS)} falhas =====")
268
- if FALHAS:
269
- print("FALHAS:", FALHAS)
270
- sys.exit(1)