PowerMachine commited on
Commit
e829bfc
·
verified ·
1 Parent(s): dbedf98

AURORA v3: microunidades escaláveis (serial/paralela/isolada/recursiva), Transformers+CNN-BiGRU+BiGRU, memória interna conficiente, PRS V8, MTP K adaptativo, crescimento por Hessiano

Browse files
README.md CHANGED
@@ -3,62 +3,86 @@ license: mit
3
  language:
4
  - pt
5
  tags:
 
 
 
 
 
6
  - self-organizing-map
7
  - kohonen
8
- - som
9
  - multimodal
10
- - mixture-of-experts
11
  - multi-token-prediction
12
  - dpo
13
  - pcgrad
14
  - smoothquant
15
  - w8a8
 
 
 
16
  - pt-br
17
- - reasoning
18
- - growing-neural-gas
19
  - pdca
20
  metrics:
21
  - perplexity
22
  ---
23
 
24
- # AURORA v2 — Arquitetura Unificada de Raciocínio, Otimização e Aprendizagem auto-organizada
 
 
 
 
 
 
 
 
 
25
 
26
- IA multimodal (texto, imagem, áudio, vídeo, planilha/documentos/PDF) **auto-aprendente**
27
- para português do Brasil. A v2 refatora integralmente a v1 com quatro inovações de
28
- escopo, todas **provadas antes do código** (`docs/matematica/10-moe-foco-denso-som-v2.md`):
29
 
30
  | Inovação | O que faz | Fundamento |
31
  |---|---|---|
32
- | **(a) MoE agrupável com foco na tarefa** | 6 experts em 3 grupos (texto/visual/áudio); gate duplo `s = ⟨x̄,μ_e⟩/√d + b_{g,τ}`; fase densa (todos os experts, máx conexões) → fase foco (top-k, experts irrelevantes **não são computados** — ignorados por compactação+indexação) | Teoremas 10.1–10.4 |
33
- | **(b) 18 datasets, um por vez** | streaming=True (+trust_remote_code onde aceito); imagens reais (JPEG 96px), áudio real (fp16 16kHz), webdataset por **faixa HTTP Range** (não baixa shards de GB) | adaptadores em `dados/streaming.py` |
34
- | **(c) Estados do modelo NO HuggingFace** | safetensors + hash SHA-256 + meta; commit atômico; retomada ("salvar E usar"); disco local mínimo | protocolo §9 |
35
- | **(d) Pipeline denso→SOM** | rede aprimorada treina TODOS os parâmetros (máx conexões) → consolidação SOM com **máximo de neurônios ativos** (novidade restrita a empates + reseeding; taxa_ativos ≥ 0,90) | Teoremas 10.5–10.7 |
 
 
 
 
 
36
 
37
- Extras v2 (corrigindo defeitos identificados no estudo do código do autor):
38
- **MTP** com α aprendíveis via tabela empatada (K·d² em vez de K·V·d), **DPO** com β
39
- adaptativo (sinal da dualidade corrigido), **PCGrad** CE×auxiliares, **SmoothQuant
40
- com α aprendível** (STE), **barreira analítica de LR** (η ≤ (2−m)/L̂), **punição
41
- dinâmica de repetição** na geração (proporcional à entropia do contexto).
 
42
 
43
  ## Matemática (ler antes do código)
44
 
45
  - `00–09` (v1): Kohonen/GG/GCS/GSOM/H-SOM/TKM/RSOM/CPN/S-SOM, atenção mista+KV-cache, W8A8, ortogonais, punição, PDCA
46
- - **`10-moe-foco-denso-som-v2.md` (v2): 13 teoremas/proposições novos**
 
47
 
48
  ## Estrutura do repositório
49
 
50
  ```
51
- src/aurora/ # código (9 módulos por competência)
52
- percepcao/moe.py # NOVO v2: MoE agrupável com foco na tarefa
53
- treino/{mtp,dpo,cirurgia_grad}.py # NOVOS v2
54
- dados/estados_hf.py # NOVO v2: estados no Hub (safetensors+hash)
55
- dados/streaming.py # v2: 18 fontes, um-por-dataset, multimodal real
56
- scripts/ # 01 verificar · 02 coletar · 03 tokenizador · 04 treinar · 05 avaliar · 06 publicar
57
- configs/base.json # todas as constantes (moe/mtp/dpo/abmo/fase_som/estados_hf)
58
- docs/matematica/ # 00–10: provas ANTES dos scripts
59
- tests/ # test_aurora.py (26) + test_aurora_v2.py (36) = 62 verificações
60
- avaliacao_v2.json # relatório de qualidade do aprendizado (evidências)
61
- estados/ # estados do modelo salvos no Hub (fase-dpo, fase-som)
 
 
 
 
 
 
62
  ```
63
 
64
  ## Pipeline de treino (scripts organizados)
@@ -67,40 +91,77 @@ estados/ # estados do modelo salvos no Hub (fase-dpo, fase-som)
67
  pip install -r requirements.txt
68
  export HF_TOKEN=... # apenas variável de ambiente; NUNCA em arquivo
69
  python3 scripts/01_verificar_ambiente.py
70
- python3 scripts/02_coletar_corpus.py # um dataset por vez; cache limpo a cada fonte
71
  python3 scripts/03_treinar_tokenizador.py
72
- python3 scripts/04_treinar.py --orcamento 1500 # segmentos; retoma do último estado no HF
73
- python3 scripts/05_avaliar.py # evidências de qualidade (ppl, foco MoE, SOM, W8A8)
74
- python3 scripts/06_publicar_hf.py # publica de forma organizada
75
  ```
76
 
77
- ## Evidências de qualidade (ver `avaliacao_v2.json`)
78
 
79
  | Métrica | Treinado | Aleatório |
80
  |---|---|---|
81
- | ppl (LM) | **859** | 8515 |
82
- | perda instrucao | 5.29 | 9.06 |
83
- | perda vqa (imagem real) | 4.96 | 9.08 |
84
- | perda ocr (imagem real) | 5.24 | 9.05 |
85
- | perda asr (áudio real) | 5.73 | 9.05 |
86
- | perda tts | 4.01 | 9.07 |
87
-
88
- - **MoE foco na tarefa** (fase foco, top-2 por bloco): lm→grupos [texto,texto];
89
- vqa→[visual,visual]; ocr→[áudio-índice,visual]; asr→[visual,áudio]; tts→[texto,visual]
90
- — o roteamento muda com a tarefa (índice por âncora + viés b_{g,τ}).
91
- - **MTP**: α=[0.98, 0.02] com regularizador de entropia — a 2ª cabeça mantém
92
- peso > 0 (anti-colapso do Teorema 10.8); perdas 6.70/7.47 por cabeça.
93
- - **W8A8-QAT**: Δperda = +0.00215 (cota do Teorema 8.1/8.2).
94
- - **SOM máximo de neurônios ativos**: taxa_ativos = **1.00** em som/gg/tkm/rsom
95
- (reseeding + novidade restrita a empates, Teorema 10.7); S-SOM com rótulos
96
- degenerados fica em 0 (documentado).
97
- - **DPO**: acc 0.75, margem > 0 com β no piso (dual update corrigido).
98
- - **Geração**: punição dinâmica de repetição reduz loops (amostras no relatório).
99
- - 62 verificações de invariantes (26 v1 + 36 v2) verdes.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
100
 
101
  ## Limitações honestas
102
 
103
- - Modelo em escala CPU (validação de pipeline); pesos e encoders multimodais treinam
104
- com gradiente real, mas a qualidade semântica exige escala GPU.
105
- - O dataset carolina (554 XML.gz sem parquet) permanece com adaptador documentado,
106
- fora do orçamento de RAM/disco desta execução.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3
  language:
4
  - pt
5
  tags:
6
+ - mixture-of-experts
7
+ - micro-units
8
+ - transformer
9
+ - cnn-bigru
10
+ - bigru
11
  - self-organizing-map
12
  - kohonen
 
13
  - multimodal
 
14
  - multi-token-prediction
15
  - dpo
16
  - pcgrad
17
  - smoothquant
18
  - w8a8
19
+ - confidence-estimation
20
+ - internal-memory
21
+ - hutchinson
22
  - pt-br
 
 
23
  - pdca
24
  metrics:
25
  - perplexity
26
  ---
27
 
28
+ # AURORA v3 — Microunidades especializadas escaláveis: Transformers + CNN‑BiGRU + BiGRU com composição provada
29
+
30
+ IA multimodal (texto, imagem, áudio, vídeo) **auto-aprendente** para português do
31
+ Brasil. A v3 **sobrescreve e aprimora** a v2 com a composição pedida:
32
+ **microunidades especializadas escaláveis** (crescem conforme a necessidade —
33
+ evolução do item MoE) organizadas em **quatro topologias — serial, paralela,
34
+ isolada e recursiva** — unindo redes **Transformers + CNN‑BiGRU + BiGRU**, com
35
+ **gestão de memória interna** aprimorada e **divisão de competências verificada
36
+ por contrato** entre módulos. Toda matemática vem ANTES dos scripts:
37
+ `docs/matematica/11-composicao-microunidades-v3.md` (12 teoremas/proposições).
38
 
39
+ ## O que mudou da v2 → v3
 
 
40
 
41
  | Inovação | O que faz | Fundamento |
42
  |---|---|---|
43
+ | **(a+) Microunidades escaláveis** | FFN de cada bloco vira um **compositor**: stem SERIAL `conv causal → GRU causal`; ramos **PARALELOS** {conv dilatada, GRU, SwiGLU, **MoE agrupável**} com gating convexo por token (causal) e temperatura pela confiança h_t; refino **RECURSIVO** com corte por cauda geométrica; encoders de imagem/áudio ganham **BiGRU** (lane **ISOLADA**, Teorema 11.3) | Teoremas 11.1–11.4 |
44
+ | **(a++) Crescimento por Hessiano** | `GestorCrescimento` sonda a **diagonal do Hessiano via Hutchinson–Rademacher** (E[v⊙Hv]=diag(H)) e **expande/poda** microunidades em tempo de treino (curvatura alta → expande; uso baixo + curvatura baixa → poda); agendamento **LPT 4/3‑aprox** | Lema 11.1, Teo 11.5, Prop 11.3 |
45
+ | **(b+) MTP com K adaptativo** | Nº de tokens futuros preditos por posição depende da confiança: `K_t = clamp(round(K_min+(K_max−K_min)·h_t))` — posições certas predizem mais longe; economia medida de termos de CE | Teorema 11.6 |
46
+ | **(c+) Estados no Hub, robustos** | safetensors+hash SHA-256, uploads/downloads com retentativas, par peso→meta consistente, retomada **tolerante a forma** (sobrevive à expansão de microunidades), nunca reinicia por falha transitória | protocolo §9 doc 11 |
47
+ | **(d+) Pipeline denso→SOM mantido** | fase densa (máx conexões, todos os ramos) → foco (top-k) → DPO → SOM com **máximo de neurônios ativos** | Teoremas 10.5–10.7 |
48
+ | **NOVO: PRS V8** | trust com **histerese assimétrica** (recuperação 2,5× mais lenta que a queda), grad-clip por **percentil robusto Q₀.₇₅**, recompensa de sequência logarítmica, dois regimes β_min | Teoremas 11.7.1–7.6 |
49
+ | **NOVO: AgenteConfiança** | posterior **Beta** sobre "está certo" com **cotas de Bernstein** e **PAC‑Bayes**; funde features neurais (entropia, max‑prob, Δperda) com κ assimétrico (punição pesa 3× prêmio); alimenta gating, MTP, memória e o **endosso do PDCA** | Teoremas 11.8 |
50
+ | **NOVO: Memória interna** | slots com **escrita conficiente** (só grava com h_t ≥ limiar), recuperação por similaridade+bônus de utilidade, **evicção** recência×utilidade×confiança, **compressão VQ‑EMA** (códigos discretos, dead-code restart por janela) e índice **SOM** (endereço simbólico por BMU) | Teoremas 11.9 |
51
+ | **NOVO: Contratos de módulos** | matriz de permissões percepção/memória/raciocínio/treino/núcleo verificada em runtime — violação = defeito registrado | §10 doc 11 |
52
 
53
+ Defeitos corrigidos no código estudado (`PowerMachine/gru-ring-v13-9-2`,
54
+ 16 arquivos) — doc 11 §11: Hutchinson da diagonal (o original lia só o 1º
55
+ parâmetro), Stormer–Verlet sem reavaliação do gradiente, dead-code do VQ com
56
+ contagem acumulada (nunca decai), best-of-N com cópias do modelo, buffers
57
+ τ/velocidade misturados, exp map truncado (não ortogonal) → **rotação de
58
+ Cayley exata**, `auto_k_hessian` (grad_outputs incorreto).
59
 
60
  ## Matemática (ler antes do código)
61
 
62
  - `00–09` (v1): Kohonen/GG/GCS/GSOM/H-SOM/TKM/RSOM/CPN/S-SOM, atenção mista+KV-cache, W8A8, ortogonais, punição, PDCA
63
+ - `10-moe-foco-denso-som-v2.md` (v2): 13 teoremas (MoE agrupável, denso→SOM, MTP, DPO, PCGrad, ABMO)
64
+ - **`11-composicao-microunidades-v3.md` (v3): 12 teoremas/proposições novos** — serial (gradiente em [1−ΣγL, 1+ΣγL]), paralela convexa (Lip ≤ 1+max L), isolada (variância σ²(ρ+(1−ρ)/K)), recursiva (ponto fixo com corte), Hutchinson, K adaptativo, PRS V8, Beta/Bernstein/PAC-Bayes, memória (taxa-distorção + hit-rate), contratos
65
 
66
  ## Estrutura do repositório
67
 
68
  ```
69
+ src/aurora/
70
+ percepcao/microunidades.py # NOVO v3: ComposicaoMicroUnidades + GestorCrescimento + Cayley + LPT
71
+ percepcao/blocos.py # BlocoV3 (tronco causal com composição)
72
+ percepcao/moe.py # v3: roteamento POR TOKEN e CAUSAL (v2 vazava futuro)
73
+ memoria/interna.py # NOVO v3: MemoriaInterna (slots conficientes + VQ + SOM + contratos)
74
+ treino/confianca.py # NOVO v3: PosteriorBeta + AgenteConfiança + máscara K
75
+ treino/prs_v8.py # NOVO v3: PRS V8 (histerese, percentil, streak)
76
+ treino/mtp.py # v3: perda com K adaptativo
77
+ dados/estados_hf.py # v3: retentativas + retomada tolerante a forma
78
+ raciocinio/ciclo.py # v3: consulta à memória + endosso PAC-Bayes
79
+ scripts/ # 01..06 organizados (verificar→coletar→tokenizador→treinar→avaliar→publicar)
80
+ configs/base.json # todas as constantes (microunidades/prs_v8/confianca/crescimento/memoria_interna)
81
+ docs/matematica/ # 00–11: provas ANTES dos scripts
82
+ tests/ # 26 (v1) + 36 (v2) + 40 (v3) = 102 verificações
83
+ avaliacao_v3.json # evidências de qualidade do aprendizado
84
+ resumo_treino_v3.json # curva por época + PRS + confiança + crescimento
85
+ estados/ # pesos finais no Hub (fase-dpo, fase-som) + épocas
86
  ```
87
 
88
  ## Pipeline de treino (scripts organizados)
 
91
  pip install -r requirements.txt
92
  export HF_TOKEN=... # apenas variável de ambiente; NUNCA em arquivo
93
  python3 scripts/01_verificar_ambiente.py
94
+ python3 scripts/02_coletar_corpus.py # um dataset por vez; streaming=True
95
  python3 scripts/03_treinar_tokenizador.py
96
+ python3 scripts/04_treinar.py --orcamento 1500 # segmentos; retoma do HF
97
+ python3 scripts/05_avaliar.py # 12 blocos de evidências
98
+ python3 scripts/06_publicar_hf.py # publicação organizada (poda parciais)
99
  ```
100
 
101
+ ## Evidências de qualidade (ver `avaliacao_v3.json`, 1.200 passos × 6 épocas)
102
 
103
  | Métrica | Treinado | Aleatório |
104
  |---|---|---|
105
+ | **ppl (LM)** | **1025.6** | 8608.7 |
106
+ | perda instrucao | 5.71 | 9.05 |
107
+ | perda vqa (imagem real) | **5.21** | 9.05 |
108
+ | perda ocr (imagem real) | 5.31 | 9.07 |
109
+ | perda asr (áudio real) | 6.33 | 9.06 |
110
+ | perda tts | **4.72** | 9.07 |
111
+ | perda imagem_caption | 5.53 | 9.08 |
112
+ | perda lm/notícia/pontuacao | 6.93/6.77/6.72 | ~9.05 |
113
+
114
+ **Todas as 9 tarefas com perda treinado ≪ aleatório.** Curva de treino: perda
115
+ 9.06 → 6.60 (passo 1200), sem regressão entre épocas (correção v3.1 do regime
116
+ de LR — ver "Limitações honestas").
117
+
118
+ - **Microunidades em ação**: crescimento real durante o treino — no passo 1200
119
+ o gestor **expande** `c0+conv`, `c1+rot` (Cayley), `c2+conv` (compositores
120
+ passam a 4/5/5 ramos); gating final equilibrado α≈[0.32, 0.32, 0.36] (sem
121
+ colapso de ramos — perda de balanceamento R·Σf·p, análogo Switch);
122
+ refino recursivo executa 2 passos.
123
+ - **MoE com foco na tarefa** (roteamento POR TOKEN, causal): lm→grupo[2,2];
124
+ vqa→[0,0]; ocr→[0,2]; asr→[2,2] — o roteamento muda com a tarefa.
125
+ - **MTP K adaptativo**: economia real de termos de CE (ex.: 626 vs 3.072
126
+ teóricos fixos num lote típico); α das cabeças com regularizador de entropia.
127
+ - **PRS V8**: trust com histerese (η_up=0.05/η_down=0.02); clip por percentil
128
+ adaptou-se a 1.60 (> base 1.0) durante a fase foco; punições/retreinos
129
+ conforme política de estagnação.
130
+ - **DPO**: acc **1.00**, margem 44.4 com β no piso 0.05 (dual update).
131
+ - **W8A8‑QAT**: Δperda = **+0.00047** (cota Teorema 8.1).
132
+ - **SOM máximo de neurônios ativos**: taxa_ativos = **1.00** (som, rsom), GSOM
133
+ cresceu a k=39; S-SOM com rótulos degenerados = 0 (documentado).
134
+ - **Memória interna em execução** (com o modelo treinado): **44/48 escritas
135
+ conficientes aceitas**, **15/16 consultas com acerto**, **32 slots
136
+ comprimidos** em códigos VQ (entropia do codebook 3.51 nats, economia
137
+ teórica 99,9% de bits/slot), **0 violações de contrato** de acesso.
138
+ - **Confiança com garantias**: posterior Beta + Bernstein (IC 95% relatado por
139
+ época); h_t governa temperatura do gating, máscara K do MTP e limiar de
140
+ escrita da memória (τ no quantil Q25 ⇒ taxa de acerto estrutural ~25% —
141
+ limiar de escrita calibrado para 0.25).
142
+ - **102 verificações de invariantes** (26 v1 + 36 v2 + 40 v3) verdes —
143
+ incluindo causalidade do tronco por comparação de prefixos, ortogonalidade
144
+ exata de Cayley, Hutchinson vs Hessiano analítico, máscara K, cotas de
145
+ Bernstein e contratos de acesso.
146
 
147
  ## Limitações honestas
148
 
149
+ - **Regime de LR**: a primeira execução v3.0 divergiu (perda 7.05→8.95) — o
150
+ cronograma SGDR+boost do PRS V8 reinjetava η_max a cada ciclo e o gate das
151
+ microunidades colapsou num único ramo (sem perda de balanceamento). Correção
152
+ v3.1: cronograma cosine da v2 (PRS mantido para trust/clip/streak),
153
+ balanceamento de carga do gate e piso de temperatura. A execução publicada é
154
+ a v3.1 (curva monotônica de perda).
155
+ - **Qualidade de geração**: o modelo é de escala CPU (11.2M parâmetros, 1.200
156
+ passos) — as amostras geradas ainda não são texto coerente; as evidências de
157
+ aprendizado são as perdas por tarefa (todas ≪ aleatório), roteamento
158
+ condicional e memória funcional. Qualidade semântica exige escala GPU.
159
+ - **Memória durante o treino**: com τ no quantil Q25, h_t médio ficou em
160
+ 0.20–0.35 e o limiar 0.5 rejeitou quase todas as escritas — o limiar foi
161
+ recalibrado para 0.25 (config) e a evidência de memória publicada é a
162
+ execução dedicada com o modelo treinado (§12 do avaliador).
163
+ - **S-SOM**: com rótulos degenerados (uma classe), taxa_ativos = 0 — limitação
164
+ documentada desde a v2 (não é defeito do mapa).
165
+ - **Expansão × retomada**: estados salvos após expansão de microunidades têm
166
+ formas novas; a retomada carrega tensores compatíveis por chave (ramos
167
+ extras nascem na init padrão) — registrado em `dados/estados_hf.py`.
configs/base.json CHANGED
@@ -22,7 +22,21 @@
22
  "mtp": {
23
  "ativo": true,
24
  "k_cabecas": 2,
25
- "beta_entropia": 0.01
 
 
 
 
 
 
 
 
 
 
 
 
 
 
26
  }
27
  },
28
  "treino": {
@@ -76,6 +90,36 @@
76
  "gamma_empate": 0.15,
77
  "lambda_novidade": 0.25,
78
  "dim_lote": 64
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
79
  }
80
  },
81
  "estados_hf": {
@@ -90,5 +134,15 @@
90
  "orcamento_passos": 6,
91
  "cache_ferramentas_ttl": 600,
92
  "cache_ferramentas_max": 64
 
 
 
 
 
 
 
 
 
 
93
  }
94
  }
 
22
  "mtp": {
23
  "ativo": true,
24
  "k_cabecas": 2,
25
+ "beta_entropia": 0.05,
26
+ "k_adaptativo": true
27
+ },
28
+ "microunidades": {
29
+ "d_gru": 96,
30
+ "d_ramo": 96,
31
+ "d_refino": 128,
32
+ "kernel1": 3,
33
+ "kernel2": 5,
34
+ "gamma_rec": 0.5,
35
+ "k_rec_max": 2,
36
+ "eps_stop": 0.01,
37
+ "tau0": 0.8,
38
+ "kappa_conf": 1.0,
39
+ "delta_explora": 0.3
40
  }
41
  },
42
  "treino": {
 
90
  "gamma_empate": 0.15,
91
  "lambda_novidade": 0.25,
92
  "dim_lote": 64
93
+ },
94
+ "prs_v8": {
95
+ "ativo": true,
96
+ "eta_up": 0.05,
97
+ "eta_down": 0.02,
98
+ "T_ciclo": 400,
99
+ "decay_piso": 1.0,
100
+ "percentil": 0.75,
101
+ "janela_clip": 50,
102
+ "coef_streak": 0.3,
103
+ "vel_alvo": 0.01,
104
+ "boost_max": 1.0
105
+ },
106
+ "confianca": {
107
+ "ativo": true,
108
+ "kappa_punicao": 0.3,
109
+ "kappa_premio": 0.1,
110
+ "janela_tau": 50,
111
+ "quantil_tau": 0.25,
112
+ "h_escrita_memoria": 0.25
113
+ },
114
+ "crescimento": {
115
+ "ativo": true,
116
+ "a_cada": 200,
117
+ "tau_expand": 0.1,
118
+ "tau_prune": 0.01,
119
+ "eps_gate": 0.05,
120
+ "janela_uso": 8,
121
+ "n_max_ramos": 5,
122
+ "n_sondas": 2
123
  }
124
  },
125
  "estados_hf": {
 
134
  "orcamento_passos": 6,
135
  "cache_ferramentas_ttl": 600,
136
  "cache_ferramentas_max": 64
137
+ },
138
+ "memoria_interna": {
139
+ "ativo": true,
140
+ "n_slots": 64,
141
+ "h_escrita": 0.25,
142
+ "idade_compressao_s": 900.0,
143
+ "n_codigos": 64,
144
+ "lambda_utilidade": 0.1,
145
+ "meia_vida_s": 1800.0,
146
+ "replay_a_cada": 40
147
  }
148
  }
docs/matematica/11-composicao-microunidades-v3.md ADDED
@@ -0,0 +1,386 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # 11 — Composição de Microunidades v3: Transformers + CNN‑BiGRU + BiGRU, memória interna e controles adaptativos
2
+
3
+ > **Princípio v3 (regra do projeto): matemática ANTES dos scripts.**
4
+ > Este documento define e **prova** cada mecanismo novo antes da implementação em
5
+ > `src/aurora/`. Notação herdada do doc 00; docs 09–10 continuam válidos (ortogonais,
6
+ > MoE denso→SOM, punição/retreino). Estudo-fonte: `xavante_work/flexnet/*` e
7
+ > `xavante_work/xavante/model/*` do repo `PowerMachine/gru-ring-v13-9-2` (16 arquivos),
8
+ > com correções de defeitos identificados (§11).
9
+
10
+ ---
11
+
12
+ ## 0. Definições: microunidade e composição
13
+
14
+ **Definição 0.1 (microunidade).** Uma *microunidade* é um módulo paramétrico
15
+ `u_θ: R^d → R^d` com **competência declarada** `c(u) ∈ {conv, rec, att, rot, mlp}` e
16
+ custo `F(u)` (FLOPs por token). A população `U = {u_1, …, u_n}` é **escalável**: `n`
17
+ cresce/diminui em tempo de treino pelo gestor de crescimento (§5).
18
+
19
+ **Definição 0.2 (topologias).** Dado `x ∈ R^d` e unidades `u_1…u_n`:
20
+
21
+ - **Serial (S):** `y = x + Σ_k γ_k · u_k(x_k)`, com `x_1 = x`, `x_{k+1} = x_k + γ_k u_k(x_k)` — resíduos encadeados com ganhos `γ_k > 0`.
22
+ - **Paralela (P):** `y = x + Σ_k α_k(x) · u_k(x)`, `α(x) = softmax(g(x)/τ)` — ramos executados sobre a MESMA entrada e agregados por gating convexo.
23
+ - **Isolada (I):** `y = x + Σ_k β_k · u_k(x)` com **subconjuntos disjuntos de parâmetros e gradiente bloqueado entre ramos** (`u_i` não vê gradientes de `u_j, j≠i`; sem estado compartilhado) — especialistas independentes agregados por pesos fixos ou por votação.
24
+ - **Recursiva (R):** `y_{k+1} = y_k + γ^k · u(y_k)` com `y_0 = x`, profundidade efetiva cortada quando `‖γ^k u(y_k)‖ ≤ ε_stop`.
25
+
26
+ As quatro topologias podem **aninhar-se** (ex.: stem serial de P, ramos paralelos de S…), formando o *compositor*.
27
+
28
+ ---
29
+
30
+ ## 1. Teorema (estabilidade da composição serial)
31
+
32
+ **Teorema 1.1 (serial não amplifica gradiente).** Seja cada unidade pré‑norma
33
+ `u_k(x) = W_k σ(LN(x))` com Lipschitz `L(u_k) ≤ L_k`. A função serial com resíduo
34
+ `F = Id + Σ γ_k u_k∘…∘u_1` satisfaz, para a derivada em qualquer ponto,
35
+
36
+ ```
37
+ ‖∂F/∂x‖_op ≥ 1 − Σ_{k=1..n} γ_k L_k (cota inferior — sem desaparecer)
38
+ ‖∂F/∂x‖_op ≤ 1 + Σ_{k=1..n} γ_k L_k (cota superior — sem explodir)
39
+ ```
40
+
41
+ *Prova.* Por indução: `F_1 = Id + γ_1 u_1 ⇒ ∂F_1 = I + γ_1 ∂u_1`; pela desigualdade
42
+ triangular inversa `‖I + A‖ ≥ ‖I‖ − ‖A‖ = 1 − ‖A‖` e direta `≤ 1 + ‖A‖`. Passo
43
+ indutivo: `F_{k+1} = F_k + γ_{k+1} u_{k+1}∘F_k ⇒ ∂F_{k+1} = (I + γ_{k+1} ∂u_{k+1}(F_k)) · ∂F_k`;
44
+ o fator esquerdo tem norma em `[1 − γ_{k+1}L_{k+1}, 1 + γ_{k+1}L_{k+1}]` e multiplica a
45
+ cota anterior. ∎
46
+
47
+ **Corolário 1.2 (condição de projeto).** Com `γ_k = 1/√n` e `L_k ≤ L`, o caminho de
48
+ gradiente serial permanece em `[1 − L√n, 1 + L√n]` — para `n ≤ (1/L)²` a serialização
49
+ é bem‑condicionada. Implementação: pré‑norma + ganho `1/√n`.
50
+
51
+ ---
52
+
53
+ ## 2. Teorema (paralela reduz a constante de Lipschitz; cobertura de campos receptivos)
54
+
55
+ **Teorema 2.1 (paralela convexa).** Com gating convexo `α_k(x) ≥ 0, Σα_k = 1` e
56
+ `F(x) = x + Σ α_k(x) u_k(x)`:
57
+
58
+ ```
59
+ Lip(F) ≤ 1 + max_k Lip(u_k) + Lip(α)·max_k sup‖u_k‖
60
+ ```
61
+
62
+ *Prova.* Para `x, x'`: `‖F(x) − F(x')‖ ≤ ‖x − x'‖ + ‖Σ α_k(x)u_k(x) − α_k(x')u_k(x')‖`.
63
+ Decompondo (identidade `Σα_k = 1`):
64
+
65
+ ```
66
+ Σ α_k(x)(u_k(x) − u_k(x')) + Σ (α_k(x) − α_k(x')) u_k(x')
67
+ ≤ max_k L_k · ‖x − x'‖ + ‖α(x) − α(x')‖₁ · max_k sup‖u_k‖.
68
+ ```
69
+
70
+ e `‖α(x) − α(x')‖₁ ≤ Lip(α)‖x − x'‖`. ∎
71
+
72
+ **Contraste com serial:** serial multiplica constantes (`Π(1+γL)`), paralela toma o
73
+ **máximo** — por isso ramos paralelos são o lugar seguro para as famílias de maior
74
+ Lipschitz (atenção global).
75
+
76
+ **Proposição 2.2 (cobertura mínima).** Sejam os campos receptivos
77
+ `R_conv = O(k)` (kernel k, local), `R_bigru = O(T)` (recorrência bidirecional cobre
78
+ toda a sequência com custo O(T)), `R_att = O(T)` (global com custo O(T²) — mitigado
79
+ O(T) no híbrido doc 07). A união dos três tipos cobre tarefas de (i) n‑gramas locais,
80
+ (ii) ordem/reversibilidade sequencial, (iii) dependências longas — **e nenhuma família
81
+ cobre as outras**: conv não vê dependência de comprimento > k; GRU unidirecional não
82
+ vé contexto futuro; atenção pura não codifica ordem sem senoidal/RoPE. Logo a
83
+ composição mínima que cobre os três regimes contém **um ramo de cada família** (base
84
+ `n = 3`), com gating aprendendo a seleção por token.
85
+
86
+ ---
87
+
88
+ ## 3. Teorema (isolada: redução de variância e proibição de interferência)
89
+
90
+ **Teorema 3.1 (variância de ensemble isolado).** Sejam ramos `u_k` com gradientes
91
+ por amostra `g_k` com `E[g_k] = g`, `Cov(g_k, g_j) = ρσ² (k≠j), ρ ≥ 0` (compartilham
92
+ dados ⇒ correlação ρ; parâmetros disjuntos ⇒ covariâncias *de ruído de amostra*
93
+ independentes dado o dado). O estimador agregado `ĝ = (1/K)Σ g_k` tem
94
+
95
+ ```
96
+ Var[ĝ] = σ²(ρ + (1−ρ)/K) → σ²ρ quando K→∞.
97
+ ```
98
+
99
+ *Prova.* Cálculo direto da média de covariâncias: K termos de variância σ² e K(K−1)
100
+ de covariância ρσ², dividido por K². ∎
101
+
102
+ **Proposição 3.2 (critério de isolamento).** Se `cos(g_i, g_j) < 0` (interferência
103
+ negativa — PCGrad do doc 10 detecta), mover os ramos para topologia **isolada**
104
+ (remove a soma dos gradientes conflitantes) elimina a componente destrutiva: o
105
+ gradiente do agregado isolado por votação fixa é média de gradientes não combinados,
106
+ e o passo efetivo `Δθ = −η·Σ β_k g_k` com `β_k ≥ 0` fixos satisfaz
107
+ `⟨Δθ, g_alvo⟩ ≤ 0` sempre que `⟨g_k, g_alvo⟩ ≤ 0` para todo k (cada ramo só pode
108
+ ajudar a si mesmo; ninguém puxa contra). Na topologia compartilhada isso falha
109
+ porque um único parâmetro comum recebe `Σ g_k` e pode retroceder em `g_alvo`.
110
+
111
+ **Corolário 3.3 (divisão de competências).** Ramos **isolados** são o lugar das
112
+ competências que não devem compartilhar parâmetros: encoders por modalidade
113
+ (imagem/áudio) e cabeças auxiliares — a interface do módulo permanece a mesma
114
+ (contratos §10), mas o gradiente é tubo‑a‑tubo.
115
+
116
+ ---
117
+
118
+ ## 4. Teorema (recursiva: ponto fixo com profundidade finita)
119
+
120
+ **Teorema 4.1 (convergência geométrica).** Seja `u` Lipschitz com constante `L_u` e
121
+ ganho decrescente `γ ∈ (0, 1/L_u)`. A iteração `y_{k+1} = y_k + γ^k u(y_k)` satisfaz
122
+
123
+ ```
124
+ ‖y_{k+1} − y*‖ ≤ ‖y_k − y*‖ + γ^k ‖u(y_k)‖, e com ‖u‖ ≤ B:
125
+ ‖y_n − x‖ ≤ B(1 − γ^n)/(1 − γ) ≤ B/(1−γ) (comprimento total limitado)
126
+ ```
127
+
128
+ A série de correções é absolutamente convergente ⇒ profundidade efetiva pode ser
129
+ **cortada** em `ε_stop` com erro total `≤ ε_stop/(1−γ)` (Banach/Weierstrass M‑test).
130
+
131
+ *Prova.* Soma das normas das correções por comparação com série geométrica; o resto
132
+ da série após corte `Σ_{k≥n} B γ^k = Bγ^n/(1−γ) ≤ ε_stop/(1−γ)`. ∎
133
+
134
+ **Proposição 4.2 (por que recursiva nas microunidades).** A recursiva compartilha
135
+ **os mesmos pesos** `u` em profundidades variáveis — parâmetros O(1) para
136
+ refinamento O(k). É a topologia com melhor razão capacidade/parâmetro; usamos
137
+ `k ≤ 2`, `γ = 0.5`, `ε_stop = 10⁻²`.
138
+
139
+ ---
140
+
141
+ ## 5. Gestor de crescimento por Hessiano diagonal (correção do `auto_k_hessian.py`)
142
+
143
+ **Lema 5.1 (Hutchinson–Rademacher para a diagonal).** Para `H` simétrica e
144
+ `v ~ Rademacher` (entradas ±1, E[v]=0, E[vv^T]=I):
145
+
146
+ ```
147
+ E[v ⊙ (Hv)] = diag(H)
148
+ ```
149
+
150
+ *Prova.* `E[v_i Σ_j H_ij v_j] = Σ_j H_ij E[v_i v_j] = H_ii`. ∎
151
+
152
+ **Defeito corrigido do código estudado:** `auto_k_hessian.py` computa
153
+ `grad(g, params, grad_outputs=v)` uma vez e lê `hv[0]` (apenas o primeiro
154
+ parâmetro) — (a) não propaga o produto `Hv` para todos os parâmetros, (b) soma
155
+ `(v*hv[0])` que não é a diagonal. Implementação v3: para cada parâmetro `θ_i`,
156
+ `Hv = autograd.grad(g, θ_i, grad_outputs=v_i)` por elemento com `retain_graph`,
157
+ e acumula `v_i ⊙ (Hv)_i` — média sobre `m` sondas reduz a variância por 1/m.
158
+
159
+ **Teorema 5.2 (crescimento/poda).** Seja `s = max_i diag(H)` a maior sensibilidade
160
+ de segunda ordem e `a_k = ᾱ_k` a utilização média do gating da unidade k.
161
+ - **Expandir** se `s > τ_exp` e `n < n_max`: curvatura alta ⇒ o modelo demanda
162
+ capacidade adicional na direção dominante (definição de direção de maior
163
+ sensibilidade; acrescentar unidade distribui a curvatura — na família residual
164
+ de §1 a nova unidade entra com ganho `1/√(n+1)` preservando o corolário 1.2).
165
+ - **Podar** se `a_k < ε_gate` (unidade ignorada pelo gating) por janela W **e**
166
+ a contribuição de curvatura `Σ_{i∈u_k} diag(H)_i < τ_prune`: remover não altera
167
+ a função no limite `a_k → 0` (continuidade do gating: `F(a_k→0) = F sem u_k`).
168
+
169
+ **Proposição 5.3 (agendamento LPT das microunidades paralelas).** Executar ramos
170
+ paralelos em ordem LPT (maior custo primeiro, no recurso menos carregado) dá
171
+ makespan ≤ (4/3)·ÓTIMO (Graham 1969). Usamos LPT para ordenar as unidades nos 2
172
+ núcleos (telemetria de custo por unidade), refino local ≤ 10 iterações.
173
+
174
+ ---
175
+
176
+ ## 6. MTP com K adaptativo por confiança
177
+
178
+ **Definição 6.1.** Confiança `h_t ∈ [0,1]` do AgenteConfiança (§8) na posição t;
179
+ `K_t = clamp(round(K_min + (K_max−K_min)·h_t), K_min, K_max)`; máscara
180
+ `M[t,k] = 1[k < K_t]`; perda
181
+
182
+ ```
183
+ L_MTP = Σ_t Σ_k M[t,k]·CE(y_{t+k}, p_k(·|h_≤t)) / Σ M
184
+ ```
185
+
186
+ **Teorema 6.2 (K adaptativo ≤ K fixo em perda esperada, com confiança calibrada).**
187
+ Se `h_t` é calibrada (`P(acerto no passo k | h_t ≥ c)` monotônica em c) e o custo
188
+ de ruído por passo extra é `r(k) ≥ 0` crescente quando a confiança é baixa, então
189
+ existe escolha de `K_t` por posição com `E[L] ≤ E[L_{K fixo}]`, com estrito
190
+ `<` quando `h_t` tem variância positiva sobre as posições.
191
+
192
+ *Prova.* A perda total é soma por posição `L = Σ_t ℓ_t(K_t)`. Com K fixo, todas as
193
+ posições pagam o mesmo `ℓ(K)`. Para cada posição, escolher `K_t* = argmin_k ℓ_t(k)`
194
+ — que, por calibração, é não‑decrescente em `h_t` — produz
195
+ `Σ_t ℓ_t(K_t*) ≤ Σ_t ℓ_t(K)`, ∀K. O mapeamento `K_t` (def. 6.1) aproxima `K_t*`:
196
+ quanto mais calibrada `h_t`, menor o gap (desigualdade do quantil). Variância
197
+ positiva em `h_t` ⇒ alguma posição tem `K_t* < K ⇒ estrito`. ∎
198
+
199
+ **Economia:** a v2 pagava K passos para todas as posições; a v3 paga
200
+ `Σ_t K_t ≈ K_max·E[h] + K_min·(1−E[h])`. Com `E[h] ≈ 0.4`: ~40% menos termos de CE
201
+ auxiliar nos passos com `K_max=4`.
202
+
203
+ ---
204
+
205
+ ## 7. Sistema de punição‑recompensa V8 (PRS) — cinco mecanismos provados
206
+
207
+ Notação da v2 (doc 09 §9.4): punição = retreino parcial; aqui gerimos **confiança T,
208
+ taxa de aprendizado η, clip de gradiente c e pisos β_min/δ_min**.
209
+
210
+ **Teorema 7.1 (histerese assimétrica).** `T(t) = (1−η_up)T + η_up` se acerto,
211
+ `T(t) = (1−η_down)T` se erro. Para acertos Bernoulli(p): `E[T(∞)] = p·η_up/(η_up + (1−p)η_down·0 + …)` —
212
+ mais diretamente, o ponto fixo da cadeia de renovação dá
213
+
214
+ ```
215
+ E[T(∞)] = p / (p + (1−p)·η_down/η_up · 1) · [correção] = (p η_up) / (p η_up + (1−p) η_down)
216
+ ```
217
+
218
+ Com `η_up = 0.05, η_down = 0.02`: p=0.5 ⇒ E[T] = 0.714 (vs 0.5 do EMA simétrico).
219
+ Recuperação de confiança é **2,5× mais lenta que a perda** ⇒ misses transitórios
220
+ em platô não desabam o trust (efeito histerese: caminho de subida ≠ descida).
221
+
222
+ **Teorema 7.2 (SGDR com piso decrescente).** `η(t) = η_min^{(i)} + ½(η_max − η_min^{(i)})(1 + cos(π s/T_c))`, `s = (t−t_w) mod T_c`, `η_min^{(i)} = η_min·d^i` (i = nº de ciclos, `d = 0.5`).
223
+ Restart quente reinjeta ruído de exploração (escape de selos: Jin et al. 2017) e o
224
+ piso decrescente garante que a energia injetada **não cresce** entre ciclos:
225
+ `η_max_ciclo_i` é o mesmo, o piso cai ⇒ a média do ciclo i é menor que a do i−1 ⇒
226
+ convergência global preservada (soma dos passos finita; Robbins–Monro do doc 01 Teo 1.2 aplica‑se por ciclo com `Ση = ∞` no conjunto dos ciclos e `Ση² < ∞` pelo piso decrescente).
227
+
228
+ **Teorema 7.3 (clip por percentil robusto).** `c(t) = max(c_min, Q_{0.75}(‖∇L‖_janela))`.
229
+ Ponto de ruptura do quantil q é `1−q = 0.25` (tolera 25% de outliers de gradiente)
230
+ contra 0% da média ± kσ (um único gradiente explosivo infla σ e **relaxa** o clip
231
+ subsequente — defeito do EMA+σ). Cap de segurança: `c(t) ≤ 5·c_base`.
232
+
233
+ **Teorema 7.4 (dois regimes para β_min).** Se `T > 0.5`: `β_min = β_min⁰·T`
234
+ (exploração — punição mínima cai com a confiança); se `T ≤ 0.5`:
235
+ `β_min = β_min⁰·f` com `f = 2` (força correção). A discontinuidade em `T = 0.5` é
236
+ deliberada (regime de banda morta anti‑oscilação: dentro da banda o sinal não muda).
237
+
238
+ **Teorema 7.5 (recompensa de sequência logarítmica).** `R = R⁰(1 + c·log(1+k))`,
239
+ k = acertos consecutivos. `Var[log(1+K)] < ∞` para K geométrica(p) (crescimento
240
+ sub‑linear ⇒ momentos finitos), sem saturação artificial (cap) — incentivo por
241
+ consistência com variância limitada.
242
+
243
+ **Teorema 7.6 (boost por velocidade suave).** `m(t) = 1 + ½(m_max−1)·σ(α(v̄ − v*))`.
244
+ σ diferenciável ⇒ sem oscilação de chattering no limiar (contra a regra
245
+ all‑or‑nothing), e para perda Lipschitz a modulação suave do passo preserva a taxa
246
+ O(1/t) (Robbins–Monro com passo `η·m(t)`, `m(t) ∈ [1, m_max]` limitado).
247
+
248
+ ---
249
+
250
+ ## 8. AgenteConfiança: posterior Beta com garantias finitas → h_t
251
+
252
+ **Definição 8.1 (posterior).** θ = probabilidade latente de "o modelo está certo".
253
+ Prior Beta(α₀, β₀); a cada batch, acerto (perda < τ adaptativo — quantil EMA da
254
+ janela) soma α += 1, erro soma β += 1. Média `μ̂ = α/(α+β)`, variância
255
+ `σ² = αβ/((α+β)²(α+β+1))`.
256
+
257
+ **Teorema 8.2 (Bernstein finito).** Com probabilidade ≥ 1−δ:
258
+
259
+ ```
260
+ |μ̂_n − θ*| ≤ √(2σ²_n ln(2/δ)) + (2/3)·ln(2/δ)/(α+β)
261
+ ```
262
+
263
+ **Teorema 8.3 (PAC‑Bayes para o risco do gate).** `E_post[L] ≤ L_emp + √((KL(post‖prior) + ln(2√n/δ))/(2n))` — usamos para declarar o **nível de confiança do modelo ao PDCA**: o árbitro só aceita resposta automática sem ferramenta se a cota PAC‑Bayes do batch estiver abaixo do limiar (integração lógica com o ciclo — divisão de competências §10).
264
+
265
+ **Mapeamento para h_t:** `h_t = clip(0.5·μ̂ + 0.5·h_neural, 0, 1)` onde
266
+ `h_neural = σ(MLP[H(entropy logits), max_prob, Δperda])` (features do
267
+ `ConfidenceAgent` estudado, com κ assimétrico: punição pondera mais que prêmio —
268
+ `κ_p = 3·κ_r`). Calibração monotônica exigida pelo Teo 6.2 é verificada por
269
+ telemetria (ECE por faixas de h_t).
270
+
271
+ ---
272
+
273
+ ## 9. Memória interna multimodal (gestão aprimorada)
274
+
275
+ **Arquitetura (competências separadas, contratos §10):**
276
+
277
+ 1. **Memória de trabalho (slots).** `M = {(z_i, u_i, h_i, t_i)}_{i=1..S}`:
278
+ vetor `z_i`, utilidade `u_i` (EMA de acessos), confiança `h_i` no momento da
279
+ escrita, timestamp `t_i`.
280
+ - **Escrita conficiente:** grava só se `h_t ≥ h_write` (evita poluir a memória
281
+ com estados de baixa confiança — escrito por percepção, dono do conteúdo).
282
+ - **Recuperação:** top‑m por produto interno normalizado (consulta por
283
+ similaridade), com bônus de utilidade: `score = cos(q, z_i) + λ_u·u_i`.
284
+ - **Evicção:** remove argmin de `U_i = u_i · exp(−(t_now−t_i)/T) · h_i`
285
+ (recência × utilidade × confiança).
286
+ 2. **Compressão VQ (códigos discretos).** Entradas antigas (idade > T_comp) são
287
+ comprimidas por quantizador vetorial EMA (VectorQuantizerEMA com dead‑code
288
+ restart + perda de diversidade — revisado do `vqvae2_hierarchical.py`):
289
+ `z → e_idx ∈ {1..N}` (log₂N bits) e o slot guarda (índice, resumo).
290
+ **Teorema 9.1 (taxa‑distorção do slot).** Com N códigos e distorção
291
+ `D = E‖z − e_{idx(z)}‖²`, o slot comprimido economiza
292
+ `1 − log₂N/(b·d)` da memória (b bits/float, d = dim) com erro quadrático ≤ D;
293
+ o restart de códigos mortos mantém a entropia de uso
294
+ `H ≥ log N − ε` (todo código com contagem < limiar é reinicializado num
295
+ vetor observado ⇒ cada código tem massa positiva; soma das massas = 1 ⇒
296
+ H ≥ (1−ε)·log N por concavidade do log na distribuição com no máximo ε de
297
+ massa fora dos códigos vivos).
298
+ 3. **Memória associativa SOM (longo prazo).** O orquestrador de SOMs (docs 01–06,
299
+ 10) indexa as escritas: o BMU de cada `z` vira endereço simbólico
300
+ `(mapa, linha, coluna)` — a memória interna usa esse endereço como chave de
301
+ agrupamento (recall por categoria, não só por similaridade bruta).
302
+ 4. **Rotação de aprendizado ↔ consulta.** Durante o treino, a memória de trabalho
303
+ fornece `top‑m` como contexto auxiliar da perda (replay leve); na inferência,
304
+ raciocínio (PDCA) consulta e recebe também a **confiança PAC‑Bayes** do §8.
305
+
306
+ **Teorema 9.2 (hit‑rate estável).** Sob entrada estacionária (distribuição das
307
+ consultas fixa) e taxa de escrita `λ`, o sistema com evicção por utilidade tem
308
+ hit‑rate assintótico `HR* = Σ_{i∈top‑m} π_i` (massa das m consultas mais úteis)
309
+ e o erro de reconstrução da memória decai geometricamente com a razão de
310
+ compressão (Teo 9.1), pois os slots comprimidos só armazenam códigos com
311
+ distorção D e a consulta por similaridade em códigos tem erro aditivo O(D).
312
+
313
+ ---
314
+
315
+ ## 10. Contratos — integração e acesso lógico (divisão de competências)
316
+
317
+ **Regra do engenheiro‑agente v3:** cada módulo tem permissões explícitas; violação
318
+ = defeito (capturado pelo BugWatch como verificação de contrato):
319
+
320
+ | módulo | lê | escreve | proibido |
321
+ |---|---|---|---|
322
+ | `percepcao` | dados brutos, memória (consulta) | memória de trabalho (com `h_t`), telemetria | treinar pesos do núcleo |
323
+ | `memoria` | tudo que percepção escreveu | slots, códigos VQ, índices SOM | chamar raciocínio/treino |
324
+ | `raciocinio` | memória, confiança (§8) | plano PDCA, ferramentas | escrever na memória de trabalho |
325
+ | `treino` | corpus, estados HF, telemetria | pesos, otimizador, estados, punição | inferência em produção |
326
+ | `nucleo` | compõe percepção+memória | logits, caches KV | acessar disco/datasets |
327
+
328
+ Implementação: `telemetria.registro_acessos` registra `(módulo_origem, alvo, operação)`
329
+ e o teste verifica a matriz de permissões (§ testes v3). O `nucleo/modelo.py` passa a
330
+ receber `memoria` como dependência injetada (nunca constrói a sua) — inversão de
331
+ dependência explícita.
332
+
333
+ ---
334
+
335
+ ## 11. Defeitos encontrados no código estudado (corrigidos aqui)
336
+
337
+ 1. **`auto_k_hessian.py`**: `grad(g, params, grad_outputs=v)` não computa H·v por
338
+ parâmetro; `(v*hv[0])` lê só o primeiro. Correção: Lema 5.1 por parâmetro.
339
+ 2. **`cyclic_hamiltonian_optimizer.py`**: Stormer–Verlet sem reavaliação do
340
+ gradiente no ponto intermediário (usa o mesmo `grad` duas vezes) e
341
+ `p.data.add_(h/mass*p_half)` mistura momento na posição. Correção: leapfrog
342
+ com reavaliação — aqui NÃO implementamos otimizador Hamiltoniano completo
343
+ (custo de 2 forwards/passo); adotamos apenas a **modulação de ressonância**
344
+ `η(t) = η(1 + a·cos(ω t))` dentro do PRS V8 (Teo 7.2), que é a parte estável e
345
+ provada.
346
+ 3. **`vqvae2_hierarchical.py`**: `usage_count.index_add_(0, indices, torch.ones_like(indices))`
347
+ correto, mas dead‑restart usa `usage_count` **acumulada desde o início** (nunca
348
+ decai) — códigos mortos recentes nunca são reiniciados. Correção: janela EMA
349
+ de contagem para o critério de morte.
350
+ 4. **`hypothesis_head.py` (best‑of‑N)**: correto, porém os N trials re‑aplicam e
351
+ restauram parâmetros N vezes (2N cópias de tensores alvo). v3: aplica Δθ numa
352
+ **cópia funcional de um único alvo LoRA** (A,B) — sem tocar o modelo — e usa
353
+ forward linear `W + AB^T` (custo igual, zero cópias do modelo).
354
+ 5. **`adaptive_prs.py`**: `velocity` usa `loss_history[-W]` — com janela que também
355
+ alimenta τ (correlaciona sinal e alvo); v3 separa buffers (τ com janela 50,
356
+ velocidade com janela 20 independente).
357
+ 6. **`learnable_mapping.py`**: `hyp_penalty_history` lê `list(deque)[-10:]` a cada
358
+ forward (O(K·100)) — v3 mantém média EMA O(1).
359
+ 7. **`fnh_layer.py/rotation_module.py`**: exp map truncado em 3 termos com clamp
360
+ 0.5 **não é** exatamente ortogonal (‖R^TR−I‖ ≈ O(θ⁴)); v3 usa Rotação de
361
+ Cayley `R = (I−A)(I+A)^{-1}` que é **exatamente** ortogonal para A anti‑simétrica
362
+ (custo: uma inversão d×d — só em unidades de rotação pequenas, d ≤ 64).
363
+
364
+ ---
365
+
366
+ ## 12. Resumo da composição final v3 (o que será implementado)
367
+
368
+ ```
369
+ BlocoComposto(v3):
370
+ stem = SERIAL [conv_local(k=3) → bigru_bidirecional] (Teo 1, cobertura local+ordem)
371
+ ramos = PARALELO { atencao_hibrida(RoPE+KV) , bigru_bidirecional_2 , conv_dilatada(k=5) }
372
+ com gating convexo + temperatura por confiança (Teo 2, Prop 2.2)
373
+ refino = RECURSIVA(MLP_SwiGLU, γ=0.5, k≤2) (Teo 4)
374
+ especialistas ISOLADOS por modalidade (imagem/áudio) — túnel de gradiente próprio (Teo 3)
375
+ crescimento: Hutchinson diag-H → expandir/podar microunidades (Teo 5, Lema 5.1)
376
+ execução paralela: LPT (4/3‑aprox) nos 2 núcleos (Prop 5.3)
377
+ MTP: K_t = f(confiança h_t) (Teo 6)
378
+ PRS V8: histerese, SGDR+piso↓, clip‑percentil, 2 regimes, streak log, boost σ (Teo 7)
379
+ confiança: Beta + Bernstein/PAC‑Bayes → h_t (Teo 8)
380
+ memória: slots conficientes + evicção U + compressão VQ + SOM (Teo 9)
381
+ contratos: matriz de permissões verificada por teste (§10)
382
+ ```
383
+
384
+ Cada item acima tem provedor matemático e arquivo de implementação correspondente;
385
+ os testes v3 verificam as **propriedades** (não só formas): ortogonalidade exata,
386
+ limites de Lipschitz empíricos, calibração monotônica, hit‑rate, contratos.
scripts/04_treinar.py CHANGED
@@ -1,13 +1,17 @@
1
  #!/usr/bin/env python3
2
  # -*- coding: utf-8 -*-
3
- """Treino v2 — pipeline completo do escopo:
4
-
5
- FASE Densa (épocas 0..2): máx conexões, MoE softmax-total, MTP, PCGrad,
6
- ABMO, punição/retreino; estados por época NO HUGGINGFACE
7
- (item c: salvar E USAR; disco local mínimo).
 
 
 
8
  FASE Foco (época 3): MoE top-k + máscara de tarefa + QAT-W8A8 final.
9
  FASE DPO : pares (dourado, corrompido) com β adaptativo (doc 10 §4).
10
- FASE SOM : consolidação com MÁXIMO de neurônios ativos (doc 10 §2.3).
 
11
 
12
  Uso (CPU em segmentos):
13
  python3 04_treinar.py --orcamento 1500 # segmento de 25 min
@@ -34,7 +38,7 @@ from aurora.treino.treinador import TreinadorExtensao
34
 
35
  CORPUS = "/home/z/my-project/aurora/cache_dados/corpus_v2.jsonl"
36
  TOKENIZADOR = "/home/z/my-project/aurora/cache_dados/tokenizador.json"
37
- RESUMO = "/home/z/my-project/aurora/telemetria_out/resumo_treino_v2.json"
38
 
39
 
40
  def carregar_registros(caminho: str) -> list[dict]:
@@ -132,11 +136,28 @@ def main():
132
 
133
  os.makedirs(os.path.dirname(RESUMO), exist_ok=True)
134
  with open(RESUMO, "w", encoding="utf-8") as f:
135
- json.dump({"epocas": treinar.historico_epocas,
 
136
  "passos": treinar.passo_global,
137
  "punicoes": len(treinar.eventos_punicao),
138
  "barreira_abmo_ativacoes": treinar.barreira_ativa_count,
139
  "pcgrad_ultimo": treinar.ultimos_pcgrad,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
140
  "dpo": resultado_dpo, "som": resultado_som,
141
  "avaliacao_final": aval_final,
142
  "estados_eventos": estados.eventos[-12:]},
 
1
  #!/usr/bin/env python3
2
  # -*- coding: utf-8 -*-
3
+ """Treino v3 — pipeline completo (itens a–d + composição de microunidades):
4
+
5
+ FASE Densa (épocas 0..2): máx conexões, MoE softmax-total (por token,
6
+ causal), MTP com K ADAPTATIVO por confiança, PCGrad, ABMO,
7
+ PRS V8 (histerese/SGDR/clip-percentil), AgenteConfiança,
8
+ MEMÓRIA INTERNA (escrita conficiente), GESTOR DE CRESCIMENTO
9
+ (Hutchinson diag-H expande/poda microunidades);
10
+ estados por época NO HUGGINGFACE (item c).
11
  FASE Foco (época 3): MoE top-k + máscara de tarefa + QAT-W8A8 final.
12
  FASE DPO : pares (dourado, corrompido) com β adaptativo (doc 10 §4).
13
+ FASE SOM : consolidação com MÁXIMO de neurônios ativos (doc 10 §2.3)
14
+ + indexação dos slots da memória interna pelos BMUs.
15
 
16
  Uso (CPU em segmentos):
17
  python3 04_treinar.py --orcamento 1500 # segmento de 25 min
 
38
 
39
  CORPUS = "/home/z/my-project/aurora/cache_dados/corpus_v2.jsonl"
40
  TOKENIZADOR = "/home/z/my-project/aurora/cache_dados/tokenizador.json"
41
+ RESUMO = "/home/z/my-project/aurora/telemetria_out/resumo_treino_v3.json"
42
 
43
 
44
  def carregar_registros(caminho: str) -> list[dict]:
 
136
 
137
  os.makedirs(os.path.dirname(RESUMO), exist_ok=True)
138
  with open(RESUMO, "w", encoding="utf-8") as f:
139
+ json.dump({"versao": "v3-microunidades",
140
+ "epocas": treinar.historico_epocas,
141
  "passos": treinar.passo_global,
142
  "punicoes": len(treinar.eventos_punicao),
143
  "barreira_abmo_ativacoes": treinar.barreira_ativa_count,
144
  "pcgrad_ultimo": treinar.ultimos_pcgrad,
145
+ "prs_v8": treinar.prs.estado(),
146
+ "confianca": {"h_ema": treinar.agente.ultimo_h,
147
+ "ece": treinar.agente.ece(),
148
+ "posterior_media": treinar.agente.posterior.media,
149
+ "bernstein": treinar.agente.posterior.bernstein()},
150
+ "memoria": (treinar.memoria.estatisticas()
151
+ if treinar.memoria is not None else None),
152
+ "crescimento": (treinar.gestor.eventos
153
+ if treinar.gestor is not None else []),
154
+ "microunidades": [
155
+ {"ramos": c.nome_ramos,
156
+ "ativos": [float(a) for a in c.ramo_ativo.tolist()],
157
+ "uso_ema": (c.uso_ema.tolist()
158
+ if c.uso_ema is not None else None),
159
+ "passos_rec": c.ultimo_passos_rec}
160
+ for c in modelo.compositores],
161
  "dpo": resultado_dpo, "som": resultado_som,
162
  "avaliacao_final": aval_final,
163
  "estados_eventos": estados.eventos[-12:]},
scripts/05_avaliar.py CHANGED
@@ -1,16 +1,19 @@
1
  #!/usr/bin/env python3
2
  # -*- coding: utf-8 -*-
3
- """Avaliação v2 — relatório de QUALIDADE DO APRENDIZADO com evidências:
4
 
5
  1. perplexidade LM: modelo inicial (aleatório) vs treinado vs por época;
6
  2. perdas por tarefa (9 tarefas) treinado vs aleatório;
7
- 3. MoE agrupável: especialistas ativos POR TAREFA na fase foco — evidência
8
- de foco na tarefa (grupos texto/visual/áudio roteiam diferente);
9
- 4. MTP: perdas por cabeça e α;
10
  5. W8A8: delta de perda com/sem quantização na lm_head;
11
  6. SOM: taxa de neurônios ativos, EQ, TE por variante;
12
- 7. geração: amostras com/sem punição dinâmica de repetição.
13
- Salva telemetria_out/avaliacao_v2.json."""
 
 
 
 
14
  import base64
15
  import json
16
  import math
@@ -34,7 +37,7 @@ from aurora.treino.treinador import (TAREFAS_AUDIO, TAREFAS_IMAGEM,
34
 
35
  CORPUS = "/home/z/my-project/aurora/cache_dados/corpus_v2.jsonl"
36
  TOKENIZADOR = "/home/z/my-project/aurora/cache_dados/tokenizador.json"
37
- RELATORIO = "/home/z/my-project/aurora/telemetria_out/avaliacao_v2.json"
38
 
39
 
40
  def carregar_registros(caminho):
@@ -200,7 +203,7 @@ def main():
200
 
201
  # 6) SOM — métricas TREINADAS vêm do resumo do treino (o orquestrador
202
  # não é nn.Module: seu estado é consolidado na fase SOM e gravado lá)
203
- resumo_path = "/home/z/my-project/aurora/telemetria_out/resumo_treino_v2.json"
204
  if os.path.exists(resumo_path):
205
  som_treinado = json.load(open(resumo_path)).get("som", {})
206
  relatorio["som_treinado"] = som_treinado
@@ -224,8 +227,90 @@ def main():
224
  print(" sem punição:", relatorio["geracao"]["sem_punicao"][:120])
225
  print(" com punição:", relatorio["geracao"]["com_punicao"][:120])
226
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
227
  # curva de épocas (telemetria)
228
- resumo_path = "/home/z/my-project/aurora/telemetria_out/resumo_treino_v2.json"
229
  if os.path.exists(resumo_path):
230
  relatorio["curva_epocas"] = [
231
  {"epoca": e["epoca"], "perda_media": e["perda_media"],
 
1
  #!/usr/bin/env python3
2
  # -*- coding: utf-8 -*-
3
+ """Avaliação v3 — relatório de QUALIDADE DO APRENDIZADO com evidências:
4
 
5
  1. perplexidade LM: modelo inicial (aleatório) vs treinado vs por época;
6
  2. perdas por tarefa (9 tarefas) treinado vs aleatório;
7
+ 3. MoE agrupável (roteamento POR TOKEN causal): top experts POR TAREFA;
8
+ 4. MTP adaptativo: perdas por cabeça, α e ECONOMIA de termos de CE;
 
9
  5. W8A8: delta de perda com/sem quantização na lm_head;
10
  6. SOM: taxa de neurônios ativos, EQ, TE por variante;
11
+ 7. geração: amostras com/sem punição dinâmica de repetição;
12
+ 8. MICROUNIDADES: ramos ativos, gating α por tarefa, refino recursivo;
13
+ 9. CONFIANÇA: posterior Beta, cota de Bernstein, ECE de calibração;
14
+ 10. MEMÓRIA INTERNA: hit-rate, escritas conficientes, compressão VQ;
15
+ 11. CRESCIMENTO: eventos de expansão/poda das microunidades.
16
+ Salva telemetria_out/avaliacao_v3.json."""
17
  import base64
18
  import json
19
  import math
 
37
 
38
  CORPUS = "/home/z/my-project/aurora/cache_dados/corpus_v2.jsonl"
39
  TOKENIZADOR = "/home/z/my-project/aurora/cache_dados/tokenizador.json"
40
+ RELATORIO = "/home/z/my-project/aurora/telemetria_out/avaliacao_v3.json"
41
 
42
 
43
  def carregar_registros(caminho):
 
203
 
204
  # 6) SOM — métricas TREINADAS vêm do resumo do treino (o orquestrador
205
  # não é nn.Module: seu estado é consolidado na fase SOM e gravado lá)
206
+ resumo_path = "/home/z/my-project/aurora/telemetria_out/resumo_treino_v3.json"
207
  if os.path.exists(resumo_path):
208
  som_treinado = json.load(open(resumo_path)).get("som", {})
209
  relatorio["som_treinado"] = som_treinado
 
227
  print(" sem punição:", relatorio["geracao"]["sem_punicao"][:120])
228
  print(" com punição:", relatorio["geracao"]["com_punicao"][:120])
229
 
230
+ # 8) MICROUNIDADES (doc 11): ramos, gating α por tarefa, recursão
231
+ print("== microunidades (composição serial/paralela/recursiva) ==")
232
+ micra = {}
233
+ for tarefa in ("lm", "vqa", "asr", "instrucao"):
234
+ perda_lote(modelo, tk, registros, tarefa, n_lotes=1)
235
+ micra[tarefa] = [
236
+ {"ramos": c.nome_ramos,
237
+ "alpha_medio": [round(a, 4) for a in c.ultimo_alpha.tolist()]
238
+ if c.ultimo_alpha is not None else None,
239
+ "passos_rec": c.ultimo_passos_rec}
240
+ for c in modelo.compositores]
241
+ for t, ms in micra.items():
242
+ if ms and ms[0]["alpha_medio"]:
243
+ print(f" {t:10s} α bloco0 = {ms[0]['alpha_medio']} rec = {ms[0]['passos_rec']}")
244
+ relatorio["microunidades"] = micra
245
+
246
+ # 9-11) CONFIANÇA / MEMÓRIA / CRESCIMENTO — estado consolidado no resumo
247
+ resumo_v3 = json.load(open(resumo_path)) if os.path.exists(resumo_path) else {}
248
+ if resumo_v3:
249
+ for chave in ("prs_v8", "confianca", "memoria", "crescimento", "microunidades"):
250
+ if chave in resumo_v3 and chave not in relatorio:
251
+ relatorio[f"treino_{chave}"] = resumo_v3[chave]
252
+ if resumo_v3.get("confianca"):
253
+ c = resumo_v3["confianca"]
254
+ print(f"== confiança: h_ema={c.get('h_ema')}, ECE={c.get('ece')}, "
255
+ f"Bernstein={c.get('bernstein')} ==")
256
+ if resumo_v3.get("memoria"):
257
+ m = resumo_v3["memoria"]
258
+ print(f"== memória: hit_rate={m.get('hit_rate')}, escritas={m.get('escritas')}, "
259
+ f"rejeitadas={m.get('rejeitadas_confianca')}, "
260
+ f"entropia_codebook={m.get('entropia_codebook')} ==")
261
+ if resumo_v3.get("crescimento") is not None:
262
+ print(f"== crescimento: {len(resumo_v3['crescimento'])} eventos ==")
263
+
264
+ # 12) MEMÓRIA INTERNA EM EXECUÇÃO (doc 11 §9): evidência de integração
265
+ # real — escrita conficiente dos contextos do corpus, consulta, evicção,
266
+ # compressão VQ e contratos, com o modelo JÁ TREINADO
267
+ print("== memória interna em execução (contextos reais do modelo) ==")
268
+ from aurora.memoria.interna import MemoriaInterna
269
+ from aurora.treino.confianca import AgenteConfianca
270
+ mi = MemoriaInterna(d=modelo.d, n_slots=32, h_escrita=0.25,
271
+ idade_compressao_s=0.0, n_codigos=64)
272
+ ag = AgenteConfianca()
273
+ amostras_mem = random.sample(registros, min(64, len(registros)))
274
+ h_escreveras = 0
275
+ for r in amostras_mem[:48]:
276
+ seq = tk.encode(r.get("texto") or (r.get("saida") or r.get("entrada", "")),
277
+ tarefa=r["tarefa"], max_len=64)[:64]
278
+ if len(seq) < 4:
279
+ continue
280
+ ids_m = torch.zeros(1, len(seq), dtype=torch.long)
281
+ ids_m[0] = torch.tensor(seq)
282
+ logits_m, _ = modelo(ids_m, tarefa=r["tarefa"])
283
+ perda_m = modelo.ultima_perda or 6.0
284
+ h_m = float(ag(AgenteConfianca.features_logits(logits_m),
285
+ perda_atual=float(perda_m)))
286
+ z_m = modelo.contexto(ids_m)[0]
287
+ if mi.escrever(z_m, h_m, origem="nucleo", tarefa=r["tarefa"]):
288
+ h_escreveras += 1
289
+ consultas_ok = 0
290
+ for r in amostras_mem[48:]:
291
+ seq = tk.encode(r.get("texto") or (r.get("saida") or r.get("entrada", "")),
292
+ tarefa=r["tarefa"], max_len=64)[:64]
293
+ if len(seq) < 4:
294
+ continue
295
+ ids_m = torch.zeros(1, len(seq), dtype=torch.long)
296
+ ids_m[0] = torch.tensor(seq)
297
+ z_m = modelo.contexto(ids_m)[0]
298
+ rec_m = mi.consultar(z_m, m=3, origem="raciocinio")
299
+ consultas_ok += int(rec_m["acerto"])
300
+ n_comp_m = mi.comprimir_antigos(origem="treino")
301
+ stats_m = mi.estatisticas()
302
+ stats_m["escritas_aceitas"] = h_escreveras
303
+ stats_m["consultas_com_acerto"] = consultas_ok
304
+ stats_m["comprimidos_agora"] = n_comp_m
305
+ relatorio["memoria_execucao"] = stats_m
306
+ print(f" escritas aceitas={h_escreveras}/48 · consultas com acerto="
307
+ f"{consultas_ok}/16 · comprimidos={n_comp_m} · "
308
+ f"entropia_codebook={stats_m['entropia_codebook']:.3f} · "
309
+ f"economia_bits/slot={stats_m['economia_bits_por_slot']:.4f} · "
310
+ f"violações_contrato={stats_m['violacoes_contrato']}")
311
+
312
  # curva de épocas (telemetria)
313
+ resumo_path = "/home/z/my-project/aurora/telemetria_out/resumo_treino_v3.json"
314
  if os.path.exists(resumo_path):
315
  relatorio["curva_epocas"] = [
316
  {"epoca": e["epoca"], "perda_media": e["perda_media"],
scripts/06_publicar_hf.py CHANGED
@@ -1,11 +1,14 @@
1
  #!/usr/bin/env python3
2
  # -*- coding: utf-8 -*-
3
- """Publica o AURORA v2 no HuggingFace de modo ORGANIZADO (item 11):
4
 
5
- README.md (model card v2) · LICENSE · configs/ · src/aurora/ · scripts/
6
- docs/matematica/ (provas 00–10) · tests/ · avaliacao_v2.json
7
  estados/{fase-dpo,fase-som}/modelo.safetensors+meta.json (pesos finais)
8
 
 
 
 
9
  SEGURANÇA: token EXCLUSIVAMENTE da variável HF_TOKEN — nunca gravado em arquivo,
10
  log ou repo. A publicação NUNCA inclui: cache_dados, telemetria_out, checkpoints
11
  locais, estados_local (cópia), cache_hub_tmp, arquivos com o token.
@@ -83,8 +86,10 @@ def main():
83
 
84
  # código/docs/configs de uma vez
85
  api.upload_folder(folder_path=STAGE, repo_id=args.repo, repo_type="model",
86
- commit_message="AURORA v2: MoE agrupável, denso→SOM, "
87
- "estados no Hub, 18 datasets streaming",
 
 
88
  allow_patterns=["*.py", "*.md", "*.json", "*.yaml", "*.yml",
89
  "*.txt", "LICENSE*"])
90
  print("✓ código, docs, configs, testes publicados")
@@ -111,23 +116,46 @@ def main():
111
  print(f"✓ estados publicados: {publico_tag(publicado)}")
112
 
113
  # relatório de avaliação como artefato de 1ª classe
114
- rel = os.path.join(RAIZ, "telemetria_out", "avaliacao_v2.json")
115
  if os.path.exists(rel):
116
- api.upload_file(path_or_fileobj=rel, path_in_repo="avaliacao_v2.json",
 
 
 
 
 
 
117
  repo_id=args.repo, repo_type="model",
118
- commit_message="relatório de avaliação v2")
119
- print("✓ avaliacao_v2.json publicado")
120
 
121
- # poda dos estados intermediários de retomada (mantém épocas cheias + fases)
 
 
122
  try:
 
123
  arquivos = api.list_repo_files(args.repo, repo_type="model")
124
- a_apagar = [f for f in arquivos
125
- if f.startswith("estados/") and "-parcial" in f]
126
- for f in a_apagar:
127
- api.delete_file(f, repo_id=args.repo, repo_type="model",
128
- commit_message=f"poda estado intermediário: {f}")
 
 
 
129
  if a_apagar:
130
- print(f"✓ {len(a_apagar)} estados intermediários podados do Hub")
 
 
 
 
 
 
 
 
 
 
 
131
  except Exception as e:
132
  print(f"(poda de parciais ignorada: {type(e).__name__})")
133
 
 
1
  #!/usr/bin/env python3
2
  # -*- coding: utf-8 -*-
3
+ """Publica o AURORA v3 no HuggingFace de modo ORGANIZADO (item 11):
4
 
5
+ README.md (model card v3) · LICENSE · configs/ · src/aurora/ · scripts/
6
+ docs/matematica/ (provas 00–11) · tests/ · avaliacao_v3.json · resumo_treino_v3.json
7
  estados/{fase-dpo,fase-som}/modelo.safetensors+meta.json (pesos finais)
8
 
9
+ HUGGINGFACE EXIGE ENVIOS COMPLETOS — parciais são PODADOS do repo no fim
10
+ (single commit de exclusão, com retentativas).
11
+
12
  SEGURANÇA: token EXCLUSIVAMENTE da variável HF_TOKEN — nunca gravado em arquivo,
13
  log ou repo. A publicação NUNCA inclui: cache_dados, telemetria_out, checkpoints
14
  locais, estados_local (cópia), cache_hub_tmp, arquivos com o token.
 
86
 
87
  # código/docs/configs de uma vez
88
  api.upload_folder(folder_path=STAGE, repo_id=args.repo, repo_type="model",
89
+ commit_message="AURORA v3: microunidades escaláveis (serial/"
90
+ "paralela/isolada/recursiva), Transformers+CNN-BiGRU+"
91
+ "BiGRU, memória interna conficiente, PRS V8, MTP K "
92
+ "adaptativo, crescimento por Hessiano",
93
  allow_patterns=["*.py", "*.md", "*.json", "*.yaml", "*.yml",
94
  "*.txt", "LICENSE*"])
95
  print("✓ código, docs, configs, testes publicados")
 
116
  print(f"✓ estados publicados: {publico_tag(publicado)}")
117
 
118
  # relatório de avaliação como artefato de 1ª classe
119
+ rel = os.path.join(RAIZ, "telemetria_out", "avaliacao_v3.json")
120
  if os.path.exists(rel):
121
+ api.upload_file(path_or_fileobj=rel, path_in_repo="avaliacao_v3.json",
122
+ repo_id=args.repo, repo_type="model",
123
+ commit_message="relatório de avaliação v3")
124
+ print("✓ avaliacao_v3.json publicado")
125
+ res = os.path.join(RAIZ, "telemetria_out", "resumo_treino_v3.json")
126
+ if os.path.exists(res):
127
+ api.upload_file(path_or_fileobj=res, path_in_repo="resumo_treino_v3.json",
128
  repo_id=args.repo, repo_type="model",
129
+ commit_message="resumo do treino v3 (PRS/confiança/memória/crescimento)")
130
+ print("✓ resumo_treino_v3.json publicado")
131
 
132
+ # poda dos estados intermediários de retomada — HF limita parciais;
133
+ # exclusão em ÚNICO commit (CommitOperationDelete) com retentativas
134
+ import time as _time
135
  try:
136
+ from huggingface_hub import CommitOperationDelete
137
  arquivos = api.list_repo_files(args.repo, repo_type="model")
138
+ a_apagar = []
139
+ for f in arquivos:
140
+ if not f.startswith("estados/"):
141
+ continue
142
+ partes = f.split("/")
143
+ tag = partes[1] if len(partes) > 2 else ""
144
+ if "-parcial" in tag or re.search(r"-p\d{5}$", tag):
145
+ a_apagar.append(f)
146
  if a_apagar:
147
+ ops = [CommitOperationDelete(path_in_repo=f) for f in a_apagar]
148
+ for tentativa in range(1, 4):
149
+ try:
150
+ api.create_commit(repo_id=args.repo, repo_type="model",
151
+ operations=ops,
152
+ commit_message="poda de estados parciais "
153
+ "(envios completos apenas)")
154
+ print(f"✓ {len(a_apagar)} estados parciais podados (1 commit)")
155
+ break
156
+ except Exception as e:
157
+ print(f" poda tentativa {tentativa} falhou: {type(e).__name__}")
158
+ _time.sleep(5)
159
  except Exception as e:
160
  print(f"(poda de parciais ignorada: {type(e).__name__})")
161
 
src/aurora/config.py CHANGED
@@ -49,7 +49,13 @@ class ConfigModelo:
49
  "d_ff_expert": 160, "top_k": 2, "margem_foco": 1.0, "n_tarefas": 9})
50
  # v2 — predição multi-token com α aprendíveis (doc 10 §3)
51
  mtp: dict = field(default_factory=lambda: {
52
- "ativo": True, "k_cabecas": 2, "beta_entropia": 0.01})
 
 
 
 
 
 
53
  # encoders multimodais "completo pesado" com escala configurável:
54
  imagem: dict = field(default_factory=lambda: {
55
  "tam_patch": 16, "resolucao": 96, "d": 192, "n_camadas": 3, "n_cabecas": 4})
@@ -114,6 +120,33 @@ class ConfigTreino:
114
  fase_som: dict = field(default_factory=lambda: {
115
  "ativo": True, "epocas": 2, "alvo_ativos": 0.90, "gamma_empate": 0.15,
116
  "lambda_novidade": 0.25, "dim_lote": 64})
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
117
 
118
 
119
  @dataclass
@@ -155,6 +188,7 @@ class Config:
155
  telemetria: ConfigTelemetria = field(default_factory=ConfigTelemetria)
156
  ciclo: ConfigCiclo = field(default_factory=ConfigCiclo)
157
  estados_hf: ConfigEstadosHF = field(default_factory=ConfigEstadosHF)
 
158
 
159
  def de_arquivo(self, caminho: str) -> "Config":
160
  """Sobrescreve campos recursivamente a partir de JSON."""
 
49
  "d_ff_expert": 160, "top_k": 2, "margem_foco": 1.0, "n_tarefas": 9})
50
  # v2 — predição multi-token com α aprendíveis (doc 10 §3)
51
  mtp: dict = field(default_factory=lambda: {
52
+ "ativo": True, "k_cabecas": 2, "beta_entropia": 0.01,
53
+ "k_adaptativo": True})
54
+ # v3 — microunidades escaláveis (doc 11 §§0–5): serial/paralela/isolada/recursiva
55
+ microunidades: dict = field(default_factory=lambda: {
56
+ "d_gru": 96, "d_ramo": 96, "d_refino": 128, "kernel1": 3, "kernel2": 5,
57
+ "gamma_rec": 0.5, "k_rec_max": 2, "eps_stop": 1e-2,
58
+ "tau0": 0.8, "kappa_conf": 1.0, "delta_explora": 0.15})
59
  # encoders multimodais "completo pesado" com escala configurável:
60
  imagem: dict = field(default_factory=lambda: {
61
  "tam_patch": 16, "resolucao": 96, "d": 192, "n_camadas": 3, "n_cabecas": 4})
 
120
  fase_som: dict = field(default_factory=lambda: {
121
  "ativo": True, "epocas": 2, "alvo_ativos": 0.90, "gamma_empate": 0.15,
122
  "lambda_novidade": 0.25, "dim_lote": 64})
123
+ # v3 — PRS V8 (doc 11 §7): histerese, SGDR+piso↓, clip-percentil, 2 regimes
124
+ prs_v8: dict = field(default_factory=lambda: {
125
+ "ativo": True, "eta_up": 0.05, "eta_down": 0.02, "T_ciclo": 400,
126
+ "decay_piso": 0.5, "percentil": 0.75, "janela_clip": 50,
127
+ "coef_streak": 0.3, "vel_alvo": 0.01, "boost_max": 1.5})
128
+ # v3 — AgenteConfiança (doc 11 §8): Beta+Bernstein+PAC-Bayes, κ assimétrico
129
+ confianca: dict = field(default_factory=lambda: {
130
+ "ativo": True, "kappa_punicao": 0.3, "kappa_premio": 0.1,
131
+ "janela_tau": 50, "quantil_tau": 0.25, "h_escrita_memoria": 0.5})
132
+ # v3 — GestorCrescimento (doc 11 §5): Hutchinson diag-H → expandir/podar
133
+ crescimento: dict = field(default_factory=lambda: {
134
+ "ativo": True, "a_cada": 200, "tau_expand": 0.10, "tau_prune": 0.01,
135
+ "eps_gate": 0.05, "janela_uso": 8, "n_max_ramos": 5, "n_sondas": 2})
136
+
137
+
138
+ @dataclass
139
+ class ConfigMemoriaInterna:
140
+ """Memória interna multimodal (v3, doc 11 §9): slots conficientes, evicção
141
+ por utilidade, compressão VQ e índice SOM + contratos de acesso."""
142
+ ativo: bool = True
143
+ n_slots: int = 64
144
+ h_escrita: float = 0.5
145
+ idade_compressao_s: float = 900.0
146
+ n_codigos: int = 64
147
+ lambda_utilidade: float = 0.1
148
+ meia_vida_s: float = 1800.0
149
+ replay_a_cada: int = 40 # passos entre replays de memória como contexto
150
 
151
 
152
  @dataclass
 
188
  telemetria: ConfigTelemetria = field(default_factory=ConfigTelemetria)
189
  ciclo: ConfigCiclo = field(default_factory=ConfigCiclo)
190
  estados_hf: ConfigEstadosHF = field(default_factory=ConfigEstadosHF)
191
+ memoria_interna: ConfigMemoriaInterna = field(default_factory=ConfigMemoriaInterna)
192
 
193
  def de_arquivo(self, caminho: str) -> "Config":
194
  """Sobrescreve campos recursivamente a partir de JSON."""
src/aurora/dados/estados_hf.py CHANGED
@@ -46,22 +46,28 @@ class EstadosHF:
46
  return os.path.join(self.dir_local, tag)
47
 
48
  def _upload(self, tag: str, nome: str, dados: bytes) -> bool:
49
- """Commit único no Hub; False se offline/erro (fallback local)."""
 
 
50
  if not self.repo_id or not self.token:
51
  return False
52
- try:
53
- from huggingface_hub import HfApi
54
- api = HfApi(token=self.token)
55
- api.upload_file(
56
- path_or_fileobj=dados,
57
- path_in_repo=f"{self.pasta}/{tag}/{nome}",
58
- repo_id=self.repo_id, repo_type="model",
59
- commit_message=f"AURORA estado {tag}: {nome}",
60
- )
61
- return True
62
- except Exception as e: # degradação graciosa
63
- self.eventos.append(f"upload {tag}/{nome} falhou: {type(e).__name__}: {e}")
64
- return False
 
 
 
 
65
 
66
  def _download(self, tag: str, nome: str) -> bytes | None:
67
  local = os.path.join(self._caminho_local(tag), nome)
@@ -70,17 +76,21 @@ class EstadosHF:
70
  return f.read()
71
  if not self.repo_id:
72
  return None
73
- try:
74
- from huggingface_hub import hf_hub_download
75
- caminho = hf_hub_download(repo_id=self.repo_id, repo_type="model",
76
- filename=f"{self.pasta}/{tag}/{nome}",
77
- token=self.token,
78
- cache_dir="/home/z/my-project/cache_hub_tmp")
79
- with open(caminho, "rb") as f:
80
- return f.read()
81
- except Exception as e:
82
- self.eventos.append(f"download {tag}/{nome} falhou: {type(e).__name__}")
83
- return None
 
 
 
 
84
 
85
  # ---------------- salvar / listar / carregar ----------------
86
  def salvar(self, modelo, tag: str, meta: dict) -> str:
@@ -109,34 +119,48 @@ class EstadosHF:
109
  with open(os.path.join(self._caminho_local(tag), "meta.json"), "w",
110
  encoding="utf-8") as f:
111
  json.dump(meta, f, ensure_ascii=False, indent=2)
 
 
112
  ok_peso = self._upload(tag, "modelo.safetensors", dados)
113
  ok_meta = self._upload(tag, "meta.json",
114
- json.dumps(meta, ensure_ascii=False).encode())
 
 
 
 
115
  self.eventos.append(f"estado {tag}: hub={'ok' if ok_peso and ok_meta else 'local'} "
116
  f"({len(dados)/1e6:.1f} MB)")
117
  return caminho
118
 
119
  def listar(self) -> list[str]:
120
- """Tags disponíveis (Hub ∪ local), ordenadas cronologicamente."""
 
 
121
  tags: set[str] = set()
122
  if os.path.isdir(self.dir_local):
123
  tags |= {d for d in os.listdir(self.dir_local)
124
  if os.path.isdir(os.path.join(self.dir_local, d))}
125
  if self.repo_id and self.token:
126
- try:
127
- from huggingface_hub import HfApi
128
- arquivos = HfApi(token=self.token).list_repo_files(self.repo_id,
129
- repo_type="model")
130
- prefixo = f"{self.pasta}/"
131
- for a in arquivos:
132
- if a.startswith(prefixo) and a.count("/") >= 2:
133
- tags.add(a[len(prefixo):].split("/")[0])
134
- except Exception as e:
135
- self.eventos.append(f"listar falhou: {type(e).__name__}")
 
 
 
 
136
  return sorted(tags)
137
 
138
  def carregar(self, modelo, tag: str) -> bool:
139
- """Baixa (se preciso), valida hash e carrega no modelo. True = ok."""
 
 
140
  dados = self._download(tag, "modelo.safetensors")
141
  if dados is None:
142
  return False
@@ -145,25 +169,69 @@ class EstadosHF:
145
  try:
146
  esperado = json.loads(meta_bruto).get("hash_sha256")
147
  if esperado and _sha256_bytes(dados) != esperado:
148
- self.eventos.append(f"estado {tag}: HASH divergente — rejeitado")
149
- return False
 
 
 
 
 
 
150
  except Exception:
151
  pass # meta ilegível: segue com aviso implícito
152
  try:
153
  sd = _st_load(dados)
154
- modelo.load_state_dict(sd, strict=False)
155
- self.eventos.append(f"estado {tag} carregado ({len(sd)} tensores)")
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
156
  return True
157
  except Exception as e:
158
  self.eventos.append(f"carregar {tag}: {type(e).__name__}: {e}")
159
  return False
160
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
161
  def carregar_ultimo(self, modelo) -> str | None:
162
  """Estado mais AVANÇADO (maior passo_global no meta) — não o
163
- lexicográfico (tags 'fase-*' ordenariam depois das 'epoca-*')."""
 
 
164
  tags = self.listar()
165
- melhor, melhor_passo = None, -1
166
- for tag in reversed(tags):
167
  dados = self._download(tag, "meta.json")
168
  if not dados:
169
  continue
@@ -171,11 +239,13 @@ class EstadosHF:
171
  passo = int(json.loads(dados).get("passo_global", -1))
172
  except Exception:
173
  continue
174
- if passo > melhor_passo:
175
- melhor, melhor_passo = tag, passo
176
- if melhor is None:
177
- return None
178
- return melhor if self.carregar(modelo, melhor) else None
 
 
179
 
180
  # ---------------- higiene de armazenamento ----------------
181
  def limpar_locais(self, manter: str | None = None):
 
46
  return os.path.join(self.dir_local, tag)
47
 
48
  def _upload(self, tag: str, nome: str, dados: bytes) -> bool:
49
+ """Commit único no Hub; False se offline/erro (fallback local).
50
+ v3: 3 retentativas — falha transitória de upload deixa o estado
51
+ inconsistente no Hub (meta sem peso) e reinicia o treino."""
52
  if not self.repo_id or not self.token:
53
  return False
54
+ import time
55
+ for tentativa in range(3):
56
+ try:
57
+ from huggingface_hub import HfApi
58
+ api = HfApi(token=self.token)
59
+ api.upload_file(
60
+ path_or_fileobj=dados,
61
+ path_in_repo=f"{self.pasta}/{tag}/{nome}",
62
+ repo_id=self.repo_id, repo_type="model",
63
+ commit_message=f"AURORA estado {tag}: {nome}",
64
+ )
65
+ return True
66
+ except Exception as e: # degradação graciosa
67
+ self.eventos.append(f"upload {tag}/{nome} t{tentativa}: "
68
+ f"{type(e).__name__}: {e}")
69
+ time.sleep(4 * (tentativa + 1))
70
+ return False
71
 
72
  def _download(self, tag: str, nome: str) -> bytes | None:
73
  local = os.path.join(self._caminho_local(tag), nome)
 
76
  return f.read()
77
  if not self.repo_id:
78
  return None
79
+ # v3: retentativas — 503/timeout do Hub não pode reiniciar o treino
80
+ for tentativa in range(3):
81
+ try:
82
+ from huggingface_hub import hf_hub_download
83
+ caminho = hf_hub_download(repo_id=self.repo_id, repo_type="model",
84
+ filename=f"{self.pasta}/{tag}/{nome}",
85
+ token=self.token,
86
+ cache_dir="/home/z/my-project/cache_hub_tmp")
87
+ with open(caminho, "rb") as f:
88
+ return f.read()
89
+ except Exception as e:
90
+ self.eventos.append(f"download {tag}/{nome} t{tentativa}: {type(e).__name__}")
91
+ import time
92
+ time.sleep(3 * (tentativa + 1))
93
+ return None
94
 
95
  # ---------------- salvar / listar / carregar ----------------
96
  def salvar(self, modelo, tag: str, meta: dict) -> str:
 
119
  with open(os.path.join(self._caminho_local(tag), "meta.json"), "w",
120
  encoding="utf-8") as f:
121
  json.dump(meta, f, ensure_ascii=False, indent=2)
122
+ # v3: peso PRIMEIRO; meta só se o peso subiu (par consistente — um meta
123
+ # sem peso, ou com hash de outro peso, reinicia o treino na retomada)
124
  ok_peso = self._upload(tag, "modelo.safetensors", dados)
125
  ok_meta = self._upload(tag, "meta.json",
126
+ json.dumps(meta, ensure_ascii=False).encode()) \
127
+ if ok_peso else False
128
+ if not ok_peso:
129
+ self.eventos.append(f"estado {tag}: peso NÃO subiu — par antigo "
130
+ f"preservado no Hub")
131
  self.eventos.append(f"estado {tag}: hub={'ok' if ok_peso and ok_meta else 'local'} "
132
  f"({len(dados)/1e6:.1f} MB)")
133
  return caminho
134
 
135
  def listar(self) -> list[str]:
136
+ """Tags disponíveis (Hub ∪ local), ordenadas cronologicamente.
137
+ v3: duas leituras separadas por 3s (a listagem do Hub pode estar
138
+ em cache de CDN logo após o commit — união reduz o risco)."""
139
  tags: set[str] = set()
140
  if os.path.isdir(self.dir_local):
141
  tags |= {d for d in os.listdir(self.dir_local)
142
  if os.path.isdir(os.path.join(self.dir_local, d))}
143
  if self.repo_id and self.token:
144
+ import time
145
+ for leitura in range(2):
146
+ try:
147
+ from huggingface_hub import HfApi
148
+ arquivos = HfApi(token=self.token).list_repo_files(
149
+ self.repo_id, repo_type="model")
150
+ prefixo = f"{self.pasta}/"
151
+ for a in arquivos:
152
+ if a.startswith(prefixo) and a.count("/") >= 2:
153
+ tags.add(a[len(prefixo):].split("/")[0])
154
+ if leitura == 0 and tags:
155
+ time.sleep(3) # segunda leitura pega commits novos
156
+ except Exception as e:
157
+ self.eventos.append(f"listar t{leitura} falhou: {type(e).__name__}")
158
  return sorted(tags)
159
 
160
  def carregar(self, modelo, tag: str) -> bool:
161
+ """Baixa (se preciso), valida hash e carrega no modelo. True = ok.
162
+ v3: em divergência de hash, re-baixa FORÇADO uma vez (cache do Hub
163
+ pode estar velho após sobrescrita) antes de rejeitar."""
164
  dados = self._download(tag, "modelo.safetensors")
165
  if dados is None:
166
  return False
 
169
  try:
170
  esperado = json.loads(meta_bruto).get("hash_sha256")
171
  if esperado and _sha256_bytes(dados) != esperado:
172
+ # re-baixa forçada (sem cache) — sobrescrita pode ter
173
+ # deixado blob velho no cache local
174
+ dados = self._download_forcado(tag, "modelo.safetensors")
175
+ if dados is None or _sha256_bytes(dados) != esperado:
176
+ self.eventos.append(f"estado {tag}: HASH divergente "
177
+ f"após re-download — rejeitado")
178
+ return False
179
+ self.eventos.append(f"estado {tag}: hash ok após re-download")
180
  except Exception:
181
  pass # meta ilegível: segue com aviso implícito
182
  try:
183
  sd = _st_load(dados)
184
+ # v3: carregamento TOLERANTE A FORMA — o gestor de crescimento pode
185
+ # ter EXPANDIDO microunidades (gate do compositor muda de forma);
186
+ # ao retomar de um estado pós-expansão num modelo novo, carregamos
187
+ # tensores por chave (mesmo nome E mesma forma) e pulamos os demais
188
+ # com registro — o treino segue com a capacidade do estado salvo.
189
+ modelo_sd = modelo.state_dict()
190
+ carregados, pulados = 0, 0
191
+ próprios = {}
192
+ for k, v in sd.items():
193
+ alvo = modelo_sd.get(k)
194
+ if alvo is not None and alvo.shape == v.shape:
195
+ próprios[k] = v
196
+ carregados += 1
197
+ else:
198
+ pulados += 1
199
+ faltantes = {k: v for k, v in modelo_sd.items()
200
+ if k not in próprios and k not in sd}
201
+ modelo.load_state_dict(próprios, strict=False)
202
+ if pulados or faltantes:
203
+ self.eventos.append(f"estado {tag}: {carregados} tensores, "
204
+ f"{pulados} pulados (forma/nome), "
205
+ f"{len(faltantes)} novos no modelo")
206
+ else:
207
+ self.eventos.append(f"estado {tag} carregado ({carregados} tensores)")
208
  return True
209
  except Exception as e:
210
  self.eventos.append(f"carregar {tag}: {type(e).__name__}: {e}")
211
  return False
212
 
213
+ def _download_forcado(self, tag: str, nome: str) -> bytes | None:
214
+ try:
215
+ from huggingface_hub import hf_hub_download
216
+ caminho = hf_hub_download(repo_id=self.repo_id, repo_type="model",
217
+ filename=f"{self.pasta}/{tag}/{nome}",
218
+ token=self.token,
219
+ cache_dir="/home/z/my-project/cache_hub_tmp",
220
+ force_download=True)
221
+ with open(caminho, "rb") as f:
222
+ return f.read()
223
+ except Exception as e:
224
+ self.eventos.append(f"download forçado {tag}/{nome}: {type(e).__name__}")
225
+ return None
226
+
227
  def carregar_ultimo(self, modelo) -> str | None:
228
  """Estado mais AVANÇADO (maior passo_global no meta) — não o
229
+ lexicográfico (tags 'fase-*' ordenariam depois das 'epoca-*').
230
+ v3: se o melhor estado falhar ao carregar, cai para o próximo
231
+ (nunca reinicia o treino por um download transitório)."""
232
  tags = self.listar()
233
+ candidatos: list[tuple[int, str]] = []
234
+ for tag in tags:
235
  dados = self._download(tag, "meta.json")
236
  if not dados:
237
  continue
 
239
  passo = int(json.loads(dados).get("passo_global", -1))
240
  except Exception:
241
  continue
242
+ candidatos.append((passo, tag))
243
+ candidatos.sort(reverse=True)
244
+ for passo, tag in candidatos:
245
+ if self.carregar(modelo, tag):
246
+ self.eventos.append(f"retomada: {tag} (passo {passo})")
247
+ return tag
248
+ return None
249
 
250
  # ---------------- higiene de armazenamento ----------------
251
  def limpar_locais(self, manter: str | None = None):
src/aurora/memoria/interna.py ADDED
@@ -0,0 +1,263 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Memória interna multimodal do modelo (v3, doc 11 §9) — gestão aprimorada:
3
+
4
+ 1. MEMÓRIA DE TRABALHO: slots (z_i, u_i, h_i, t_i) com ESCRITA CONFICIENTE
5
+ (só grava com h_t ≥ h_escrita), recuperação por similaridade+bônus de
6
+ utilidade e EVICÇÃO por utilidade U_i = u_i·e^{−Δt/T}·h_i.
7
+ 2. COMPRESSÃO VQ: entradas antigas viram códigos discretos (log₂N bits/slot)
8
+ via quantizador vetorial EMA com dead-code restart por JANELA (correção
9
+ do defect 3 do estudo: contagem decrescente, não acumulada) + perda de
10
+ diversidade (Teorema 11.9: H ≥ log N − ε).
11
+ 3. ÍNDICE SOM: endereço simbólico (mapa, BMU) de cada escrita — recall por
12
+ categoria, não só por similaridade bruta.
13
+ 4. CONTRATOS (doc 11 §10): matriz de permissões verificada em runtime —
14
+ violação registra defeito no BugWatch e levanta erro (divisão de
15
+ competências entre percepcao/memoria/raciocinio/treino/nucleo).
16
+ """
17
+ from __future__ import annotations
18
+
19
+ import math
20
+ import time
21
+ from dataclasses import dataclass, field
22
+
23
+ import torch
24
+ import torch.nn as nn
25
+ import torch.nn.functional as F
26
+
27
+ # matriz de permissões (doc 11 §10): quem pode fazer o quê com a memória
28
+ PERMISSOES = {
29
+ "percepcao": {"escrever", "consultar"},
30
+ "nucleo": {"consultar", "escrever"},
31
+ "raciocinio": {"consultar"},
32
+ "treino": {"consultar", "consolidar", "estatisticas"},
33
+ "telemetria": {"estatisticas"},
34
+ }
35
+
36
+
37
+ class QuantizadorVetorialEMA(nn.Module):
38
+ """VQ‑EMA com dead-code restart por JANELA (defeito 3 corrigido: a
39
+ contagem de uso decai — EMA — em vez de acumular desde o início)."""
40
+
41
+ def __init__(self, n_codigos: int, dim: int, decaimento: float = 0.99,
42
+ custo_compromisso: float = 0.25, morto_ema: float = 0.01,
43
+ peso_diversidade: float = 0.1):
44
+ super().__init__()
45
+ embed = torch.randn(n_codigos, dim) * 0.02
46
+ self.register_buffer("embeddings", embed)
47
+ self.register_buffer("ema_cont", torch.zeros(n_codigos))
48
+ self.register_buffer("ema_peso", embed.clone())
49
+ self.decaimento = decaimento
50
+ self.custo = custo_compromisso
51
+ self.morto_ema = morto_ema
52
+ self.peso_div = peso_diversidade
53
+ self.n_codigos = n_codigos
54
+
55
+ def forward(self, z: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
56
+ flat = z.reshape(-1, z.shape[-1])
57
+ dist = (flat.pow(2).sum(1, keepdim=True)
58
+ - 2 * flat @ self.embeddings.t()
59
+ + self.embeddings.pow(2).sum(1))
60
+ idx = dist.argmin(dim=1)
61
+ one_hot = F.one_hot(idx, self.n_codigos).type(flat.dtype)
62
+ q = one_hot @ self.embeddings
63
+ if self.training:
64
+ with torch.no_grad():
65
+ cont = one_hot.sum(0)
66
+ ema_n = self.decaimento * self.ema_cont + (1 - self.decaimento) * cont
67
+ self.ema_peso = (self.decaimento * self.ema_peso
68
+ + (1 - self.decaimento) * (one_hot.t() @ flat))
69
+ self.ema_cont = ema_n
70
+ self.embeddings.copy_(self.ema_peso / self.ema_cont.unsqueeze(1).clamp(min=1e-6))
71
+ # dead-code restart por janela EMA (não acumulada)
72
+ mortos = (self.ema_cont < self.morto_ema).nonzero(as_tuple=True)[0]
73
+ if mortos.numel() and flat.shape[0] > 0:
74
+ n = min(mortos.numel(), flat.shape[0])
75
+ escolha = torch.randperm(flat.shape[0])[:n]
76
+ self.embeddings.data[mortos[:n]] = flat[escolha].detach()
77
+ self.ema_cont.data[mortos[:n]] = 1.0
78
+ self.ema_peso.data[mortos[:n]] = flat[escolha].detach()
79
+ e_lat = F.mse_loss(q.detach(), flat)
80
+ q_lat = F.mse_loss(q, flat.detach())
81
+ # diversidade: -H(p) normalizado (força uso uniforme do codebook)
82
+ if self.training and self.peso_div > 0:
83
+ p = one_hot.float().mean(0).clamp_min(1e-10)
84
+ H = -(p * p.log()).sum()
85
+ div = -H / math.log(self.n_codigos)
86
+ else:
87
+ div = torch.zeros(())
88
+ perda = q_lat + self.custo * e_lat + self.peso_div * div
89
+ q_ste = flat + (q - flat).detach() # straight-through
90
+ return q_ste.reshape_as(z), perda, idx.reshape(z.shape[:-1])
91
+
92
+ @torch.no_grad()
93
+ def entropia_uso(self) -> float:
94
+ p = (self.ema_cont / self.ema_cont.sum().clamp(min=1e-9)).clamp_min(1e-10)
95
+ return float(-(p * p.log()).sum())
96
+
97
+
98
+ @dataclass
99
+ class SlotMemoria:
100
+ z: torch.Tensor # (d,) conteúdo
101
+ utilidade: float = 0.0 # EMA de acessos
102
+ confianca: float = 0.5 # h_t no momento da escrita
103
+ t: float = field(default_factory=time.time)
104
+ comprimido: bool = False
105
+ codigo: int | None = None # índice VQ quando comprimido
106
+ endereco_som: tuple | None = None # (variante, índice BMU)
107
+ origem: str = "percepcao"
108
+ tarefa: str | None = None
109
+
110
+
111
+ class RegistroAcessos:
112
+ """Verificação de contratos (doc 11 §10): cada operação valida a matriz
113
+ de permissões; violações são coletadas para o BugWatch."""
114
+
115
+ def __init__(self):
116
+ self.historico: list[dict] = []
117
+ self.violacoes: list[dict] = []
118
+
119
+ def registrar(self, origem: str, operacao: str, ok: bool):
120
+ entrada = {"origem": origem, "operacao": operacao, "ok": ok,
121
+ "t": time.time()}
122
+ self.historico.append(entrada)
123
+ if not ok:
124
+ self.violacoes.append(entrada)
125
+ return ok
126
+
127
+
128
+ class MemoriaInterna:
129
+ """Memória de trabalho + compressão VQ + índice SOM + contratos."""
130
+
131
+ def __init__(self, d: int, n_slots: int = 64, h_escrita: float = 0.5,
132
+ idade_compressao_s: float = 900.0, n_codigos: int = 64,
133
+ lambda_utilidade: float = 0.1, meia_vida_s: float = 1800.0):
134
+ self.d = d
135
+ self.n_slots = n_slots
136
+ self.h_escrita = h_escrita
137
+ self.idade_compressao = idade_compressao_s
138
+ self.lambda_u = lambda_utilidade
139
+ self.meia_vida = meia_vida_s
140
+ self.slots: list[SlotMemoria] = []
141
+ self.vq = QuantizadorVetorialEMA(n_codigos, d)
142
+ self.acessos = RegistroAcessos()
143
+ self.escritas_total = 0
144
+ self.rejeitadas_confianca = 0
145
+ self.consultas = 0
146
+ self.acertos = 0 # consulta com ≥1 slot útil (score>0)
147
+ self.perda_vq_ema: float | None = None
148
+ self.som_index: dict[tuple, list[int]] = {}
149
+
150
+ # ---------------- contratos ----------------
151
+ def _checar(self, origem: str, operacao: str) -> bool:
152
+ ok = operacao in PERMISSOES.get(origem, set())
153
+ self.acessos.registrar(origem, operacao, ok)
154
+ return ok
155
+
156
+ # ---------------- escrita conficiente ----------------
157
+ def escrever(self, z: torch.Tensor, h_t: float, origem: str = "percepcao",
158
+ tarefa: str | None = None) -> bool:
159
+ """Grava z (d,) se h_t ≥ h_escrita (doc 11 §9.1). Retorna se gravou."""
160
+ if not self._checar(origem, "escrever"):
161
+ raise PermissionError(f"{origem} não pode escrever na memória")
162
+ h_t = float(min(max(h_t, 0.0), 1.0))
163
+ if h_t < self.h_escrita:
164
+ self.rejeitadas_confianca += 1
165
+ return False
166
+ z = z.detach().flatten().float()
167
+ if z.shape[0] != self.d:
168
+ raise ValueError(f"dimensão {z.shape[0]} ≠ d={self.d}")
169
+ if len(self.slots) >= self.n_slots:
170
+ self._evict()
171
+ self.slots.append(SlotMemoria(z=z, confianca=h_t, origem=origem))
172
+ self.escritas_total += 1
173
+ return True
174
+
175
+ def indexar_som(self, indice_slot: int, variante: str, bmu: int):
176
+ """Registra endereço simbólico (mapa, BMU) — recall por categoria."""
177
+ slot = self.slots[indice_slot]
178
+ slot.endereco_som = (variante, bmu)
179
+ self.som_index.setdefault((variante, bmu), []).append(indice_slot)
180
+
181
+ # ---------------- consulta ----------------
182
+ def consultar(self, q: torch.Tensor, m: int = 3, origem: str = "nucleo") -> dict:
183
+ """score = cos(q, z_i) + λ_u·u_i; devolve top-m e metadados."""
184
+ if not self._checar(origem, "consultar"):
185
+ raise PermissionError(f"{origem} não pode consultar a memória")
186
+ self.consultas += 1
187
+ if not self.slots:
188
+ return {"vetores": torch.zeros(m, self.d), "scores": [0.0] * m,
189
+ "indices": [], "acerto": False}
190
+ q = q.detach().flatten().float()
191
+ Z = torch.stack([s.z for s in self.slots]) # (S,d)
192
+ Zn = F.normalize(Z, dim=1)
193
+ cos = Zn @ F.normalize(q, dim=0) # (S,)
194
+ agora = time.time()
195
+ U = torch.tensor([s.utilidade * math.exp(-(agora - s.t) / self.meia_vida)
196
+ * s.confianca for s in self.slots])
197
+ score = cos + self.lambda_u * U
198
+ m = min(m, len(self.slots))
199
+ topo = score.topk(m).indices.tolist()
200
+ for i in topo:
201
+ s = self.slots[i]
202
+ s.utilidade = 0.9 * s.utilidade + 0.1
203
+ s.t = agora
204
+ acerto = float(score[topo[0]]) > 0.0
205
+ self.acertos += int(acerto)
206
+ return {"vetores": Z[topo], "scores": [float(score[i]) for i in topo],
207
+ "indices": topo, "acerto": acerto}
208
+
209
+ # ---------------- evicção e compressão ----------------
210
+ def _evict(self):
211
+ agora = time.time()
212
+ U = [s.utilidade * math.exp(-(agora - s.t) / self.meia_vida) * s.confianca
213
+ for s in self.slots]
214
+ i = int(torch.tensor(U).argmin())
215
+ self.slots.pop(i)
216
+ # reindexa (índices deslocam)
217
+ novo = {}
218
+ for chave, idxs in self.som_index.items():
219
+ novo[chave] = [j - 1 if j > i else j for j in idxs if j != i]
220
+ self.som_index = {k: v for k, v in novo.items() if v}
221
+
222
+ def comprimir_antigos(self, origem: str = "treino") -> int:
223
+ """Slots com idade > idade_compressao viram códigos VQ (log₂N bits).
224
+ Teorema 11.9: economia 1 − log₂N/(32·d) com distorção ≤ D."""
225
+ if not self._checar(origem, "consolidar"):
226
+ raise PermissionError(f"{origem} não pode consolidar a memória")
227
+ agora = time.time()
228
+ alvo = [i for i, s in enumerate(self.slots)
229
+ if not s.comprimido and agora - s.t > self.idade_compressao]
230
+ if not alvo:
231
+ return 0
232
+ Z = torch.stack([self.slots[i].z for i in alvo])
233
+ if not Z.requires_grad:
234
+ Z = Z.clone().requires_grad_(False)
235
+ self.vq.train()
236
+ q, perda, idx = self.vq(Z)
237
+ self.perda_vq_ema = (perda if self.perda_vq_ema is None
238
+ else 0.9 * self.perda_vq_ema + 0.1 * float(perda))
239
+ for j, i in enumerate(alvo):
240
+ s = self.slots[i]
241
+ s.comprimido = True
242
+ s.codigo = int(idx[j])
243
+ s.z = q[j].detach() # conteúdo ≈ quantizado (poupa nada
244
+ # em RAM aqui — a economia real é nos CHECKPOINTS: só o codebook
245
+ # (N·d) viaja; os códigos ficam simbólicos no meta.json)
246
+ return len(alvo)
247
+
248
+ # ---------------- estatísticas ----------------
249
+ def estatisticas(self) -> dict:
250
+ agora = time.time()
251
+ n_comp = sum(s.comprimido for s in self.slots)
252
+ return {
253
+ "slots": len(self.slots), "capacidade": self.n_slots,
254
+ "escritas": self.escritas_total,
255
+ "rejeitadas_confianca": self.rejeitadas_confianca,
256
+ "hit_rate": (self.acertos / self.consultas) if self.consultas else 0.0,
257
+ "comprimidos": n_comp,
258
+ "entropia_codebook": self.vq.entropia_uso(),
259
+ "perda_vq": self.perda_vq_ema,
260
+ "violacoes_contrato": len(self.acessos.violacoes),
261
+ "economia_bits_por_slot": (1.0 - math.log2(self.vq.n_codigos)
262
+ / (32.0 * self.d)),
263
+ }
src/aurora/nucleo/modelo.py CHANGED
@@ -23,9 +23,10 @@ import torch.nn.functional as F
23
 
24
  from aurora.percepcao.atencao import MixtureOfAttention
25
  from aurora.percepcao.audio import CodificadorAudio
26
- from aurora.percepcao.blocos import Bloco, RMSNorm
27
  from aurora.percepcao.fusao import FusaoMultimodal
28
  from aurora.percepcao.imagem import CodificadorImagem
 
29
  from aurora.percepcao.moe import GRUPOS_TAREFA, MoEAgrupavel
30
  from aurora.percepcao.ortogonais import CamadaCooperativa, CamadaOrtogonal
31
  from aurora.percepcao.video import CodificadorVideo
@@ -63,10 +64,14 @@ class AURORAModel(nn.Module):
63
  top_k=int(cfg_moe.get("top_k", 2)),
64
  n_tarefas=int(cfg_moe.get("n_tarefas", 9)),
65
  margem_foco=float(cfg_moe.get("margem_foco", 1.0)))
 
 
66
  self.blocos = nn.ModuleList([
67
- Bloco(m.d_modelo, m.n_cabecas, m.d_ff, m.janela_sliding, m.dropout,
68
- moe=_moe_para(i))
69
  for i in range(m.n_camadas)])
 
 
70
  self.norm_f = RMSNorm(m.d_modelo)
71
  self.lm_head = nn.Linear(m.d_modelo, m.vocab, bias=False)
72
  self.lm_head.weight = self.emb.weight # tied (RAM otimizada)
@@ -103,6 +108,19 @@ class AURORAModel(nn.Module):
103
  if bloco.moe is not None:
104
  bloco.moe.fase_densa = (fase == "densa")
105
 
 
 
 
 
 
 
 
 
 
 
 
 
 
106
  def indice_tarefa(self, tarefa: str | None) -> int:
107
  return self.TAREFAS.index(tarefa) if tarefa in self.TAREFAS else -1
108
 
@@ -146,11 +164,12 @@ class AURORAModel(nn.Module):
146
  # ---------------- MTP (doc 10 §3) ----------------
147
  def mtp_do_trunk(self, ids: torch.Tensor, alvo: torch.Tensor,
148
  tarefa: str | None = None,
149
- com_prefixo: bool = False) -> torch.Tensor | None:
 
150
  """MTP sobre o estado oculto do MESMO forward (grafo compartilhado —
151
- PCGrad separa os gradientes depois, doc 10 §5). Se não houver forward
152
- recente compatível, re-executa o trunk. `com_prefixo`: descarta a
153
- posição do prefixo para alinhar MTP ao eixo temporal dos ids."""
154
  if self.mtp is None:
155
  return None
156
  h = getattr(self, "_ultimo_oculto", None)
@@ -164,7 +183,7 @@ class AURORAModel(nn.Module):
164
  h = self.norm_f(x)
165
  if com_prefixo and h.shape[1] == ids.shape[1] + 1:
166
  h = h[:, 1:]
167
- return self.mtp.perda(h, self.emb.weight, alvo)
168
 
169
  # ---------------- multimodal ----------------
170
  @torch.no_grad()
@@ -304,6 +323,22 @@ class AURORAModel(nn.Module):
304
  if self.mtp is not None and self.mtp.ultimos:
305
  for j, a in enumerate(self.mtp.ultimos.get("alphas", [])):
306
  out[f"mtp/alpha{j}"] = a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
307
  return out
308
 
309
  @torch.no_grad()
 
23
 
24
  from aurora.percepcao.atencao import MixtureOfAttention
25
  from aurora.percepcao.audio import CodificadorAudio
26
+ from aurora.percepcao.blocos import Bloco, BlocoV3, RMSNorm
27
  from aurora.percepcao.fusao import FusaoMultimodal
28
  from aurora.percepcao.imagem import CodificadorImagem
29
+ from aurora.percepcao.microunidades import BiGRUNaoCausal
30
  from aurora.percepcao.moe import GRUPOS_TAREFA, MoEAgrupavel
31
  from aurora.percepcao.ortogonais import CamadaCooperativa, CamadaOrtogonal
32
  from aurora.percepcao.video import CodificadorVideo
 
64
  top_k=int(cfg_moe.get("top_k", 2)),
65
  n_tarefas=int(cfg_moe.get("n_tarefas", 9)),
66
  margem_foco=float(cfg_moe.get("margem_foco", 1.0)))
67
+ # v3: tronco causal com microunidades (doc 11 §12) — BlocoV3
68
+ cfg_micra = dict(getattr(m, "microunidades", {}) or {})
69
  self.blocos = nn.ModuleList([
70
+ BlocoV3(m.d_modelo, m.n_cabecas, m.d_ff, m.janela_sliding, m.dropout,
71
+ moe=_moe_para(i), cfg_micra=cfg_micra)
72
  for i in range(m.n_camadas)])
73
+ # confiança corrente (h_t do AgenteConfiança — definida pelo treino)
74
+ self.confianca_corrente: float = 0.5
75
  self.norm_f = RMSNorm(m.d_modelo)
76
  self.lm_head = nn.Linear(m.d_modelo, m.vocab, bias=False)
77
  self.lm_head.weight = self.emb.weight # tied (RAM otimizada)
 
108
  if bloco.moe is not None:
109
  bloco.moe.fase_densa = (fase == "densa")
110
 
111
+ @property
112
+ def compositores(self) -> list:
113
+ """Compositores de microunidades (para o GestorCrescimento — doc 11 §5)."""
114
+ return [b.composto for b in self.blocos if hasattr(b, "composto")]
115
+
116
+ def registrar_confianca(self, h_t: float):
117
+ """Distribui h_t (AgenteConfiança) aos compositores — temperatura do
118
+ gating (menor confiança ⇒ softmax mais plano ⇒ mais exploração)."""
119
+ self.confianca_corrente = float(min(max(h_t, 0.0), 1.0))
120
+ for b in self.blocos:
121
+ if hasattr(b, "registrar_confianca"):
122
+ b.registrar_confianca(self.confianca_corrente)
123
+
124
  def indice_tarefa(self, tarefa: str | None) -> int:
125
  return self.TAREFAS.index(tarefa) if tarefa in self.TAREFAS else -1
126
 
 
164
  # ---------------- MTP (doc 10 §3) ----------------
165
  def mtp_do_trunk(self, ids: torch.Tensor, alvo: torch.Tensor,
166
  tarefa: str | None = None,
167
+ com_prefixo: bool = False,
168
+ h_conf: torch.Tensor | None = None) -> torch.Tensor | None:
169
  """MTP sobre o estado oculto do MESMO forward (grafo compartilhado —
170
+ PCGrad separa os gradientes depois, doc 10 §5). v3: `h_conf` (B,T) ativa
171
+ a máscara de K adaptativo (doc 11 Teorema 11.6). `com_prefixo`: descarta
172
+ a posição do prefixo para alinhar MTP ao eixo temporal dos ids."""
173
  if self.mtp is None:
174
  return None
175
  h = getattr(self, "_ultimo_oculto", None)
 
183
  h = self.norm_f(x)
184
  if com_prefixo and h.shape[1] == ids.shape[1] + 1:
185
  h = h[:, 1:]
186
+ return self.mtp.perda(h, self.emb.weight, alvo, h_conf=h_conf)
187
 
188
  # ---------------- multimodal ----------------
189
  @torch.no_grad()
 
323
  if self.mtp is not None and self.mtp.ultimos:
324
  for j, a in enumerate(self.mtp.ultimos.get("alphas", [])):
325
  out[f"mtp/alpha{j}"] = a
326
+ if "termos_ce" in self.mtp.ultimos:
327
+ out["mtp/termos_ce"] = float(self.mtp.ultimos["termos_ce"])
328
+ # microunidades v3 (doc 11): uso por ramo, gating e recursão
329
+ for i, bloco in enumerate(self.blocos):
330
+ comp = getattr(bloco, "composto", None)
331
+ if comp is None:
332
+ continue
333
+ out[f"micra{i}/n_ramos"] = len(comp.nome_ramos)
334
+ out[f"micra{i}/ramos_ativos"] = int((comp.ramo_ativo > 0.5).sum())
335
+ out[f"micra{i}/passos_rec"] = comp.ultimo_passos_rec
336
+ if comp.ultimo_alpha is not None:
337
+ for r, a in enumerate(comp.ultimo_alpha.tolist()):
338
+ out[f"micra{i}/alpha{r}"] = a
339
+ if comp.uso_ema is not None:
340
+ for r, a in enumerate(comp.uso_ema.tolist()):
341
+ out[f"micra{i}/uso{r}"] = a
342
  return out
343
 
344
  @torch.no_grad()
src/aurora/percepcao/audio.py CHANGED
@@ -15,6 +15,7 @@ import torch.nn as nn
15
  import torch.nn.functional as F
16
 
17
  from aurora.percepcao.blocos import Bloco, RMSNorm
 
18
 
19
 
20
  def log_mel_spectrogram(onda: torch.Tensor, n_mels: int = 80, n_fft: int = 400,
@@ -36,6 +37,8 @@ class CodificadorAudio(nn.Module):
36
  self.conv2 = nn.Conv1d(d, d, kernel_size=3, stride=2, padding=1) # downsample 2×
37
  self.blocos = nn.ModuleList([Bloco(d, n_cabecas, d_ff, raio_janela=16)
38
  for _ in range(n_camadas)])
 
 
39
  self.norm = RMSNorm(d)
40
  self.aten_pool = nn.Linear(d, 1)
41
  self.saida = nn.Linear(d, d_saida)
@@ -50,6 +53,7 @@ class CodificadorAudio(nn.Module):
50
  x = F.gelu(self.conv1(x))
51
  x = F.gelu(self.conv2(x))
52
  x = x.transpose(1, 2) # (B, T, d)
 
53
  for bloco in self.blocos:
54
  x, _, _ = bloco(x)
55
  pesos = torch.softmax(self.aten_pool(x), dim=1) # pooling de atenção
 
15
  import torch.nn.functional as F
16
 
17
  from aurora.percepcao.blocos import Bloco, RMSNorm
18
+ from aurora.percepcao.microunidades import BiGRUNaoCausal
19
 
20
 
21
  def log_mel_spectrogram(onda: torch.Tensor, n_mels: int = 80, n_fft: int = 400,
 
37
  self.conv2 = nn.Conv1d(d, d, kernel_size=3, stride=2, padding=1) # downsample 2×
38
  self.blocos = nn.ModuleList([Bloco(d, n_cabecas, d_ff, raio_janela=16)
39
  for _ in range(n_camadas)])
40
+ # v3 (doc 11 §12): lane CNN-BiGRU isolada (Teorema 11.3) pós-convs
41
+ self.bigru = BiGRUNaoCausal(d)
42
  self.norm = RMSNorm(d)
43
  self.aten_pool = nn.Linear(d, 1)
44
  self.saida = nn.Linear(d, d_saida)
 
53
  x = F.gelu(self.conv1(x))
54
  x = F.gelu(self.conv2(x))
55
  x = x.transpose(1, 2) # (B, T, d)
56
+ x = x + self.bigru(x) # contexto bidirecional
57
  for bloco in self.blocos:
58
  x, _, _ = bloco(x)
59
  pesos = torch.softmax(self.aten_pool(x), dim=1) # pooling de atenção
src/aurora/percepcao/blocos.py CHANGED
@@ -11,6 +11,7 @@ import torch
11
  import torch.nn as nn
12
  import torch.nn.functional as F
13
  from aurora.percepcao.atencao import MixtureOfAttention
 
14
 
15
 
16
  class RMSNorm(nn.Module):
@@ -75,3 +76,43 @@ class Bloco(nn.Module):
75
  @torch.no_grad()
76
  def reset_estado(self):
77
  self._estado_linear = None
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
11
  import torch.nn as nn
12
  import torch.nn.functional as F
13
  from aurora.percepcao.atencao import MixtureOfAttention
14
+ from aurora.percepcao.microunidades import ComposicaoMicroUnidades
15
 
16
 
17
  class RMSNorm(nn.Module):
 
76
  @torch.no_grad()
77
  def reset_estado(self):
78
  self._estado_linear = None
79
+
80
+
81
+ class BlocoV3(nn.Module):
82
+ """Bloco v3 (doc 11 §12): Transformer (atenção mista doc 07) + composição
83
+ de microunidades no FFN — stem CNN→GRU serial, ramos paralelos com
84
+ gating convexo (incluindo a MoE agrupável) e refino recursivo.
85
+
86
+ O bloco `Bloco` (v2) permanece para os ENCODERS não causais; o tronco
87
+ causal do decodificador usa `BlocoV3`. Interface idêntica à do `Bloco`:
88
+ forward(x, cache_k, cache_v, kv_max, coletar, tarefa) → (x, k, v).
89
+ """
90
+
91
+ def __init__(self, d: int, n_cabecas: int, d_ff: int, raio_janela: int = 32,
92
+ dropout: float = 0.0, moe=None, cfg_micra: dict | None = None):
93
+ super().__init__()
94
+ self.norm1 = RMSNorm(d)
95
+ self.atencao = MixtureOfAttention(d, n_cabecas, raio_janela, dropout)
96
+ self.norm2 = RMSNorm(d)
97
+ self.composto = ComposicaoMicroUnidades(d, cfg_micra or {}, moe=moe)
98
+ self.moe = moe # compatibilidade com a telemetria v2
99
+ self._tarefa_corrente: str | None = None
100
+
101
+ def registrar_confianca(self, h_t: float):
102
+ self.composto.registrar_confianca(h_t)
103
+
104
+ def forward(self, x, cache_k=None, cache_v=None, kv_max=512, coletar=None,
105
+ tarefa=None):
106
+ est_in = getattr(self, "_estado_linear", None) \
107
+ if (not self.training and x.shape[1] == 1) else None
108
+ h, k, v, est_out = self.atencao(self.norm1(x), cache_k, cache_v, kv_max, coletar,
109
+ estado_linear=est_in)
110
+ self._estado_linear = est_out if est_out is not None else None
111
+ x = x + h
112
+ self._tarefa_corrente = tarefa
113
+ x = x + self.composto(self.norm2(x), tarefa=tarefa)
114
+ return x, k, v
115
+
116
+ @torch.no_grad()
117
+ def reset_estado(self):
118
+ self._estado_linear = None
src/aurora/percepcao/imagem.py CHANGED
@@ -9,6 +9,7 @@ import torch
9
  import torch.nn as nn
10
 
11
  from aurora.percepcao.blocos import Bloco, RMSNorm
 
12
 
13
 
14
  class CodificadorImagem(nn.Module):
@@ -24,6 +25,8 @@ class CodificadorImagem(nn.Module):
24
  self.cls = nn.Parameter(torch.randn(1, 1, d) * 0.02)
25
  self.blocos = nn.ModuleList([Bloco(d, n_cabecas, d_ff, raio_janela=8)
26
  for _ in range(n_camadas)])
 
 
27
  self.norm = RMSNorm(d)
28
  self.saida = nn.Linear(d, d_saida)
29
 
@@ -35,4 +38,5 @@ class CodificadorImagem(nn.Module):
35
  x = torch.cat([cls, x], dim=1) + self.pos[:, : x.shape[1] + 1]
36
  for bloco in self.blocos:
37
  x, _, _ = bloco(x)
 
38
  return self.saida(self.norm(x[:, 0])) # [CLS]
 
9
  import torch.nn as nn
10
 
11
  from aurora.percepcao.blocos import Bloco, RMSNorm
12
+ from aurora.percepcao.microunidades import BiGRUNaoCausal
13
 
14
 
15
  class CodificadorImagem(nn.Module):
 
25
  self.cls = nn.Parameter(torch.randn(1, 1, d) * 0.02)
26
  self.blocos = nn.ModuleList([Bloco(d, n_cabecas, d_ff, raio_janela=8)
27
  for _ in range(n_camadas)])
28
+ # v3 (doc 11 §12): CNN-BiGRU — lane isolada pós-ViT (Teorema 11.3)
29
+ self.bigru = BiGRUNaoCausal(d)
30
  self.norm = RMSNorm(d)
31
  self.saida = nn.Linear(d, d_saida)
32
 
 
38
  x = torch.cat([cls, x], dim=1) + self.pos[:, : x.shape[1] + 1]
39
  for bloco in self.blocos:
40
  x, _, _ = bloco(x)
41
+ x = x + self.bigru(x) # contexto BiGRU sobre a sequência de patches
42
  return self.saida(self.norm(x[:, 0])) # [CLS]
src/aurora/percepcao/microunidades.py ADDED
@@ -0,0 +1,443 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Microunidades especializadas escaláveis (v3, doc 11 §§0–5) — item (a) do
3
+ escopo ampliado: composição Transformers + CNN‑BiGRU + BiGRU com unidades
4
+ que CRESCEM conforme a necessidade, em quatro topologias:
5
+
6
+ SERIAL y = x + Σ γ_k u_k(x_k) (Teorema 11.1 — gradiente em
7
+ [1−ΣγL, 1+ΣγL])
8
+ PARALELA y = x + Σ α_k(x) u_k(x), α convexo (Teorema 11.2 — Lip ≤ 1+max L)
9
+ ISOLADA ramos sem parâmetros/gradiente (Teorema 11.3 — Var[ĝ]=σ²(ρ+(1−ρ)/K))
10
+ compartilhados (encoders por modalidade)
11
+ RECURSIVA y ← y + γ^k u(y), k ≤ k_max (Teorema 11.4 — séries geométricas,
12
+ corte ε_stop)
13
+
14
+ Correções documentadas do código estudado (doc 11 §11): rotação de Cayley
15
+ EXATAMENTE ortogonal (§11.7), Hutchinson da diagonal correto (§11.1), LPT
16
+ 4/3‑aprox para o agendamento dos ramos (Proposição 11.3, Graham 1969).
17
+
18
+ COMPETÊNCIAS: conv (CNN), rec (GRU/BiGRU), att (atenção — nos blocos),
19
+ rot (Cayley), mlp (SwiGLU). CAUSALIDADE preservada no decodificador:
20
+ conv com preenchimento à esquerda e GRU UNIDIRECIONAL; BiGRU (bidirecional)
21
+ só em contextos NÃO causais (encoders multimodais — ramos isolados).
22
+ """
23
+ from __future__ import annotations
24
+
25
+ import heapq
26
+ import math
27
+ from collections import deque
28
+
29
+ import torch
30
+ import torch.nn as nn
31
+ import torch.nn.functional as F
32
+
33
+ # ---------------------------------------------------------------------------
34
+ # 1. Microunidades por competência
35
+ # ---------------------------------------------------------------------------
36
+
37
+
38
+ class ConvCausal(nn.Module):
39
+ """Conv1d causal (preenchimento à esquerda — posição t só vê ≤ t)."""
40
+
41
+ def __init__(self, d: int, kernel: int = 3, dilatacao: int = 1, grupos: int = 4):
42
+ super().__init__()
43
+ assert d % grupos == 0, "d deve ser divisível por grupos"
44
+ self.pad = (kernel - 1) * dilatacao
45
+ self.conv = nn.Conv1d(d, d, kernel, dilation=dilatacao, groups=grupos)
46
+ self.ponto = nn.Linear(d, d) # mistura entre grupos
47
+
48
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
49
+ y = x.transpose(1, 2) # (B,d,T)
50
+ y = F.pad(y, (self.pad, 0))
51
+ y = self.conv(y).transpose(1, 2) # (B,T,d)
52
+ return self.ponto(y)
53
+
54
+
55
+ class GRUCausal(nn.Module):
56
+ """GRU unidirecional compacto + projeção (causal por construção: estado em
57
+ t depende só de x_≤t). Composição CNN‑BiGRU nos ENCODERS usa a variante
58
+ bidirecional `BiGRUNaoCausal` (contextos não causais)."""
59
+
60
+ def __init__(self, d: int, d_oculto: int = 96):
61
+ super().__init__()
62
+ self.gru = nn.GRU(d, d_oculto, batch_first=True)
63
+ self.proj = nn.Linear(d_oculto, d)
64
+
65
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
66
+ y, _ = self.gru(x)
67
+ return self.proj(y)
68
+
69
+
70
+ class BiGRUNaoCausal(nn.Module):
71
+ """BiGRU (bidirecional) para ENCODERS — lanes isoladas (Teorema 11.3):
72
+ sem parâmetros compartilhados com o decodificador; interação apenas na
73
+ fusão. Parametrização: 2 direções × d/2 → concat → proj."""
74
+
75
+ def __init__(self, d: int, d_oculto: int | None = None):
76
+ super().__init__()
77
+ d_oculto = d_oculto or d // 2
78
+ self.gru = nn.GRU(d, d_oculto, batch_first=True, bidirectional=True)
79
+ self.proj = nn.Linear(2 * d_oculto, d)
80
+
81
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
82
+ y, _ = self.gru(x)
83
+ return self.proj(y)
84
+
85
+
86
+ class RotacaoCayley(nn.Module):
87
+ """Rotação EXATAMENTE ortogonal (correção do defect 7 do estudo):
88
+ R = (I−A)(I+A)^{−1} com A anti‑simétrica ⇒ R ∈ SO(n) para QUALQUER θ
89
+ (sem truncamento de série). Custo O(n³) — só em unidades pequenas."""
90
+
91
+ def __init__(self, n: int, init: float = 0.01):
92
+ super().__init__()
93
+ self.n = n
94
+ self.theta = nn.Parameter(torch.randn(n * (n - 1) // 2) * init)
95
+ idx = torch.triu_indices(n, n, offset=1)
96
+ self.register_buffer("lin", idx[0])
97
+ self.register_buffer("col", idx[1])
98
+ self.register_buffer("olho", torch.eye(n))
99
+
100
+ def matriz(self) -> torch.Tensor:
101
+ A = torch.zeros(self.n, self.n, dtype=self.theta.dtype,
102
+ device=self.theta.device)
103
+ A[self.lin, self.col] = self.theta
104
+ A = A - A.t() # anti-simétrica exata
105
+ return torch.linalg.solve(self.olho + A, self.olho - A) # Cayley
106
+
107
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
108
+ R = self.matriz().to(x.dtype)
109
+ return x @ R
110
+
111
+
112
+ class MLPMicra(nn.Module):
113
+ """SwiGLU compacto (microunidade mlp)."""
114
+
115
+ def __init__(self, d: int, d_ff: int):
116
+ super().__init__()
117
+ self.w_gate = nn.Linear(d, d_ff, bias=False)
118
+ self.w_up = nn.Linear(d, d_ff, bias=False)
119
+ self.w_down = nn.Linear(d_ff, d, bias=False)
120
+
121
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
122
+ return self.w_down(F.silu(self.w_gate(x)) * self.w_up(x))
123
+
124
+
125
+ # ---------------------------------------------------------------------------
126
+ # 2. Composição (FFN do bloco v3): stem SERIAL → ramos PARALELOS → RECURSIVA
127
+ # ---------------------------------------------------------------------------
128
+
129
+
130
+ class ComposicaoMicroUnidades(nn.Module):
131
+ """Substitui o FFN/MoE plano do bloco (doc 11 §12):
132
+
133
+ stem: h1 = x + conv_causal(LN(x)); h2 = h1 + gru_fwd(LN(h1)) [serial]
134
+ ramos: {conv_dilatada, gru_fwd2, mlp, moe?} sobre h2, gating
135
+ convexo com temperatura pela confiança h_t [paralelo]
136
+ refino: y ← y + γ^k u_rec(y), k ≤ k_max, corte ‖Δ‖ ≤ ε_stop [recursiva]
137
+
138
+ A MoE agrupável vira UM ramo (foco de tarefa preservado, doc 10 §1);
139
+ o gating PWHG dá bônus de exploração a ramos pouco usados (doc 11 §8).
140
+ """
141
+
142
+ def __init__(self, d: int, cfg: dict, moe=None):
143
+ super().__init__()
144
+ cfg = dict(cfg or {})
145
+ self.d = d
146
+ self.moe = moe
147
+ d_stem = int(cfg.get("d_gru", 96))
148
+ self.norm_stem = nn.ModuleList([nn.LayerNorm(d), nn.LayerNorm(d)])
149
+ self.stem = nn.ModuleList([
150
+ ConvCausal(d, kernel=int(cfg.get("kernel1", 3))),
151
+ GRUCausal(d, d_stem),
152
+ ])
153
+ self.gamma_stem = 1.0 / math.sqrt(2.0) # Corolário 11.2 (γ=1/√n)
154
+ # ramos paralelos (n dinâmico — gestor de crescimento)
155
+ d_ramo = int(cfg.get("d_ramo", 96))
156
+ self.ramos = nn.ModuleList([
157
+ ConvCausal(d, kernel=int(cfg.get("kernel2", 5)), dilatacao=2),
158
+ GRUCausal(d, d_stem),
159
+ MLPMicra(d, d_ramo),
160
+ ])
161
+ self.nome_ramos = ["conv_dil", "gru", "mlp"]
162
+ if moe is not None:
163
+ self.nome_ramos.append("moe")
164
+ self.ramo_ativo = nn.Parameter(torch.ones(len(self.nome_ramos)),
165
+ requires_grad=False)
166
+ self.gate = nn.Sequential(nn.Linear(d, d // 2), nn.SiLU(),
167
+ nn.Linear(d // 2, len(self.nome_ramos)))
168
+ self.refino = MLPMicra(d, int(cfg.get("d_refino", 128)))
169
+ self.gamma_rec = float(cfg.get("gamma_rec", 0.5))
170
+ self.k_rec_max = int(cfg.get("k_rec_max", 2))
171
+ self.eps_stop = float(cfg.get("eps_stop", 1e-2))
172
+ self.tau0 = float(cfg.get("tau0", 0.8))
173
+ self.kappa_conf = float(cfg.get("kappa_conf", 1.0))
174
+ self.delta_explora = float(cfg.get("delta_explora", 0.15))
175
+ # telemetria
176
+ self.uso_ema: torch.Tensor | None = None
177
+ self.ultimo_alpha: torch.Tensor | None = None
178
+ self.ultimo_passos_rec = 0
179
+ self._confianca = 0.5 # definido pelo modelo (h_t)
180
+ self._custo_ramos = [3.0, 4.0, 2.0] + ([6.0] if moe is not None else [])
181
+
182
+ # ---------------- utilidades ----------------
183
+ def registrar_confianca(self, h_t: float):
184
+ self._confianca = float(min(max(h_t, 0.0), 1.0))
185
+
186
+ def custo_lpt(self) -> list[float]:
187
+ """Custo estimado por ramo (FLOPs relativos) — LPT (Prop. 11.3)."""
188
+ return list(self._custo_ramos)
189
+
190
+ # ---------------- forward ----------------
191
+ def forward(self, x: torch.Tensor, tarefa: str | None = None) -> torch.Tensor:
192
+ B, T, d = x.shape
193
+ # stem serial (Teorema 11.1)
194
+ h = x
195
+ for i, u in enumerate(self.stem):
196
+ h = h + self.gamma_stem * u(self.norm_stem[i](h))
197
+ # ramos paralelos ativos
198
+ ativos = [k for k in range(len(self.nome_ramos))
199
+ if float(self.ramo_ativo[k]) > 0.5]
200
+ saidas = []
201
+ for k in ativos:
202
+ nome = self.nome_ramos[k]
203
+ if nome == "moe":
204
+ saidas.append(self.moe(h, tarefa=tarefa))
205
+ elif nome == "conv_dil":
206
+ saidas.append(self.ramos[0](h))
207
+ elif nome == "gru":
208
+ saidas.append(self.ramos[1](h))
209
+ else:
210
+ saidas.append(self.ramos[2](h))
211
+ # gating convexo com temperatura pela confiança (Teorema 11.2 + §8)
212
+ # CAUSAL: média acumulada até t (nenhuma posição vê o futuro — o
213
+ # roteamento por posição é inclusive mais fino que o por amostra)
214
+ cum = torch.cumsum(h, dim=1)
215
+ denom = torch.arange(1, T + 1, device=h.device, dtype=h.dtype).view(1, T, 1)
216
+ cmean = cum / denom
217
+ logits = self.gate(cmean) # (B, T, R)
218
+ tau = self.tau0 + self.kappa_conf * (1.0 - self._confianca)
219
+ if len(ativos) < len(self.nome_ramos): # poda: restringe colunas
220
+ logits = logits[:, :, ativos]
221
+ # bônus de exploração PWHG: ramos pouco usados recebem +δ·log(1/ū)
222
+ if self.uso_ema is not None:
223
+ uso_at = self.uso_ema[ativos] if self.uso_ema.numel() > max(ativos) \
224
+ else torch.ones(len(ativos))
225
+ bonus = self.delta_explora * torch.log(1.0 / (uso_at + 1e-3))
226
+ logits = logits + bonus.view(1, 1, -1)
227
+ # piso de temperatura: mantém o gradiente do gate vivo (anti-saturação)
228
+ tau = max(tau, 0.3)
229
+ alpha = torch.softmax(logits / max(tau, 0.05), dim=-1) # convexo (B,T,R)
230
+ y = sum(alpha[:, :, j].unsqueeze(-1) * saidas[j]
231
+ for j in range(len(ativos)))
232
+ self.ultimo_alpha = alpha.detach().mean(dim=(0, 1))
233
+ # v3 fix: BALANCEAMENTO DE CARGA do gate (análogo ao Teorema 10.2 —
234
+ # Switch-style R·Σ f_r·p_r): sem isto o gate colapsa num único ramo
235
+ # (softmax saturado ⇒ gradiente do gate some ⇒ rich-get-richer)
236
+ with torch.no_grad():
237
+ f_med = (alpha > 1.0 / len(ativos)).float().mean(dim=(0, 1))
238
+ p_med = alpha.mean(dim=(0, 1))
239
+ self.perla_balanceamento = len(ativos) * float((f_med * p_med).sum().detach())
240
+ self.perla_balanceamento_g = len(ativos) * (f_med * p_med).sum() # diferenciável
241
+ if self.training:
242
+ # estatística de uso atualiza SÓ em treino (como BatchNorm running
243
+ # stats) — em avaliação o forward é idempotente e causal
244
+ with torch.no_grad():
245
+ ema = alpha.detach().mean(dim=(0, 1)) # (R,)
246
+ if self.uso_ema is None or self.uso_ema.numel() != len(self.nome_ramos):
247
+ self.uso_ema = torch.zeros(len(self.nome_ramos))
248
+ base = torch.zeros(len(self.nome_ramos))
249
+ base[ativos] = ema
250
+ self.uso_ema = 0.95 * self.uso_ema + 0.05 * base.to(self.uso_ema.device)
251
+ # refino recursivo (Teorema 11.4) — corte CAUSAL: a decisão de parar
252
+ # usa SÓ a posição 0 (invariante ao comprimento) com a cauda geométrica
253
+ # Σ_{j≥k+1} γ^j‖u‖ ≤ ‖Δ_0‖·γ^{k+1}/(1−γ) ≤ ε_stop (Weierstrass M-test)
254
+ passos_rec = 0
255
+ for k in range(self.k_rec_max):
256
+ delta = (self.gamma_rec ** k) * self.refino(y)
257
+ y = y + delta
258
+ passos_rec = k + 1
259
+ if k == 0:
260
+ n0 = float(delta[:, 0].detach().norm())
261
+ if n0 * self.gamma_rec / (1.0 - self.gamma_rec) <= self.eps_stop:
262
+ break
263
+ self.ultimo_passos_rec = passos_rec
264
+ return y
265
+
266
+ # ---------------- crescimento ----------------
267
+ def expandir(self, tipo: str = "mlp", d: int | None = None) -> int:
268
+ """Adiciona um ramo (gestor de crescimento — Teorema 11.5): nova
269
+ unidade entra com peso de uso nulo e ganho residual preservando o
270
+ Corolário 11.2."""
271
+ d = d or self.d
272
+ if tipo == "conv":
273
+ unidade = ConvCausal(d, kernel=3, dilatacao=4)
274
+ nome, custo = "conv_dil4", 2.5
275
+ elif tipo == "rot":
276
+ unidade = nn.Sequential(RotacaoCayley(d), nn.Linear(d, d))
277
+ nome, custo = "rot", 2.0
278
+ else:
279
+ unidade = MLPMicra(d, max(d // 2, 48))
280
+ nome, custo = "mlp2", 2.0
281
+ self.ramos.append(unidade)
282
+ self.nome_ramos.append(nome)
283
+ self._custo_ramos.append(custo)
284
+ ativo = torch.ones(len(self.nome_ramos))
285
+ ativo[:-1] = self.ramo_ativo
286
+ self.ramo_ativo = nn.Parameter(ativo, requires_grad=False)
287
+ # gate cresce por 1 coluna (nova coluna começa em 0 — uso inicial nulo)
288
+ gate_antigo = self.gate
289
+ gate_novo = nn.Sequential(
290
+ nn.Linear(self.d, self.d // 2), nn.SiLU(),
291
+ nn.Linear(self.d // 2, len(self.nome_ramos)))
292
+ gate_novo[0].weight.data[:gate_antigo[0].weight.shape[0]] = \
293
+ gate_antigo[0].weight.data
294
+ gate_novo[0].bias.data = gate_antigo[0].bias.data
295
+ gate_novo[2].weight.data[:gate_antigo[2].weight.shape[0]] = \
296
+ gate_antigo[2].weight.data
297
+ gate_novo[2].bias.data[:gate_antigo[2].bias.shape[0]] = \
298
+ gate_antigo[2].bias.data
299
+ self.gate = gate_novo
300
+ self.uso_ema = torch.cat([self.uso_ema, torch.zeros(1)]) \
301
+ if self.uso_ema is not None else None
302
+ return len(self.nome_ramos) - 1
303
+
304
+ def podar(self, indice_ramo: int) -> bool:
305
+ """Desativa o ramo (continuidade: α→0 ⇒ função inalterada — doc 11
306
+ Teorema 11.5). O parâmetro permanece (state_dict estável)."""
307
+ if self.nome_ramos[indice_ramo] == "moe":
308
+ return False # MoE é a competência de tarefa — não poda
309
+ if len([k for k in range(len(self.nome_ramos))
310
+ if float(self.ramo_ativo[k]) > 0.5]) <= 1:
311
+ return False # mantém ≥ 1 ramo
312
+ self.ramo_ativo.data[indice_ramo] = 0.0
313
+ return True
314
+
315
+
316
+ # ---------------------------------------------------------------------------
317
+ # 3. Gestor de crescimento — Hutchinson (correção do defect 1) + LPT
318
+ # ---------------------------------------------------------------------------
319
+
320
+
321
+ class GestorCrescimento:
322
+ """Cresce/poda microunidades por curvatura e uso (doc 11 Teorema 11.5,
323
+ Lema 11.1 corrigido). Sonda: Hutchinson–Rademacher E[v⊙Hv] = diag(H)
324
+ sobre os parâmetros DOS COMPOSITORES apenas (custo ~2 backwards extra,
325
+ a cada N passos)."""
326
+
327
+ def __init__(self, compositores: list, cfg: dict, hub=None):
328
+ self.compositores = compositores
329
+ self.cfg = dict(cfg or {})
330
+ self.hub = hub
331
+ self.tau_expand = float(self.cfg.get("tau_expand", 0.10))
332
+ self.tau_prune = float(self.cfg.get("tau_prune", 0.01))
333
+ self.eps_gate = float(self.cfg.get("eps_gate", 0.05))
334
+ self.janela_uso = int(self.cfg.get("janela_uso", 8))
335
+ self.n_max_ramos = int(self.cfg.get("n_max_ramos", 5))
336
+ self.n_sondas = int(self.cfg.get("n_sondas", 2))
337
+ self.ultimo_evento: dict = {}
338
+ self._uso_baixo: dict[int, deque] = {id(c): deque(maxlen=self.janela_uso)
339
+ for c in compositores}
340
+ self.eventos: list[dict] = []
341
+
342
+ # ---- LPT (Proposição 11.3): ordem de execução dos ramos ----
343
+ @staticmethod
344
+ def ordem_lpt(custos: list[float], n_unidades: int = 2) -> tuple[list[int], float]:
345
+ """Retorna (ordem dos ramos, makespan estimado). LPT com min-heap:
346
+ makespan ≤ (4/3)·ÓTIMO (Graham 1969)."""
347
+ heap = [(0.0, u) for u in range(max(1, n_unidades))]
348
+ heapq.heapify(heap)
349
+ cargas = [0.0] * max(1, n_unidades)
350
+ ordem = []
351
+ for idx in sorted(range(len(custos)), key=lambda i: -custos[i]):
352
+ carga, u = heapq.heappop(heap)
353
+ cargas[u] += custos[idx]
354
+ ordem.append(idx)
355
+ heapq.heappush(heap, (cargas[u], u))
356
+ return ordem, max(cargas) if cargas else 0.0
357
+
358
+ # ---- Hutchinson–Rademacher da diagonal do Hessiano (Lema 11.1) ----
359
+ def _diag_hessiano(self, perda_fn) -> tuple[dict, float]:
360
+ """E[v⊙Hv] = diag(H) por PARÂMETRO (tensor). Média sobre n_sondas
361
+ sondas Rademacher reduz a variância por 1/n_sondas."""
362
+ compositores = [c for c in self.compositores if c.ramos]
363
+ if not compositores:
364
+ return {}, 0.0
365
+ params = [p for c in compositores for p in c.ramos.parameters()]
366
+ # proprietário (índice do compositor/ramo) de cada parâmetro
367
+ dono: list[tuple[int, int]] = []
368
+ for ci, c in enumerate(compositores):
369
+ for ri, u in enumerate(c.ramos):
370
+ for _ in u.parameters():
371
+ dono.append((ci, ri))
372
+ perda = perda_fn()
373
+ g = torch.autograd.grad(perda, params, create_graph=True,
374
+ allow_unused=True)
375
+ diag: dict[int, float] = {}
376
+ total = 0.0
377
+ for _ in range(max(1, self.n_sondas)):
378
+ vs = [torch.randn_like(p).sign() for p in params]
379
+ gv = sum((gi * vi).sum() for gi, vi in zip(g, vs)
380
+ if gi is not None)
381
+ if not isinstance(gv, torch.Tensor):
382
+ break
383
+ # retain_graph: o MESMO grafo de g serve às n_sondas sondas
384
+ hv = torch.autograd.grad(gv, params, allow_unused=True,
385
+ retain_graph=True)
386
+ for i, p in enumerate(params):
387
+ if hv[i] is None or g[i] is None:
388
+ continue
389
+ contrib = float((vs[i] * hv[i]).sum().item())
390
+ diag[i] = diag.get(i, 0.0) + contrib / max(1, self.n_sondas)
391
+ total += abs(contrib) / max(1, self.n_sondas)
392
+ # agrega por (compositor, ramo) — usado pela poda (Teorema 11.5)
393
+ por_ramo: dict[tuple[int, int], float] = {}
394
+ for i, valor in diag.items():
395
+ chave = dono[i]
396
+ por_ramo[chave] = por_ramo.get(chave, 0.0) + valor
397
+ # libera o grafo de segunda ordem (RAM: probe + PCGrad no mesmo processo)
398
+ del g, diag
399
+ import gc
400
+ gc.collect()
401
+ return por_ramo, total
402
+
403
+ def verificar(self, passo: int, perda_fn) -> dict:
404
+ """Expande (curvatura alta) / poda (uso baixo + curvatura baixa)."""
405
+ por_ramo, total = self._diag_hessiano(perda_fn)
406
+ resultado: dict = {"passo": passo, "curvatura_total": round(total, 6),
407
+ "acoes": []}
408
+ for ci, comp in enumerate(self.compositores):
409
+ uso = comp.uso_ema
410
+ if uso is None or uso.numel() < 2:
411
+ continue
412
+ uso_cpu = uso.detach().cpu()
413
+ ativos = [k for k in range(len(comp.nome_ramos))
414
+ if float(comp.ramo_ativo[k]) > 0.5
415
+ and comp.nome_ramos[k] != "moe"]
416
+ if not ativos:
417
+ continue
418
+ k_min = min(ativos, key=lambda k: float(uso_cpu[k]))
419
+ uso_min = float(uso_cpu[k_min])
420
+ self._uso_baixo[id(comp)].append(uso_min < self.eps_gate)
421
+ # curvatura (soma da diagonal) dos parâmetros do ramo k_min
422
+ curv_ramo = por_ramo.get((ci, k_min), 0.0)
423
+ if total > self.tau_expand and len(comp.nome_ramos) < self.n_max_ramos:
424
+ tipo = "conv" if (ci % 2 == 0) else "rot"
425
+ comp.expandir(tipo)
426
+ acao = f"expandir[{tipo}]"
427
+ elif (sum(self._uso_baixo[id(comp)]) >= self.janela_uso
428
+ and abs(curv_ramo) < self.tau_prune):
429
+ if comp.podar(k_min):
430
+ acao = f"podar[{comp.nome_ramos[k_min]}]"
431
+ else:
432
+ acao = "poda_bloqueada"
433
+ else:
434
+ acao = "manter"
435
+ resultado["acoes"].append({"compositor": ci, "acao": acao,
436
+ "uso_min": round(uso_min, 4),
437
+ "curvatura_ramo": round(curv_ramo, 6)})
438
+ if acao not in ("manter",) and self.hub is not None:
439
+ self.hub.atributo(f"crescimento/c{ci}_{acao}", 1.0, passo)
440
+ self.eventos.append({"passo": passo, "compositor": ci,
441
+ "acao": acao})
442
+ self.ultimo_evento = resultado
443
+ return resultado
src/aurora/percepcao/moe.py CHANGED
@@ -102,16 +102,20 @@ class MoEAgrupavel(nn.Module):
102
  """x: (B, T, d) → saída (B, T, d) + perdas auxiliares atualizadas."""
103
  B, T, d = x.shape
104
  x_flat = x.reshape(B * T, d)
105
- xbar = x.mean(dim=1) # (B, d) compactação
 
 
 
 
106
  # gate duplo (eq. 10.1): afinidade por âncora + viés de grupo-tarefa
107
  it = self.indice_grupo(tarefa)
108
- s = (xbar @ self.ancoras.T) / (self.d ** 0.5) # (B, N)
109
  # viés b_{g(e),τ}: cada expert recebe o viés do SEU grupo para τ
110
  vies_experts = self.vies_tarefa[:, it][self.grupo_de_idx] # (N,)
111
  s = s + vies_experts.unsqueeze(0)
112
  if self.fase_densa:
113
  # fase densa: softmax sobre TODOS os experts (máximo de conexões)
114
- g = torch.softmax(s, dim=-1) # (B, N)
115
  mask_ativos = torch.ones_like(g, dtype=torch.bool)
116
  else:
117
  # fase foco: top-k dentro do grupo de τ + extras elegíveis por margem
@@ -119,7 +123,7 @@ class MoEAgrupavel(nn.Module):
119
  fora = (self.grupo_de_idx != it).nonzero(as_tuple=True)[0]
120
  s_grupo = s[:, idx_grupo]
121
  k = min(self.top_k, idx_grupo.numel())
122
- topo_val, topo_idx = s_grupo.topk(k, dim=-1) # (B, k)
123
  corte = topo_val[:, -1:].detach() # s_(k)
124
  extras = fora[(s[:, fora] > corte - self.margem_foco).any(dim=0)] \
125
  if fora.numel() else fora
@@ -139,8 +143,7 @@ class MoEAgrupavel(nn.Module):
139
  if not bool(mask_ativos[:, e].any()):
140
  acts.append(torch.zeros(B * T, d, device=x.device, dtype=x.dtype))
141
  continue
142
- ge = g[:, e] # (B,)
143
- w = ge.repeat_interleave(T) # (B*T,) pesos por token
144
  y_e = self.especialistas[e](x_flat)
145
  y = y + w.unsqueeze(1) * y_e
146
  soma_at = soma_at + w.unsqueeze(1)
 
102
  """x: (B, T, d) → saída (B, T, d) + perdas auxiliares atualizadas."""
103
  B, T, d = x.shape
104
  x_flat = x.reshape(B * T, d)
105
+ # v3 (doc 11 §12): roteamento POR TOKEN e CAUSAL — cada posição é
106
+ # roteada pelo seu próprio estado (na decodificação T=1 é o estado
107
+ # corrente; no forward paralelo de treino NÃO vê o futuro). Isto
108
+ # substitui a compactação x̄ por amostra da v2, que vazava contexto
109
+ # futuro no roteamento das posições passadas.
110
  # gate duplo (eq. 10.1): afinidade por âncora + viés de grupo-tarefa
111
  it = self.indice_grupo(tarefa)
112
+ s = (x_flat @ self.ancoras.T) / (self.d ** 0.5) # (B*T, N)
113
  # viés b_{g(e),τ}: cada expert recebe o viés do SEU grupo para τ
114
  vies_experts = self.vies_tarefa[:, it][self.grupo_de_idx] # (N,)
115
  s = s + vies_experts.unsqueeze(0)
116
  if self.fase_densa:
117
  # fase densa: softmax sobre TODOS os experts (máximo de conexões)
118
+ g = torch.softmax(s, dim=-1) # (B*T, N)
119
  mask_ativos = torch.ones_like(g, dtype=torch.bool)
120
  else:
121
  # fase foco: top-k dentro do grupo de τ + extras elegíveis por margem
 
123
  fora = (self.grupo_de_idx != it).nonzero(as_tuple=True)[0]
124
  s_grupo = s[:, idx_grupo]
125
  k = min(self.top_k, idx_grupo.numel())
126
+ topo_val, topo_idx = s_grupo.topk(k, dim=-1) # (B*T, k)
127
  corte = topo_val[:, -1:].detach() # s_(k)
128
  extras = fora[(s[:, fora] > corte - self.margem_foco).any(dim=0)] \
129
  if fora.numel() else fora
 
143
  if not bool(mask_ativos[:, e].any()):
144
  acts.append(torch.zeros(B * T, d, device=x.device, dtype=x.dtype))
145
  continue
146
+ w = g[:, e] # (B*T,) por token
 
147
  y_e = self.especialistas[e](x_flat)
148
  y = y + w.unsqueeze(1) * y_e
149
  soma_at = soma_at + w.unsqueeze(1)
src/aurora/raciocinio/ciclo.py CHANGED
@@ -29,12 +29,17 @@ class Traco:
29
 
30
 
31
  class CicloPDCA:
32
- def __init__(self, modelo, tokenizador, hub_ferramentas, cfg, hub=None):
 
33
  self.modelo = modelo
34
  self.tk = tokenizador
35
  self.tools = hub_ferramentas
36
  self.cfg = cfg
37
  self.hub = hub
 
 
 
 
38
 
39
  # ---------------- estimativa de confiança ----------------
40
  @torch.no_grad()
@@ -56,6 +61,17 @@ class CicloPDCA:
56
  plano = {"tarefa": tarefa, "acao": "modelo_gera"}
57
  if PADRAO_ARITMETICA.match(entrada):
58
  plano["acao"] = "ferramenta_calculadora"
 
 
 
 
 
 
 
 
 
 
 
59
  traco.registrar("planejar", plano)
60
  return plano
61
 
@@ -85,13 +101,26 @@ class CicloPDCA:
85
 
86
  def feedback(self, p: float, entropia_gate: float, traco: Traco) -> str:
87
  cfg = self.cfg.ciclo
88
- if p >= cfg.tau_escalada and entropia_gate <= cfg.entropia_limite:
 
 
 
 
 
 
 
 
 
 
 
 
89
  decisao = "entregar"
90
- elif p < cfg.tau_escalada and entropia_gate > cfg.entropia_limite:
91
  decisao = "escalar_humano"
92
  else:
93
  decisao = "redistribuir"
94
- traco.registrar("feedback", {"p": round(p, 3), "decisao": decisao})
 
95
  if self.hub is not None:
96
  self.hub.atributo("ciclo/confianca", p)
97
  return decisao
 
29
 
30
 
31
  class CicloPDCA:
32
+ def __init__(self, modelo, tokenizador, hub_ferramentas, cfg, hub=None,
33
+ memoria=None, agente_confianca=None):
34
  self.modelo = modelo
35
  self.tk = tokenizador
36
  self.tools = hub_ferramentas
37
  self.cfg = cfg
38
  self.hub = hub
39
+ # v3 (doc 11 §9/§10): divisão de competências — o ciclo SÓ CONSULTA a
40
+ # memória (nunca escreve) e recebe a cota PAC‑Bayes do AgenteConfiança
41
+ self.memoria = memoria
42
+ self.agente = agente_confianca
43
 
44
  # ---------------- estimativa de confiança ----------------
45
  @torch.no_grad()
 
61
  plano = {"tarefa": tarefa, "acao": "modelo_gera"}
62
  if PADRAO_ARITMETICA.match(entrada):
63
  plano["acao"] = "ferramenta_calculadora"
64
+ # v3: consulta à memória interna (contrato: raciocinio lê, nunca escreve)
65
+ if self.memoria is not None:
66
+ try:
67
+ ids = torch.tensor([self.tk.encode(entrada, tarefa=tarefa,
68
+ max_len=64)])
69
+ q = self.modelo.contexto(ids).mean(dim=0)
70
+ rec = self.memoria.consultar(q, m=2, origem="raciocinio")
71
+ plano["memoria_hits"] = len(rec["indices"])
72
+ plano["memoria_scores"] = [round(s, 3) for s in rec["scores"]]
73
+ except Exception as e:
74
+ plano["memoria_hits"] = -1 # degradação graciosa, nunca bloqueia
75
  traco.registrar("planejar", plano)
76
  return plano
77
 
 
101
 
102
  def feedback(self, p: float, entropia_gate: float, traco: Traco) -> str:
103
  cfg = self.cfg.ciclo
104
+ # v3 (Teorema 11.8/11.9): a cota PAC‑Bayes do AgenteConfiança endossa a
105
+ # entrega automática — sem endosso, exige confiança maior do modelo
106
+ endosso = True
107
+ if self.agente is not None:
108
+ try:
109
+ n = max(self.agente.posterior.n, 1)
110
+ cota = self.agente.posterior.pac_bayes(min(p, 1.0), n=n)
111
+ endosso = cota <= 0.9
112
+ traco.registrar("feedback", {"pac_bayes": round(cota, 3)})
113
+ except Exception:
114
+ endosso = True
115
+ tau_efetiva = cfg.tau_escalada + (0.0 if endosso else 0.1)
116
+ if p >= tau_efetiva and entropia_gate <= cfg.entropia_limite:
117
  decisao = "entregar"
118
+ elif p < tau_efetiva and entropia_gate > cfg.entropia_limite:
119
  decisao = "escalar_humano"
120
  else:
121
  decisao = "redistribuir"
122
+ traco.registrar("feedback", {"p": round(p, 3), "decisao": decisao,
123
+ "endosso_pac_bayes": endosso})
124
  if self.hub is not None:
125
  self.hub.atributo("ciclo/confianca", p)
126
  return decisao
src/aurora/telemetria/hub.py CHANGED
@@ -56,6 +56,7 @@ class TelemetryHub:
56
  self._ema: dict[str, float] = {}
57
  self._historico: dict[str, list[float]] = {}
58
  self._anterior_theta: dict[str, torch.Tensor] | None = None
 
59
  self._inicio = time.time()
60
 
61
  # ---------------- coleta ----------------
@@ -85,7 +86,9 @@ class TelemetryHub:
85
  delta = float(torch.norm(d)) / (norma + 1e-12)
86
  # guarda referência em CPU (RAM otimizada: fp32 → se >2GB usar fp16)
87
  self._anterior_theta = self._anterior_theta or {}
88
- self._anterior_theta[nome] = p.detach().flatten().cpu().clone()
 
 
89
  total_delta += delta ** 2
90
  total_norma += norma ** 2
91
  por_camada[nome] = round(delta, 6)
 
56
  self._ema: dict[str, float] = {}
57
  self._historico: dict[str, list[float]] = {}
58
  self._anterior_theta: dict[str, torch.Tensor] | None = None
59
+ self.eventos_guard: list[str] = []
60
  self._inicio = time.time()
61
 
62
  # ---------------- coleta ----------------
 
86
  delta = float(torch.norm(d)) / (norma + 1e-12)
87
  # guarda referência em CPU (RAM otimizada: fp32 → se >2GB usar fp16)
88
  self._anterior_theta = self._anterior_theta or {}
89
+ # v3.1: amostra ≤ 24 camadas (RAM) — delta_global usa todas
90
+ if len(self._anterior_theta) < 24 or nome in self._anterior_theta:
91
+ self._anterior_theta[nome] = p.detach().flatten().cpu().clone()
92
  total_delta += delta ** 2
93
  total_norma += norma ** 2
94
  por_camada[nome] = round(delta, 6)
src/aurora/treino/confianca.py ADDED
@@ -0,0 +1,169 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """AgenteConfiança (v3, doc 11 §8): confiança h_t ∈ [0,1] com garantias
3
+ finitas — posterior Beta(α,β) sobre θ*"o modelo está certo" com cotas de
4
+ Bernstein (Teorema 11.8) e PAC‑Bayes (Teorema 11.9 do ciclo/PDCA), fundida
5
+ com features neurais (entropia dos logits, max‑prob, variância, Δperda) e
6
+ pesos assimétricos κ_p > κ_r (punição pesa mais que prêmio — TAPR).
7
+
8
+ Saídas consumidas por:
9
+ • ComposicaoMicroUnidades.registrar_confianca(h_t) — temperatura do gating
10
+ (menor confiança ⇒ softmax mais plano ⇒ mais exploração entre ramos);
11
+ • MTP adaptativo (doc 11 Teorema 11.6): máscara por posição via confiança
12
+ posicional 1 − H(p_t)/log V (monótona, calibrável);
13
+ • MemoriaInterna.escrever(·, h_t) — escrita conficiente;
14
+ • CicloPDCA — limiar bayesiano recebe a cota PAC‑Bayes.
15
+ """
16
+ from __future__ import annotations
17
+
18
+ import math
19
+ from collections import deque
20
+
21
+ import torch
22
+ import torch.nn as nn
23
+ import torch.nn.functional as F
24
+
25
+
26
+ class PosteriorBeta:
27
+ """Beta‑Bernoulli com atualização por batch e cotas não-assintóticas."""
28
+
29
+ def __init__(self, alpha0: float = 1.0, beta0: float = 1.0):
30
+ self.a, self.b = alpha0, beta0
31
+ self.a0, self.b0 = alpha0, beta0
32
+ self.n = 0
33
+
34
+ def atualizar(self, acertos: int, erros: int):
35
+ self.a += acertos
36
+ self.b += erros
37
+ self.n += acertos + erros
38
+
39
+ @property
40
+ def media(self) -> float:
41
+ return self.a / (self.a + self.b)
42
+
43
+ @property
44
+ def variancia(self) -> float:
45
+ s = self.a + self.b
46
+ return self.a * self.b / (s * s * (s + 1.0))
47
+
48
+ def bernstein(self, delta: float = 0.05) -> tuple[float, float]:
49
+ """|μ̂ − θ*| ≤ √(2σ²ln(2/δ)) + (2/3)ln(2/δ)/(α+β) com prob ≥ 1−δ."""
50
+ log_t = math.log(2.0 / delta)
51
+ eps = math.sqrt(2.0 * self.variancia * log_t) \
52
+ + (2.0 / 3.0) * log_t / max(self.a + self.b, 1e-9)
53
+ mu = self.media
54
+ return max(0.0, mu - eps), min(1.0, mu + eps)
55
+
56
+ def pac_bayes(self, perda_emp: float, n: int, delta: float = 0.05,
57
+ kl_prior: float = 0.0) -> float:
58
+ """E_post[L] ≤ L_emp + √((KL + ln(2√n/δ))/(2n)) — cota do risco do gate."""
59
+ n = max(int(n), 1)
60
+ log_t = math.log(2.0 * math.sqrt(n) / delta)
61
+ return perda_emp + math.sqrt((kl_prior + log_t) / (2.0 * n))
62
+
63
+
64
+ class AgenteConfianca(nn.Module):
65
+ """h_t = clip(½·μ̂_Beta + ½·h_neural, 0, 1) com κ assimétrico."""
66
+
67
+ def __init__(self, n_features: int = 4, oculto: int = 32,
68
+ kappa_punicao: float = 0.3, kappa_premio: float = 0.1,
69
+ janela_tau: int = 50, quantil_tau: float = 0.25):
70
+ super().__init__()
71
+ self.mlp = nn.Sequential(nn.Linear(n_features, oculto), nn.SiLU(),
72
+ nn.Linear(oculto, 1))
73
+ self.kappa_p = kappa_punicao
74
+ self.kappa_r = kappa_premio
75
+ self.posterior = PosteriorBeta()
76
+ self.janela_perdas: deque = deque(maxlen=janela_tau)
77
+ self.quantil_tau = quantil_tau
78
+ self.tau: float | None = None
79
+ self.ultima_perda: float | None = None
80
+ self.calibracao: dict[int, list[int]] = {} # faixa h → [acertos, total]
81
+ self.ultimo_h: float = 0.5
82
+
83
+ # ---------------- τ adaptativo (quantil EMA) ----------------
84
+ def _atualizar_tau(self, perda: float) -> float:
85
+ self.janela_perdas.append(perda)
86
+ janela = sorted(self.janela_perdas)
87
+ pos = self.quantil_tau * (len(janela) - 1)
88
+ lo = int(pos)
89
+ hi = min(lo + 1, len(janela) - 1)
90
+ q = janela[lo] * (1 - (pos - lo)) + janela[hi] * (pos - lo)
91
+ self.tau = q if self.tau is None else max(1e-6, 0.95 * self.tau + 0.05 * q)
92
+ return self.tau
93
+
94
+ # ---------------- features e h ----------------
95
+ @staticmethod
96
+ def features_logits(logits: torch.Tensor) -> torch.Tensor:
97
+ """logits (B,T,V) → features médias (4,): entropia, max‑prob, variância."""
98
+ with torch.no_grad():
99
+ p = torch.softmax(logits.float(), dim=-1)
100
+ H = -(p * (p + 1e-9).log()).sum(-1).mean()
101
+ mp = p.max(-1).values.mean()
102
+ var = logits.float().var()
103
+ return torch.tensor([float(H), float(mp), float(var), 0.0])
104
+
105
+ def forward(self, feats: torch.Tensor, perda_atual: float | None = None) -> torch.Tensor:
106
+ """feats (4,) → h_t escalar (tensor)."""
107
+ if perda_atual is not None:
108
+ delta = 0.0 if self.ultima_perda is None \
109
+ else perda_atual - self.ultima_perda
110
+ feats = feats.clone()
111
+ feats[3] = max(min(delta, 5.0), -5.0)
112
+ self.ultima_perda = perda_atual
113
+ self._atualizar_tau(perda_atual)
114
+ h_raw = torch.sigmoid(self.mlp(feats.unsqueeze(0)))[0, 0]
115
+ # ajuste assimétrico: Δperda > 0 (pior) pune com κ_p; < 0 premia com κ_r
116
+ delta = float(feats[3])
117
+ if delta > 0:
118
+ ajuste = -self.kappa_p * delta * (1.0 + abs(delta))
119
+ else:
120
+ ajuste = self.kappa_r * abs(delta)
121
+ h_neural = torch.clamp(h_raw + ajuste, 0.0, 1.0)
122
+ mu = self.posterior.media
123
+ h = float(torch.clamp(0.5 * mu + 0.5 * h_neural.detach(), 0.0, 1.0))
124
+ self.ultimo_h = h
125
+ return torch.tensor(h)
126
+
127
+ # ---------------- acerto/erro (posterior + calibração) ----------------
128
+ def registrar_resultado(self, perda: float, h: float | None = None):
129
+ """hit = perda < τ (quantil adaptativo). Atualiza posterior e ECE."""
130
+ if self.tau is None:
131
+ return
132
+ hit = perda < self.tau
133
+ self.posterior.atualizar(int(hit), int(not hit))
134
+ h = self.ultimo_h if h is None else h
135
+ faixa = min(int(h * 10), 9)
136
+ caixa = self.calibracao.setdefault(faixa, [0, 0])
137
+ caixa[0] += int(hit)
138
+ caixa[1] += 1
139
+ return hit
140
+
141
+ def ece(self) -> float:
142
+ """Erro de calibração esperado (10 faixas) — monotonicidade do Teo 11.6."""
143
+ n = sum(t for _, t in self.calibracao.values())
144
+ if n == 0:
145
+ return 0.0
146
+ e = 0.0
147
+ for faixa, (acertos, total) in self.calibracao.items():
148
+ conf_media = (faixa + 0.5) / 10.0
149
+ e += (total / n) * abs(acertos / total - conf_media)
150
+ return e
151
+
152
+ # ---------------- MTP adaptativo (Teorema 11.6) ----------------
153
+ @staticmethod
154
+ def confianca_posicional(logits: torch.Tensor) -> torch.Tensor:
155
+ """logits (B,T,V) → h_pos (B,T) = 1 − H(p_t)/log V ∈ [0,1] — proxy
156
+ monotônico de confiança por posição (calibrável pelo ECE global)."""
157
+ with torch.no_grad():
158
+ p = torch.softmax(logits.float(), dim=-1)
159
+ H = -(p * (p + 1e-9).log()).sum(-1)
160
+ return (1.0 - H / math.log(p.shape[-1])).clamp(0.0, 1.0)
161
+
162
+
163
+ def mascara_k_adaptativa(h_pos: torch.Tensor, k_min: int, k_max: int) -> torch.Tensor:
164
+ """h_pos (B,T) → máscara (B,T,K_max) com 1[k < K_t],
165
+ K_t = clamp(round(K_min + (K_max−K_min)·h), K_min, K_max)."""
166
+ k_cont = k_min + (k_max - k_min) * h_pos
167
+ k_t = torch.round(k_cont).long().clamp(k_min, k_max)
168
+ ks = torch.arange(k_max, device=h_pos.device).view(1, 1, k_max)
169
+ return (ks < k_t.unsqueeze(-1)).float()
src/aurora/treino/mtp.py CHANGED
@@ -32,13 +32,20 @@ class MTPAurora(nn.Module):
32
  return torch.softmax(self.log_alphas, dim=-1)
33
 
34
  def perda(self, h: torch.Tensor, peso_emb: torch.Tensor, alvo: torch.Tensor,
35
- ignore_index: int = -100) -> torch.Tensor:
 
36
  """h: (B,T,d) estado oculto real; peso_emb: (V,d) tabela empatada;
37
- alvo: (B,T) rótulos LM com -100."""
 
 
 
 
 
38
  B, T, d = h.shape
39
  alphas = self.alphas()
40
  total = h.new_zeros(())
41
  per_cabeca = []
 
42
  for m in range(self.k):
43
  desloc = m + 1
44
  if T - desloc <= 0:
@@ -47,15 +54,30 @@ class MTPAurora(nn.Module):
47
  hm = F.silu(self.w[m](h[:, :T - desloc])) # (B, T-m, d)
48
  logits = F.linear(hm, peso_emb) # (B, T-m, V)
49
  tgt = alvo[:, desloc:] # (B, T-m)
50
- ce = F.cross_entropy(logits.reshape(-1, logits.shape[-1]),
51
- tgt.reshape(-1), ignore_index=ignore_index)
52
- per_cabeca.append(float(ce.detach()))
53
- total = total + alphas[m] * ce
 
 
 
 
 
 
 
 
 
 
 
 
 
 
54
  if all(isinstance(p, float) and p != p for p in per_cabeca):
55
  return h.new_zeros(()) # sequências curtas
56
  # regularizador de entropia (Teorema 10.8): maximiza H(α)
57
  H = -(alphas * torch.log(alphas + 1e-8)).sum()
58
  total = total - self.beta * H
59
  self.ultimos = {"alphas": [float(a) for a in alphas.detach()],
60
- "per_cabeca": per_cabeca, "entropia": float(H.detach())}
 
61
  return total
 
32
  return torch.softmax(self.log_alphas, dim=-1)
33
 
34
  def perda(self, h: torch.Tensor, peso_emb: torch.Tensor, alvo: torch.Tensor,
35
+ ignore_index: int = -100,
36
+ h_conf: torch.Tensor | None = None) -> torch.Tensor:
37
  """h: (B,T,d) estado oculto real; peso_emb: (V,d) tabela empatada;
38
+ alvo: (B,T) rótulos LM com -100.
39
+
40
+ v3 (doc 11 Teorema 11.6): se `h_conf` (B,T) ∈ [0,1] é fornecido, a
41
+ perda usa MÁSCARA DE K ADAPTATIVO — a posição t só contribui para as
42
+ cabeças m < K_t = clamp(round(K_min + (K_max−K_min)·h_t), K_min, K).
43
+ Economia esperada ≈ K_max·E[h] + K_min·(1−E[h]) termos de CE."""
44
  B, T, d = h.shape
45
  alphas = self.alphas()
46
  total = h.new_zeros(())
47
  per_cabeca = []
48
+ soma_mask = 0.0
49
  for m in range(self.k):
50
  desloc = m + 1
51
  if T - desloc <= 0:
 
54
  hm = F.silu(self.w[m](h[:, :T - desloc])) # (B, T-m, d)
55
  logits = F.linear(hm, peso_emb) # (B, T-m, V)
56
  tgt = alvo[:, desloc:] # (B, T-m)
57
+ if h_conf is not None:
58
+ # máscara K adaptativa por posição (K_t ≥ 1 ⇒ cabeça 0 sempre on)
59
+ k_min = 1
60
+ k_cont = k_min + (self.k - k_min) * h_conf[:, :T - desloc]
61
+ k_t = torch.round(k_cont).long().clamp(k_min, self.k)
62
+ mask_m = (k_t > m).float() # (B, T-m)
63
+ ce_elem = F.cross_entropy(
64
+ logits.reshape(-1, logits.shape[-1]), tgt.reshape(-1),
65
+ ignore_index=ignore_index, reduction="none")
66
+ valid = (tgt.reshape(-1) != ignore_index).float() \
67
+ * mask_m.reshape(-1)
68
+ soma = (ce_elem * valid).sum() / valid.sum().clamp(min=1.0)
69
+ soma_mask += float(valid.sum())
70
+ else:
71
+ soma = F.cross_entropy(logits.reshape(-1, logits.shape[-1]),
72
+ tgt.reshape(-1), ignore_index=ignore_index)
73
+ per_cabeca.append(float(soma.detach()))
74
+ total = total + alphas[m] * soma
75
  if all(isinstance(p, float) and p != p for p in per_cabeca):
76
  return h.new_zeros(()) # sequências curtas
77
  # regularizador de entropia (Teorema 10.8): maximiza H(α)
78
  H = -(alphas * torch.log(alphas + 1e-8)).sum()
79
  total = total - self.beta * H
80
  self.ultimos = {"alphas": [float(a) for a in alphas.detach()],
81
+ "per_cabeca": per_cabeca, "entropia": float(H.detach()),
82
+ "termos_ce": soma_mask}
83
  return total
src/aurora/treino/prs_v8.py ADDED
@@ -0,0 +1,152 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """PRS V8 — Sistema de Punição‑Recompensa com cinco mecanismos provados
3
+ (doc 11 §7, Teoremas 11.7a–11.7f), extraídos e corrigidos do estudo
4
+ `xavante_work/flexnet/adaptive_prs.py`:
5
+
6
+ 7.1 Trust EMA com HISTERESE ASSIMÉTRICA (η_up=0.05, η_down=0.02):
7
+ E[T∞] = p·η_up / (p·η_up + (1−p)·η_down) — recuperação 2,5× mais
8
+ lenta que a perda ⇒ misses transitórios em platô não desabam o trust.
9
+ 7.2 LR SGDR com PISO DECRESCENTE entre ciclos (η_min^{(i)} = η_min·d^i):
10
+ energia de exploração não cresce ⇒ Robbins–Monro preservado.
11
+ 7.3 Grad‑clip por PERCENTIL ROBUSTO Q₀.₇₅ (breakdown point 0.25 vs 0 da
12
+ média±kσ — um gradiente explosivo não relaxa o clip).
13
+ 7.4 β_min/δ_min DOIS REGIMES (T>0.5: exploração; T≤0.5: força correção).
14
+ 7.5 Recompensa de sequência LOGARÍTMICA 1 + c·log(1+k) (variância finita
15
+ para k geométrico, sem saturação artificial).
16
+ 7.6 Boost de velocidade por SIGMOIDE suave (sem chattering no limiar).
17
+
18
+ Defeito 5 corrigido: buffers de τ e de velocidade SEPARADOS (a versão
19
+ estudada media velocidade sobre a mesma janela que alimenta τ).
20
+ """
21
+ from __future__ import annotations
22
+
23
+ import math
24
+ from collections import deque
25
+
26
+
27
+ class PRSV8:
28
+ def __init__(self, cfg: dict | None = None):
29
+ c = dict(cfg or {})
30
+ # 7.1 histerese
31
+ self.eta_up = float(c.get("eta_up", 0.05))
32
+ self.eta_down = float(c.get("eta_down", 0.02))
33
+ self.trust = 0.5
34
+ # 7.2 SGDR + piso decrescente
35
+ self.warmup = int(c.get("warmup", 60))
36
+ self.T_ciclo = int(c.get("T_ciclo", 400))
37
+ self.lr_max = float(c.get("lr_max", 3e-3))
38
+ self.lr_min0 = float(c.get("lr_min", 3e-4))
39
+ self.decay_piso = float(c.get("decay_piso", 0.5))
40
+ self.ciclos = 0
41
+ # 7.3 clip percentil
42
+ self.janela_clip: deque = deque(maxlen=int(c.get("janela_clip", 50)))
43
+ self.clip_min = float(c.get("clip_min", 0.1))
44
+ self.clip_base = float(c.get("clip_base", 1.0))
45
+ self.percentil = float(c.get("percentil", 0.75))
46
+ # 7.5/7.6
47
+ self.streak = 0
48
+ self.coef_streak = float(c.get("coef_streak", 0.3))
49
+ self.vel_janela: deque = deque(maxlen=int(c.get("vel_janela", 20)))
50
+ self.vel_alvo = float(c.get("vel_alvo", 0.01))
51
+ self.boost_max = float(c.get("boost_max", 1.5))
52
+ self.alfa_sig = float(c.get("alfa_sig", 20.0))
53
+ # τ adaptativo para hit/miss (janela PRÓPRIA — defect 5)
54
+ self.janela_tau: deque = deque(maxlen=int(c.get("janela_tau", 50)))
55
+ self.tau: float | None = None
56
+ # telemetria
57
+ self.recompensa_acum = 0.0
58
+ self.clip_atual = self.clip_base
59
+ self.boost_atual = 1.0
60
+
61
+ # ---------------- 7.1 ----------------
62
+ def atualizar_trust(self, hit: bool) -> float:
63
+ eta = self.eta_up if hit else self.eta_down
64
+ alvo = 1.0 if hit else 0.0
65
+ self.trust = (1 - eta) * self.trust + eta * alvo
66
+ return self.trust
67
+
68
+ def registrar_perda(self, perda: float):
69
+ """τ = quantil EMA da janela própria (defeito 5 corrigido)."""
70
+ self.janela_tau.append(perda)
71
+ j = sorted(self.janela_tau)
72
+ pos = 0.25 * (len(j) - 1)
73
+ lo = int(pos)
74
+ hi = min(lo + 1, len(j) - 1)
75
+ q = j[lo] * (1 - (pos - lo)) + j[hi] * (pos - lo)
76
+ self.tau = q if self.tau is None else max(1e-6, 0.95 * self.tau + 0.05 * q)
77
+ return self.tau
78
+
79
+ def hit(self, perda: float) -> bool:
80
+ return self.tau is not None and perda < self.tau
81
+
82
+ def passo_batch(self, perda: float) -> bool:
83
+ """Registra perda, decide hit, atualiza trust e streak. → hit"""
84
+ self.registrar_perda(perda)
85
+ h = self.hit(perda)
86
+ self.atualizar_trust(h)
87
+ # 7.5 recompensa de sequência
88
+ self.streak = self.streak + 1 if h else 0
89
+ base = max(0.0, (self.tau - perda)) if self.tau else 0.0
90
+ recompensa = base * (1.0 + self.coef_streak * math.log1p(self.streak))
91
+ self.recompensa_acum += recompensa
92
+ return h
93
+
94
+ # ---------------- 7.2 + 7.6 ----------------
95
+ def registrar_velocidade(self, velocidade: float) -> float:
96
+ """velocidade > 0 = perda caindo. Boost suave por sigmoide (7.6)."""
97
+ self.vel_janela.append(velocidade)
98
+ if len(self.vel_janela) < 2:
99
+ self.boost_atual = 1.0
100
+ return 1.0
101
+ media = sum(self.vel_janela) / len(self.vel_janela)
102
+ sig = 1.0 / (1.0 + math.exp(-self.alfa_sig * (media - self.vel_alvo)))
103
+ self.boost_atual = 1.0 + 0.5 * (self.boost_max - 1.0) * sig
104
+ return self.boost_atual
105
+
106
+ def lr(self, t: int) -> float:
107
+ """SGDR com piso decrescente + boost + trava por trust baixo."""
108
+ if t < self.warmup:
109
+ eta = self.lr_max * (t + 1) / self.warmup
110
+ else:
111
+ s = (t - self.warmup) % max(1, self.T_ciclo)
112
+ idx = (t - self.warmup) // max(1, self.T_ciclo)
113
+ self.ciclos = max(self.ciclos, idx)
114
+ piso = self.lr_min0 * (self.decay_piso ** idx)
115
+ eta = piso + 0.5 * (self.lr_max - piso) * (1 + math.cos(math.pi * s / self.T_ciclo))
116
+ eta = max(eta, 0.5 * piso)
117
+ eta *= self.boost_atual
118
+ if self.trust < 0.1: # trava de segurança (V7)
119
+ eta *= max(0.1, self.trust ** 2)
120
+ return eta
121
+
122
+ # ---------------- 7.3 ----------------
123
+ def clip(self, grad_norm: float) -> float:
124
+ """clip(t) = max(clip_min, Q₀.₇₅(janela)), cap 5·clip_base."""
125
+ self.janela_clip.append(grad_norm)
126
+ if len(self.janela_clip) >= 5:
127
+ j = sorted(self.janela_clip)
128
+ pos = self.percentil * (len(j) - 1)
129
+ lo = int(pos)
130
+ hi = min(lo + 1, len(j) - 1)
131
+ c = j[lo] * (1 - (pos - lo)) + j[hi] * (pos - lo)
132
+ else:
133
+ c = grad_norm
134
+ self.clip_atual = min(max(c, self.clip_min), self.clip_base * 5.0)
135
+ return self.clip_atual
136
+
137
+ # ---------------- 7.4 ----------------
138
+ def beta_min(self, beta_min0: float = 0.01) -> float:
139
+ if self.trust > 0.5:
140
+ return beta_min0 * self.trust
141
+ return beta_min0 * 2.0
142
+
143
+ # ---------------- estado ----------------
144
+ def estado(self) -> dict:
145
+ return {"trust": round(self.trust, 4),
146
+ "tau": round(self.tau, 5) if self.tau else None,
147
+ "clip": round(self.clip_atual, 4),
148
+ "boost": round(self.boost_atual, 3),
149
+ "streak": self.streak,
150
+ "ciclos_sgdr": self.ciclos,
151
+ "recompensa_acum": round(self.recompensa_acum, 3),
152
+ "beta_min_relativo": round(self.beta_min(1.0), 3)}
src/aurora/treino/treinador.py CHANGED
@@ -27,13 +27,17 @@ import torch
27
 
28
  from aurora.dados.estados_hf import EstadosHF
29
  from aurora.dados.streaming import _de_b64
 
30
  from aurora.nucleo.modelo import AURORAModel
 
31
  from aurora.percepcao.ortogonais import CamadaOrtogonal
32
  from aurora.telemetria.hub import TelemetryHub
33
  from aurora.telemetria.indicadores import resumo_janela
34
  from aurora.treino.cirurgia_grad import pcgrad_duas_perdas
 
35
  from aurora.treino.dpo import PerdaDPO, logps_sequencia
36
  from aurora.treino.perdas import perda_total
 
37
  from aurora.treino.punicao import PoliticaRetreino
38
 
39
  TAREFAS_IMAGEM = ("vqa", "ocr", "imagem_caption")
@@ -93,6 +97,34 @@ class TreinadorExtensao:
93
  # telemetria da última fase
94
  self.ultimos_pcgrad: dict = {}
95
  self.modelo.definir_fase_moe("densa") # item d: começa com máx conexões
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
96
 
97
  # ---------------- cronograma (SGDR-like + barreira ABMO) ----------------
98
  def reiniciar_ciclo(self, T: int | None = None):
@@ -101,6 +133,11 @@ class TreinadorExtensao:
101
 
102
  def lr_base(self) -> float:
103
  cfg = self.cfg.treino
 
 
 
 
 
104
  if self.t_ciclo < cfg.warmup:
105
  return cfg.lr_max * (self.t_ciclo + 1) / cfg.warmup
106
  p = (self.t_ciclo - cfg.warmup) / max(self.T_ciclo - cfg.warmup, 1)
@@ -140,16 +177,18 @@ class TreinadorExtensao:
140
  return k
141
  return next(iter(disponiveis))
142
 
143
- def _montar_lote(self, tarefa: str):
144
  """Devolve (ids, alvo, extra) onde extra pode conter 'imagem' (B,3,96,96)
145
- e 'audio' (B,N) — lotes multimodais usam SÓ registros com a modalidade."""
 
146
  cfg = self.cfg
147
  L = cfg.modelo.comprimento_ctx
 
148
  extra: dict = {}
149
  if tarefa in ("lm", "noticia"):
150
  pool = self.buffer_replay if (self.modo_replay > 0 and self.buffer_replay) \
151
  else self.por_tarefa[tarefa]
152
- amostras = random.sample(pool, min(cfg.treino.lote, len(pool)))
153
  seqs = [self.tk.encode(s["texto"], tarefa=tarefa, max_len=L) for s in amostras]
154
  elif tarefa in TAREFAS_IMAGEM + TAREFAS_AUDIO:
155
  campo = "imagem" if tarefa in TAREFAS_IMAGEM else "audio"
@@ -157,7 +196,7 @@ class TreinadorExtensao:
157
  if not com_modal:
158
  com_modal = self.por_tarefa[tarefa] # fallback textual
159
  campo = "_nenhum"
160
- amostras = random.sample(com_modal, min(cfg.treino.lote, len(com_modal)))
161
  seqs = []
162
  for s in amostras:
163
  inp = self.tk.encode(s["entrada"], tarefa=tarefa, max_len=L // 2)
@@ -183,7 +222,7 @@ class TreinadorExtensao:
183
  extra["audio"] = pad
184
  else:
185
  amostras = random.sample(self.por_tarefa[tarefa],
186
- min(cfg.treino.lote, len(self.por_tarefa[tarefa])))
187
  seqs = []
188
  for s in amostras:
189
  inp = self.tk.encode(s["entrada"], tarefa=tarefa, max_len=L // 2)
@@ -213,6 +252,8 @@ class TreinadorExtensao:
213
  self.modelo.train()
214
  tarefa = self._escolher_tarefa()
215
  ids, alvo, extra = self._montar_lote(tarefa)
 
 
216
  # prefixo multimodal TREINÁVEL (gradiente nos encoders — v2)
217
  emb_prefixo = None
218
  if self.modelo.usar_multimodal and ("imagem" in extra or "audio" in extra):
@@ -233,17 +274,40 @@ class TreinadorExtensao:
233
  # perda principal CE
234
  logits, perda_ce = self.modelo(ids, alvo=alvo, emb_prefixo=emb_prefixo,
235
  tarefa=tarefa)
 
 
 
 
 
 
 
 
 
 
 
 
236
  # perda auxiliar agregada: MTP + MoE (lb, ort) + alinhamento SOM
237
  auxiliares = []
 
 
 
 
 
238
  if self.modelo.mtp is not None:
239
  p_mtp = self.modelo.mtp_do_trunk(ids, alvo, tarefa=tarefa,
240
- com_prefixo=emb_prefixo is not None)
 
241
  if p_mtp is not None and float(p_mtp) == float(p_mtp):
242
  auxiliares.append(self.cfg.treino.lambda_mtp * p_mtp)
243
  for bloco in self.modelo.blocos:
244
  if bloco.moe is not None:
245
  auxiliares.append(self.cfg.treino.lambda_moe_lb * bloco.moe.perda_lb)
246
  auxiliares.append(self.cfg.treino.lambda_moe_ort * bloco.moe.perda_ort)
 
 
 
 
 
247
  perda_som = self.modelo.alinhar_som(ids, orquestrador=self.orquestrador,
248
  tarefa=tarefa) \
249
  if self.orquestrador is not None else None
@@ -263,8 +327,13 @@ class TreinadorExtensao:
263
  else:
264
  perda_ce_total.backward()
265
  self.ultimos_pcgrad = {"pcgrad/dot": 0.0, "pcgrad/projetado": 0.0}
 
 
 
 
266
  grad_norm = torch.nn.utils.clip_grad_norm_(self.modelo.parameters(),
267
- self.cfg.treino.clip_grad).item()
 
268
  # contribuição de gradiente (EMA por camada, amostrada a cada 10 passos)
269
  if self.passo_global % 10 == 0:
270
  with torch.no_grad():
@@ -276,26 +345,72 @@ class TreinadorExtensao:
276
  for gp in self.otimizador.param_groups:
277
  gp["lr"] = lr
278
  self.otimizador.step()
279
- self._atualizar_L_hat(float(perda_ce.detach()))
280
  self.t_ciclo += 1
281
  self.passo_global += 1
282
  if self.modo_replay > 0:
283
  self.modo_replay -= 1
284
  if self.passo_global % 5 == 0:
285
  self.buffer_replay.append((tarefa, ids))
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
286
  # telemetria (item 5)
287
  self.hub.passos(self.passo_global, **{
288
- "perda/treino": float(perda_ce), "perda/ce": float(perda_ce),
289
  "grad_norm": grad_norm, "lr": lr,
290
  "abmo/L_hat": self._L_hat,
291
  "pcgrad/dot": self.ultimos_pcgrad.get("pcgrad/dot", 0.0),
292
- "pcgrad/projetado": self.ultimos_pcgrad.get("pcgrad/projetado", 0.0)})
 
 
 
 
 
293
  if self.modelo.mtp is not None and self.modelo.mtp.ultimos:
294
  self.hub.atributo("mtp/entropia",
295
  self.modelo.mtp.ultimos.get("entropia", 0.0),
296
  self.passo_global)
297
- if self.passo_global % 50 == 0:
298
- self.hub.parametros(self.modelo, self.passo_global) # delta de TODOS os parâmetros
 
 
 
 
 
 
 
 
 
 
 
299
  if self.passo_global % self.cfg.treino.avaliar_a_cada == 0:
300
  ids1, _, _ = self._montar_lote(tarefa)
301
  self.hub.atributo("rep/rank_efetivo", self.modelo.rank_efetivo_oculto(ids1),
@@ -308,7 +423,7 @@ class TreinadorExtensao:
308
  acao = self.politica.verificar(self.passo_global, grad_norm)
309
  if acao:
310
  self.eventos_punicao.append(self.politica.executar(acao, self.passo_global))
311
- return float(perda_ce)
312
 
313
  # ---------------- avaliação ----------------
314
  @torch.no_grad()
@@ -381,7 +496,17 @@ class TreinadorExtensao:
381
  return {"pulado": "sem pares possíveis"}
382
  # referência = clone congelado do trunk+head (só o que DPO usa)
383
  ref = AURORAModel(self.cfg, usar_multimodal=False)
384
- ref.load_state_dict(self.modelo.state_dict(), strict=False)
 
 
 
 
 
 
 
 
 
 
385
  ref.eval()
386
  for p in ref.parameters():
387
  p.requires_grad_(False)
@@ -468,6 +593,16 @@ class TreinadorExtensao:
468
  self.orquestrador.escolher({"rotulo_tarefa": "instrucao" if self.por_tarefa.get("instrucao") else "lm"})
469
  eq = self.orquestrador.treinar_memoria(ctx, epocas=1)
470
  self.prototipos_som = self.orquestrador.mapear(ctx)
 
 
 
 
 
 
 
 
 
 
471
  return eq
472
 
473
  # ---------------- FASE 4: SOM com máximo de neurônios ativos ----------------
@@ -550,7 +685,7 @@ class TreinadorExtensao:
550
  self.modelo.definir_fase_moe("foco")
551
  perdas_epoca = []
552
  limite = max_passos_por_epoca or (len(self.treino) // cfg.lote)
553
- alvo_passos = limite - self.passos_epoca
554
  for i in range(alvo_passos):
555
  # QAT nos últimos passos da última época (item 9)
556
  if ep >= cfg.fase_densa_ate_epoca and \
@@ -559,23 +694,42 @@ class TreinadorExtensao:
559
  perdas_epoca.append(self._passo())
560
  self.passos_epoca += 1
561
  if self.passo_global % cfg.checkpoint_a_cada == 0:
562
- self.salvar_estado_hf(f"epoca-{ep:03d}-parcial")
563
  if orcamento_s is not None and time.time() - t0 > orcamento_s:
564
  interrompido = True
565
  break
566
  if interrompido:
567
- self.salvar_estado_hf(f"epoca-{ep:03d}-parcial")
568
  break
569
  eq_som = self.atualizar_memoria_som()
570
  aval = self.avaliar()
571
  self.passos_epoca = 0
 
 
 
 
 
 
 
 
572
  self.salvar_estado_hf(f"epoca-{ep:03d}")
573
- registro = {"epoca": ep, "perda_media": sum(perdas_epoca) / len(perdas_epoca),
574
  "avaliacao": aval, "eq_som": eq_som,
575
- "punicoes": len(self.eventos_punicao)}
 
 
 
 
 
 
 
 
 
576
  self.historico_epocas.append(registro)
577
  if self.hub is not None:
578
- self.hub.atributo("epoca/perda_media", registro["perda_media"], ep)
 
 
579
  if aval.get("ppl_lm"):
580
  self.hub.atributo("epoca/ppl_lm", aval["ppl_lm"], ep)
581
  self.modelo.qat = False
 
27
 
28
  from aurora.dados.estados_hf import EstadosHF
29
  from aurora.dados.streaming import _de_b64
30
+ from aurora.memoria.interna import MemoriaInterna
31
  from aurora.nucleo.modelo import AURORAModel
32
+ from aurora.percepcao.microunidades import GestorCrescimento
33
  from aurora.percepcao.ortogonais import CamadaOrtogonal
34
  from aurora.telemetria.hub import TelemetryHub
35
  from aurora.telemetria.indicadores import resumo_janela
36
  from aurora.treino.cirurgia_grad import pcgrad_duas_perdas
37
+ from aurora.treino.confianca import AgenteConfianca
38
  from aurora.treino.dpo import PerdaDPO, logps_sequencia
39
  from aurora.treino.perdas import perda_total
40
+ from aurora.treino.prs_v8 import PRSV8
41
  from aurora.treino.punicao import PoliticaRetreino
42
 
43
  TAREFAS_IMAGEM = ("vqa", "ocr", "imagem_caption")
 
97
  # telemetria da última fase
98
  self.ultimos_pcgrad: dict = {}
99
  self.modelo.definir_fase_moe("densa") # item d: começa com máx conexões
100
+ # v3 (doc 11): PRS V8, AgenteConfiança, GestorCrescimento, MemóriaInterna
101
+ self.prs = PRSV8(cfg.treino.prs_v8)
102
+ cfg_conf = dict(cfg.treino.confianca or {})
103
+ self.agente = AgenteConfianca(
104
+ kappa_punicao=float(cfg_conf.get("kappa_punicao", 0.3)),
105
+ kappa_premio=float(cfg_conf.get("kappa_premio", 0.1)),
106
+ janela_tau=int(cfg_conf.get("janela_tau", 50)),
107
+ quantil_tau=float(cfg_conf.get("quantil_tau", 0.25)))
108
+ self.h_escrita_memoria = float(cfg_conf.get("h_escrita_memoria", 0.5))
109
+ self.memoria: MemoriaInterna | None = None
110
+ if bool(getattr(cfg, "memoria_interna", None) and cfg.memoria_interna.ativo):
111
+ mi = cfg.memoria_interna
112
+ self.memoria = MemoriaInterna(
113
+ d=modelo.d, n_slots=int(mi.n_slots), h_escrita=float(mi.h_escrita),
114
+ idade_compressao_s=float(mi.idade_compressao_s),
115
+ n_codigos=int(mi.n_codigos), lambda_utilidade=float(mi.lambda_utilidade),
116
+ meia_vida_s=float(mi.meia_vida_s))
117
+ cfg_cres = dict(cfg.treino.crescimento or {})
118
+ self.gestor = GestorCrescimento(
119
+ self.modelo.compositores, cfg_cres, hub=hub) \
120
+ if cfg_cres.get("ativo", True) else None
121
+ self.gestor_a_cada = int(cfg_cres.get("a_cada", 200))
122
+ self.k_adaptativo = bool(dict(getattr(cfg.modelo, "mtp", {}) or {})
123
+ .get("k_adaptativo", True))
124
+ self._perdas_recentes: deque = deque(maxlen=8)
125
+ self.replay_memoria_a_cada = int(getattr(cfg, "memoria_interna",
126
+ None) is not None and
127
+ cfg.memoria_interna.replay_a_cada or 40)
128
 
129
  # ---------------- cronograma (SGDR-like + barreira ABMO) ----------------
130
  def reiniciar_ciclo(self, T: int | None = None):
 
133
 
134
  def lr_base(self) -> float:
135
  cfg = self.cfg.treino
136
+ # v3 fix: o LR do PRS V8 (SGDR+boost) mostrou-se quente demais para este
137
+ # porte (reinícios a cada T_ciclo reinjetavam η_max e a perda subia entre
138
+ # épocas). O PRS V8 permanece para TRUST/CLIP/STREAK (Teoremas 7.1/7.3/
139
+ # 7.5 — valores saudáveis na telemetria); o cronograma volta ao cosine
140
+ # warm-restart da v2 (provenido estável).
141
  if self.t_ciclo < cfg.warmup:
142
  return cfg.lr_max * (self.t_ciclo + 1) / cfg.warmup
143
  p = (self.t_ciclo - cfg.warmup) / max(self.T_ciclo - cfg.warmup, 1)
 
177
  return k
178
  return next(iter(disponiveis))
179
 
180
+ def _montar_lote(self, tarefa: str, lote: int | None = None):
181
  """Devolve (ids, alvo, extra) onde extra pode conter 'imagem' (B,3,96,96)
182
+ e 'audio' (B,N) — lotes multimodais usam SÓ registros com a modalidade.
183
+ v3: `lote` sobrepõe cfg (usado pela sonda de crescimento com B=2)."""
184
  cfg = self.cfg
185
  L = cfg.modelo.comprimento_ctx
186
+ lote = lote or cfg.treino.lote
187
  extra: dict = {}
188
  if tarefa in ("lm", "noticia"):
189
  pool = self.buffer_replay if (self.modo_replay > 0 and self.buffer_replay) \
190
  else self.por_tarefa[tarefa]
191
+ amostras = random.sample(pool, min(lote, len(pool)))
192
  seqs = [self.tk.encode(s["texto"], tarefa=tarefa, max_len=L) for s in amostras]
193
  elif tarefa in TAREFAS_IMAGEM + TAREFAS_AUDIO:
194
  campo = "imagem" if tarefa in TAREFAS_IMAGEM else "audio"
 
196
  if not com_modal:
197
  com_modal = self.por_tarefa[tarefa] # fallback textual
198
  campo = "_nenhum"
199
+ amostras = random.sample(com_modal, min(lote, len(com_modal)))
200
  seqs = []
201
  for s in amostras:
202
  inp = self.tk.encode(s["entrada"], tarefa=tarefa, max_len=L // 2)
 
222
  extra["audio"] = pad
223
  else:
224
  amostras = random.sample(self.por_tarefa[tarefa],
225
+ min(lote, len(self.por_tarefa[tarefa])))
226
  seqs = []
227
  for s in amostras:
228
  inp = self.tk.encode(s["entrada"], tarefa=tarefa, max_len=L // 2)
 
252
  self.modelo.train()
253
  tarefa = self._escolher_tarefa()
254
  ids, alvo, extra = self._montar_lote(tarefa)
255
+ # v3: h_t do passo anterior governa a temperatura do gating (doc 11 §8)
256
+ self.modelo.registrar_confianca(self.agente.ultimo_h)
257
  # prefixo multimodal TREINÁVEL (gradiente nos encoders — v2)
258
  emb_prefixo = None
259
  if self.modelo.usar_multimodal and ("imagem" in extra or "audio" in extra):
 
274
  # perda principal CE
275
  logits, perda_ce = self.modelo(ids, alvo=alvo, emb_prefixo=emb_prefixo,
276
  tarefa=tarefa)
277
+ perda_valor = float(perda_ce.detach())
278
+ # v3: AgenteConfiança — h_t, posterior Beta, calibração (doc 11 §8)
279
+ feats = AgenteConfianca.features_logits(logits)
280
+ h_t = float(self.agente(feats, perda_atual=perda_valor))
281
+ hit = bool(self.prs.passo_batch(perda_valor))
282
+ self.agente.registrar_resultado(perda_valor, h_t)
283
+ self.modelo.registrar_confianca(h_t)
284
+ # v3: velocidade da perda → boost suave do PRS (Teorema 11.7.6)
285
+ if self._perdas_recentes:
286
+ vel = (self._perdas_recentes[-1] - perda_valor) / len(self._perdas_recentes)
287
+ self.prs.registrar_velocidade(vel)
288
+ self._perdas_recentes.append(perda_valor)
289
  # perda auxiliar agregada: MTP + MoE (lb, ort) + alinhamento SOM
290
  auxiliares = []
291
+ h_conf = None
292
+ if self.modelo.mtp is not None and self.k_adaptativo:
293
+ # v3 (Teorema 11.6): máscara K adaptativa por posição — proxy
294
+ # monotônico 1 − H(p_t)/log V, calibrado pelo ECE do AgenteConfiança
295
+ h_conf = AgenteConfianca.confianca_posicional(logits)
296
  if self.modelo.mtp is not None:
297
  p_mtp = self.modelo.mtp_do_trunk(ids, alvo, tarefa=tarefa,
298
+ com_prefixo=emb_prefixo is not None,
299
+ h_conf=h_conf)
300
  if p_mtp is not None and float(p_mtp) == float(p_mtp):
301
  auxiliares.append(self.cfg.treino.lambda_mtp * p_mtp)
302
  for bloco in self.modelo.blocos:
303
  if bloco.moe is not None:
304
  auxiliares.append(self.cfg.treino.lambda_moe_lb * bloco.moe.perda_lb)
305
  auxiliares.append(self.cfg.treino.lambda_moe_ort * bloco.moe.perda_ort)
306
+ # v3 fix: balanceamento do GATE das microunidades (anti-colapso —
307
+ # sem isto o softmax satura num ramo e as demais unidades morrem)
308
+ comp = getattr(bloco, "composto", None)
309
+ if comp is not None and hasattr(comp, "perla_balanceamento_g"):
310
+ auxiliares.append(0.01 * comp.perla_balanceamento_g)
311
  perda_som = self.modelo.alinhar_som(ids, orquestrador=self.orquestrador,
312
  tarefa=tarefa) \
313
  if self.orquestrador is not None else None
 
327
  else:
328
  perda_ce_total.backward()
329
  self.ultimos_pcgrad = {"pcgrad/dot": 0.0, "pcgrad/projetado": 0.0}
330
+ # v3: clip pelo PERCENTIL ROBUSTO do PRS V8 (Teorema 11.7.3) — o limite
331
+ # usa a estatística da janela anterior; a norma pré-clip atualiza a janela
332
+ limite_clip = self.prs.clip_atual if bool(self.cfg.treino.prs_v8.get("ativo", True)) \
333
+ else self.cfg.treino.clip_grad
334
  grad_norm = torch.nn.utils.clip_grad_norm_(self.modelo.parameters(),
335
+ limite_clip).item()
336
+ self.prs.clip(grad_norm)
337
  # contribuição de gradiente (EMA por camada, amostrada a cada 10 passos)
338
  if self.passo_global % 10 == 0:
339
  with torch.no_grad():
 
345
  for gp in self.otimizador.param_groups:
346
  gp["lr"] = lr
347
  self.otimizador.step()
348
+ self._atualizar_L_hat(perda_valor)
349
  self.t_ciclo += 1
350
  self.passo_global += 1
351
  if self.modo_replay > 0:
352
  self.modo_replay -= 1
353
  if self.passo_global % 5 == 0:
354
  self.buffer_replay.append((tarefa, ids))
355
+ # v3: memória interna — escrita conficiente do contexto (doc 11 §9)
356
+ ctx = None
357
+ if self.memoria is not None and self.passo_global % 4 == 0:
358
+ with torch.no_grad():
359
+ ctx = getattr(self.modelo, "_ultimo_oculto", None)
360
+ if ctx is not None:
361
+ z = ctx.mean(dim=(0, 1))
362
+ gravou = self.memoria.escrever(z, h_t, origem="nucleo",
363
+ tarefa=tarefa)
364
+ if gravou and self.memoria.slots:
365
+ self.memoria.slots[-1].tarefa = tarefa
366
+ if self.memoria is not None and self.replay_memoria_a_cada and \
367
+ self.passo_global % self.replay_memoria_a_cada == 0:
368
+ z_q = (ctx.mean(dim=(0, 1)) if ctx is not None
369
+ else torch.zeros(self.modelo.d))
370
+ rec = self.memoria.consultar(z_q, m=3, origem="treino")
371
+ self.hub.atributo("memoria/hit_rate",
372
+ self.memoria.estatisticas()["hit_rate"],
373
+ self.passo_global)
374
+ # v3: sonda de crescimento (Hutchinson diag-H) — doc 11 Teorema 11.5
375
+ if self.gestor is not None and self.passo_global % self.gestor_a_cada == 0:
376
+ def perda_sonda():
377
+ ids_p, alvo_p, _ = self._montar_lote(tarefa, lote=2)
378
+ _, p_p = self.modelo(ids_p, alvo=alvo_p, tarefa=tarefa)
379
+ return p_p
380
+ resultado_cres = self.gestor.verificar(self.passo_global, perda_sonda)
381
+ for a in resultado_cres.get("acoes", []):
382
+ if a["acao"] not in ("manter",):
383
+ self.hub.atributo("crescimento/uso_min", a["uso_min"],
384
+ self.passo_global)
385
  # telemetria (item 5)
386
  self.hub.passos(self.passo_global, **{
387
+ "perda/treino": perda_valor, "perda/ce": perda_valor,
388
  "grad_norm": grad_norm, "lr": lr,
389
  "abmo/L_hat": self._L_hat,
390
  "pcgrad/dot": self.ultimos_pcgrad.get("pcgrad/dot", 0.0),
391
+ "pcgrad/projetado": self.ultimos_pcgrad.get("pcgrad/projetado", 0.0),
392
+ "conf/h_t": h_t,
393
+ "prs/trust": self.prs.trust,
394
+ "prs/clip": self.prs.clip_atual,
395
+ "prs/boost": self.prs.boost_atual,
396
+ "prs/streak": float(self.prs.streak)})
397
  if self.modelo.mtp is not None and self.modelo.mtp.ultimos:
398
  self.hub.atributo("mtp/entropia",
399
  self.modelo.mtp.ultimos.get("entropia", 0.0),
400
  self.passo_global)
401
+ if "termos_ce" in self.modelo.mtp.ultimos:
402
+ self.hub.atributo("mtp/termos_ce",
403
+ self.modelo.mtp.ultimos["termos_ce"],
404
+ self.passo_global)
405
+ if self.passo_global % 150 == 0:
406
+ # delta completo de todos os parâmetros (item 5) — à prova de falhas:
407
+ # telemetria nunca pode derrubar o treino (RAM em pico)
408
+ try:
409
+ self.hub.parametros(self.modelo, self.passo_global)
410
+ except Exception as e:
411
+ self.hub.eventos_guard.append(f"parametros falhou: {type(e).__name__}")
412
+ import gc
413
+ gc.collect()
414
  if self.passo_global % self.cfg.treino.avaliar_a_cada == 0:
415
  ids1, _, _ = self._montar_lote(tarefa)
416
  self.hub.atributo("rep/rank_efetivo", self.modelo.rank_efetivo_oculto(ids1),
 
423
  acao = self.politica.verificar(self.passo_global, grad_norm)
424
  if acao:
425
  self.eventos_punicao.append(self.politica.executar(acao, self.passo_global))
426
+ return perda_valor
427
 
428
  # ---------------- avaliação ----------------
429
  @torch.no_grad()
 
496
  return {"pulado": "sem pares possíveis"}
497
  # referência = clone congelado do trunk+head (só o que DPO usa)
498
  ref = AURORAModel(self.cfg, usar_multimodal=False)
499
+ # v3: carregamento tolerante a forma — o gestor de crescimento pode ter
500
+ # EXPANDIDO microunidades (gate/ramos mudam de forma); carregamos por
501
+ # chave com shapes compatíveis (o resto fica na init padrão, congelado)
502
+ próprio_sd = {}
503
+ modelo_sd = self.modelo.state_dict()
504
+ ref_sd = ref.state_dict()
505
+ for k, v in modelo_sd.items():
506
+ alvo = ref_sd.get(k)
507
+ if alvo is not None and alvo.shape == v.shape:
508
+ próprio_sd[k] = v
509
+ ref.load_state_dict(próprio_sd, strict=False)
510
  ref.eval()
511
  for p in ref.parameters():
512
  p.requires_grad_(False)
 
593
  self.orquestrador.escolher({"rotulo_tarefa": "instrucao" if self.por_tarefa.get("instrucao") else "lm"})
594
  eq = self.orquestrador.treinar_memoria(ctx, epocas=1)
595
  self.prototipos_som = self.orquestrador.mapear(ctx)
596
+ # v3: indexa slots da memória interna pelos BMUs (recall por categoria)
597
+ if self.memoria is not None:
598
+ try:
599
+ variante = self.orquestrador.variante()
600
+ if hasattr(variante, "bmu"):
601
+ c_idx, _ = variante.bmu(ctx)
602
+ for i, b in enumerate(c_idx.tolist()[:len(self.memoria.slots)]):
603
+ self.memoria.indexar_som(i, self.orquestrador.ativa, int(b))
604
+ except Exception:
605
+ pass
606
  return eq
607
 
608
  # ---------------- FASE 4: SOM com máximo de neurônios ativos ----------------
 
685
  self.modelo.definir_fase_moe("foco")
686
  perdas_epoca = []
687
  limite = max_passos_por_epoca or (len(self.treino) // cfg.lote)
688
+ alvo_passos = max(limite - self.passos_epoca, 0)
689
  for i in range(alvo_passos):
690
  # QAT nos últimos passos da última época (item 9)
691
  if ep >= cfg.fase_densa_ate_epoca and \
 
694
  perdas_epoca.append(self._passo())
695
  self.passos_epoca += 1
696
  if self.passo_global % cfg.checkpoint_a_cada == 0:
697
+ self.salvar_estado_hf(f"epoca-{ep:03d}-p{self.passo_global:05d}")
698
  if orcamento_s is not None and time.time() - t0 > orcamento_s:
699
  interrompido = True
700
  break
701
  if interrompido:
702
+ self.salvar_estado_hf(f"epoca-{ep:03d}-p{self.passo_global:05d}")
703
  break
704
  eq_som = self.atualizar_memoria_som()
705
  aval = self.avaliar()
706
  self.passos_epoca = 0
707
+ # v3: consolidação da memória interna (compressão VQ + índice SOM)
708
+ if self.memoria is not None:
709
+ n_comp = self.memoria.comprimir_antigos(origem="treino")
710
+ self.hub.atributo("memoria/comprimidos", float(n_comp), ep)
711
+ stats_mem = self.memoria.estatisticas()
712
+ for k, v in stats_mem.items():
713
+ if isinstance(v, (int, float)):
714
+ self.hub.atributo(f"memoria/{k}", float(v), ep)
715
  self.salvar_estado_hf(f"epoca-{ep:03d}")
716
+ registro = {"epoca": ep, "perda_media": (sum(perdas_epoca) / len(perdas_epoca)) if perdas_epoca else None,
717
  "avaliacao": aval, "eq_som": eq_som,
718
+ "punicoes": len(self.eventos_punicao),
719
+ "prs": self.prs.estado(),
720
+ "confianca": {"h_ema": self.agente.ultimo_h,
721
+ "ece": self.agente.ece(),
722
+ "posterior": {"media": self.agente.posterior.media,
723
+ "bernstein": self.agente.posterior.bernstein()}},
724
+ "memoria": (self.memoria.estatisticas()
725
+ if self.memoria is not None else None),
726
+ "crescimento": (self.gestor.eventos[-5:]
727
+ if self.gestor is not None else [])}
728
  self.historico_epocas.append(registro)
729
  if self.hub is not None:
730
+ if registro["perda_media"] is not None:
731
+ self.hub.atributo("epoca/perda_media",
732
+ registro["perda_media"], ep)
733
  if aval.get("ppl_lm"):
734
  self.hub.atributo("epoca/ppl_lm", aval["ppl_lm"], ep)
735
  self.modelo.qat = False
tests/test_aurora_v3.py ADDED
@@ -0,0 +1,327 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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 =====")