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

Delete tests/test_aurora_v5.py

Browse files
Files changed (1) hide show
  1. tests/test_aurora_v5.py +0 -266
tests/test_aurora_v5.py DELETED
@@ -1,266 +0,0 @@
1
- # -*- coding: utf-8 -*-
2
- """Testes AURORA v5 (doc 16–17): atenção entre MoEs, entre variantes SOM,
3
- quantização REAL sem fakes, difusão multimodal, Agente Engenheiro, checkpoints.
4
- Executar: python tests/test_aurora_v5.py
5
- """
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
-
15
- _RESULT = {"ok": 0, "falhas": 0}
16
-
17
-
18
- def verifica(nome: str, cond: bool, detalhe: str = ""):
19
- marca = "✓" if cond else "✗ FALHOU"
20
- print(f" {marca} {nome}" + (f" — {detalhe}" if detalhe else ""))
21
- _RESULT["ok" if cond else "falhas"] += 1
22
- return cond
23
-
24
-
25
- def testa_atencao_entre_moes():
26
- print("== Atenção entre camadas MoE (doc 16 §§1–2) ==")
27
- from aurora.nucleo.modelo import AURORAModel
28
- from aurora.percepcao.atencao_moe import RefinamentoEntreMoEs
29
- cfg = Config()
30
- m = AURORAModel(cfg, usar_multimodal=False)
31
- moes = [b.moe for b in m.blocos if b.moe is not None]
32
- verifica("wiring: camada ℓ recebe refino da ℓ−1",
33
- moes[-1].refino is not None and moes[-1].moe_anterior is moes[-2]
34
- and moes[0].refino is None)
35
- torch.manual_seed(0)
36
- ids = torch.randint(4, cfg.modelo.vocab, (2, 16))
37
- # nascimento neutro: α=β=0 ⇒ saída idêntica a v4 (Teorema 16.1c)
38
- m.eval()
39
- with torch.no_grad():
40
- logits_neutro, _ = m(ids, alvo=ids)
41
- moes[-1].refino.alpha.fill_(0.05)
42
- logits_com_refino, _ = m(ids, alvo=ids)
43
- verifica("Teorema 16.1c: α=0 → v4 exato; α≠0 muda a saída",
44
- float((logits_neutro - logits_com_refino).abs().max()) > 0)
45
- m.train()
46
- _, perda = m(ids, alvo=ids)
47
- perda.backward()
48
- g_alpha = moes[-1].refino.alpha.grad
49
- g_beta = moes[-1].beta_feedback.grad
50
- verifica("gradiente flui para α e β (treino aprende o refino)",
51
- g_alpha is not None and float(g_alpha.abs()) > 0
52
- and g_beta is not None)
53
- # custo (Teorema 16.6): refino 3d²+2Nd ≪ experts 3N·d·d_ff
54
- N, d, d_ff = moes[-1].N, cfg.modelo.d_modelo, cfg.modelo.moe["d_ff_expert"]
55
- custo_refino = 3 * d * d + 2 * N * d
56
- custo_experts = N * 3 * d * d_ff
57
- verifica("Teorema 16.6: custo do refino ≪ custo dos experts",
58
- custo_refino < custo_experts * 0.5,
59
- f"refino={custo_refino} < 50% de experts={custo_experts}")
60
-
61
-
62
- def testa_atencao_entre_variantes_som():
63
- print("== Atenção entre variantes SOM (doc 16 §§3–5) ==")
64
- from aurora.memoria.orquestrador import OrquestradorSOM
65
- from aurora.memoria.atencao_som import AtencaoEntreVariantes, prototipo_e_distancia
66
- cfg = Config()
67
- o = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som,
68
- cfg_atencao=vars(cfg.som_atencao))
69
- torch.manual_seed(3)
70
- x = torch.randn(32, cfg.modelo.d_modelo) * 0.5
71
- o.treinar_memoria(x, epocas=2)
72
- z = o.mapear_atencao(x)
73
- verifica("mapear_atencao devolve (B,d)", z.shape == x.shape)
74
- # Teorema 16.3: ẑ ∈ casco{∪_v W_v} — dentro do raio do maior protótipo
75
- def _codebook(v):
76
- for alvo in (v, getattr(v, "kohonen", None), getattr(v, "n1", None)):
77
- if alvo is not None and hasattr(alvo, "w"):
78
- return alvo.w
79
- return None
80
- livros = [cb for cb in (_codebook(o.variantes[n]) for n in o.variantes)
81
- if cb is not None]
82
- protos = torch.cat(livros, dim=0)
83
- r_max = float((protos - protos.mean(0)).norm(dim=1).max())
84
- dentro = float((z - protos.mean(0)).norm(dim=1).max()) <= r_max * 1.5 + 1e-6
85
- verifica("Teorema 16.3: ẑ no casco dos protótipos (raio),"
86
- " sem extrapolar a memória", dentro)
87
- # Teorema 16.4: τ→0 ⇒ peso uniforme no CONJUNTO de empate do argmin
88
- atn_duro = AtencaoEntreVariantes(tau=1e-6, gamma_novidade=0.0)
89
- z_duro = atn_duro.mapear(x, o)
90
- nomes = list(o.variantes.keys())
91
- ds = torch.stack([prototipo_e_distancia(o.variantes[n], x)[1]
92
- for n in nomes], dim=1) # (B, V)
93
- zs = torch.stack([prototipo_e_distancia(o.variantes[n], x)[0]
94
- for n in nomes], dim=1) # (B, V, d)
95
- z_ref = torch.empty_like(x)
96
- for b in range(x.shape[0]):
97
- empate = (ds[b] <= ds[b].min() + 1e-6).nonzero(as_tuple=True)[0]
98
- z_ref[b] = zs[b, empate].mean(dim=0) # limite da softmax no empate
99
- err = float((z_duro - z_ref).norm(dim=1).mean())
100
- verifica("Teorema 16.4: τ→0 ⇒ protótipo do conjunto de empate (argmin)",
101
- err < 1e-3, f"erro médio={err:.2e}")
102
- # Teorema 16.5: invariante zero órfãos após resemeadura
103
- for v in o.variantes.values():
104
- if hasattr(v, "hit_ema"):
105
- v.hit_ema.zero_() # força estado 'todos mortos'
106
- inv = o.atencao.verificar_sem_orfas(o, dados=x, resemear=True)
107
- verifica("Teorema 16.5: resemeadura restaura ZERO órfãos",
108
- inv["_invariante_ok"] and inv["som"]["relocados"] > 0)
109
- a = o.atencao.ultimo["pesos"]
110
- verifica("eq. 16.3: pesos atencionais somam 1 (softmax)",
111
- abs(float(a.sum()) - 1.0) < 1e-5)
112
-
113
-
114
- def testa_quantizacao_real():
115
- print("== Quantização REAL sem fakes (doc 08 §§7–9) ==")
116
- from aurora.quanta.quantizacao import (QATW8A8, converter_int8_real,
117
- metricas_qualidade, modo_quantizacao,
118
- quantiza_simetrica)
119
- lin = torch.nn.Linear(64, 32)
120
- conv = converter_int8_real(lin)
121
- verifica("§7.1 torchao: conversão INT8 REAL ok",
122
- conv.get("ok") is True,
123
- str(conv.get("motivo", f"fator={conv.get('fator_memoria')}x")))
124
- if conv.get("ok"):
125
- y = lin(torch.randn(4, 64))
126
- verifica("§7.1 forward com kernels int8 reais", y.shape == (4, 32))
127
- mq = metricas_qualidade(torch.randn(16, 64), torch.randn(32, 64))
128
- verifica("§8 métricas honestas (SNR>0, erro<1)", mq["snr_db"] > 0
129
- and 0 <= mq["erro_relativo"] < 1,
130
- f"SNR={mq['snr_db']}dB")
131
- qat = QATW8A8(por_canal=True, tam_grupo=64)
132
- w = torch.randn(32, 64)
133
- wq = qat.quantiza_peso(w)
134
- verifica("QAT-STE (Teorema 8.3): gradiente preservado",
135
- torch.equal(w + (wq - w).detach(), wq) and qat.ultimo_erro <= 1.0)
136
- modos = modo_quantizacao()
137
- verifica("§9 diagnóstico honesto de backends",
138
- isinstance(modos.get("torchao_int8"), bool))
139
- # fakes REMOVIDOS
140
- import aurora.quanta.quantizacao as qz
141
- verifica("fakes removidos (FakeQuantW8A8/aplicar_w8_linear)",
142
- not hasattr(qz, "FakeQuantW8A8") and not hasattr(qz, "aplicar_w8_linear"))
143
-
144
-
145
- def testa_difusao():
146
- print("== Difusão multimodal (doc 17) ==")
147
- try:
148
- from diffusers import (StableDiffusionImg2ImgPipeline,
149
- StableDiffusionInpaintPipeline,
150
- StableDiffusionPipeline)
151
- ok_import = True
152
- except Exception:
153
- ok_import = False
154
- verifica("import EXATO dos 3 pipelines SD", ok_import)
155
- from aurora.geracao import GeradorMultimodal
156
- g = GeradorMultimodal(repo_id="repo/inexistente-teste", altura=128, largura=128)
157
- r = g.texto_para_imagem("um gato ao sol")
158
- verifica("Teorema 17.2: modo planejado HONESTO (sem pixels falsos)",
159
- r["modo"] == "planejado" and "imagem" not in r)
160
- # Teorema 17.1: monotonia da força semântica
161
- e_alto = torch.ones(1, 8)
162
- forca_1 = g.forca_por_similaridade(e_alto, e_alto) # cos=1
163
- forca_0 = g.forca_por_similaridade(e_alto, -e_alto) # cos=-1
164
- verifica("Teorema 17.1: cos=1 → edição leve < cos=0 → recriação",
165
- forca_1 < forca_0, f"{forca_1:.2f} < {forca_0:.2f}")
166
- from aurora.nucleo.modelo import AURORAModel
167
- m = AURORAModel(Config(), usar_multimodal=False)
168
- p_enr = m.nlg.enriquecer_prompt("cidade à noite")
169
- verifica("Teorema 17.3: NLG enriquece prompt determinístico",
170
- p_enr.startswith("cidade à noite") and len(p_enr) > len("cidade à noite"))
171
-
172
-
173
- def testa_agente_engenheiro():
174
- print("== Agente Engenheiro (doc 16 §9) ==")
175
- from aurora.qualidade import AgenteEngenheiro
176
- ag = AgenteEngenheiro(
177
- dir_telemetria="/home/z/my-project/aurora/telemetria_out")
178
- r = ag.auditar_antes("arquivo limpo",
179
- ["src/aurora/percepcao/atencao_moe.py"])
180
- verifica("revisão pré-modificação: arquivo limpo aprovado", r["aprovado"])
181
- # regressão de capacidade (Teorema 16.10)
182
- g = ag.garantir_nao_regressao(
183
- {"ppl_valid": 500.0, "coerencia": 0.5},
184
- {"ppl_valid": 600.0, "coerencia": 0.5}) # ppl +20% = regressão
185
- verifica("Teorema 16.10: regressão de ppl BLOQUEIA", not g["aprovado"])
186
- g2 = ag.garantir_nao_regressao(
187
- {"ppl_valid": 600.0, "coerencia": 0.5},
188
- {"ppl_valid": 500.0, "coerencia": 0.52}) # melhora
189
- verifica("Teorema 16.10: melhora é APROVADA", g2["aprovado"])
190
- # observação integral (modelo multimodal + forward com coleta de gates)
191
- from aurora.nucleo.modelo import AURORAModel
192
- from aurora.memoria.orquestrador import OrquestradorSOM
193
- cfg = Config()
194
- m = AURORAModel(cfg, usar_multimodal=True)
195
- o = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som,
196
- cfg_atencao=vars(cfg.som_atencao))
197
- ids = torch.randint(4, cfg.modelo.vocab, (2, 16))
198
- coletar = {}
199
- m.eval()
200
- with torch.no_grad():
201
- m(ids, alvo=ids, coletar=coletar)
202
- m.alinhar_som(ids, orquestrador=o)
203
- obs = ag.observar_treino(0, m, orquestrador_som=o)
204
- n_metricas = len([k for k in obs if not k.startswith("erro")])
205
- verifica("observação: ≥60 métricas fundamentais coletadas",
206
- n_metricas >= 60, f"n={n_metricas}")
207
- tem_som = any(k.startswith("ativos/") for k in obs)
208
- tem_moe = any("moe" in k for k in obs)
209
- tem_quanta = any(k.startswith("quanta/") for k in obs)
210
- verifica("métricas por módulo: SOM ✓ MoE ✓ quantização ✓",
211
- tem_som and tem_moe and tem_quanta)
212
- rel = ag.relatorio(orquestrador_som=o)
213
- verifica("relatório consolidado gravado", rel["tolerancia_regressao"] == 0.05)
214
-
215
-
216
- def testa_checkpoints():
217
- print("== Checkpoints locais + snapshot único (doc 16 §8) ==")
218
- import os
219
- import shutil
220
- from aurora.dados.checkpoints import GestorCheckpoints
221
- from aurora.nucleo.modelo import AURORAModel
222
- dir_teste = "/home/z/my-project/aurora/estados_local_teste"
223
- if os.path.exists(dir_teste):
224
- shutil.rmtree(dir_teste)
225
- from aurora.config import Config as C
226
- gestor = GestorCheckpoints(dir_local=dir_teste)
227
- m1 = AURORAModel(C(), usar_multimodal=False)
228
- caminho = gestor.salvar(m1, "epoca-001", {"passo_global": 10})
229
- verifica("checkpoint salvo (safetensors+meta+hash)", os.path.exists(caminho))
230
- m2 = AURORAModel(C(), usar_multimodal=False)
231
- ok = gestor.carregar(m2, "epoca-001")
232
- igual = ok and all(torch.equal(a, b) for a, b in zip(
233
- m1.state_dict().values(), m2.state_dict().values()))
234
- verifica("Teorema 16.9: retomada EXATA (hash SHA-256)", igual)
235
- gestor.salvar(m1, "epoca-002", {"passo_global": 20})
236
- verifica("higiene: só o ÚLTIMO checkpoint fica em disco",
237
- gestor.ultima_tag() == "epoca-002"
238
- and len(os.listdir(dir_teste)) == 1)
239
- stage = "/home/z/my-project/aurora/stage_teste"
240
- if os.path.exists(stage):
241
- shutil.rmtree(stage)
242
- p = gestor.preparar_para_publicacao(stage)
243
- verifica("snapshot único p/ commit único (estados/fase-v5)",
244
- p is not None and os.path.exists(os.path.join(
245
- stage, "estados", "fase-v5", "meta.json")))
246
- shutil.rmtree(dir_teste, ignore_errors=True)
247
- shutil.rmtree(stage, ignore_errors=True)
248
-
249
-
250
- def main():
251
- t0 = time.time()
252
- print("=== AURORA v5 — testes (docs 16–17) ===")
253
- testa_atencao_entre_moes()
254
- testa_atencao_entre_variantes_som()
255
- testa_quantizacao_real()
256
- testa_difusao()
257
- testa_agente_engenheiro()
258
- testa_checkpoints()
259
- dt = time.time() - t0
260
- print(f"\nresultado: {_RESULT['ok']} ✓ · {_RESULT['falhas']} ✗ · {dt:.1f}s")
261
- if _RESULT["falhas"]:
262
- sys.exit(1)
263
-
264
-
265
- if __name__ == "__main__":
266
- main()