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 +118 -57
- configs/base.json +55 -1
- docs/matematica/11-composicao-microunidades-v3.md +386 -0
- scripts/04_treinar.py +29 -8
- scripts/05_avaliar.py +94 -9
- scripts/06_publicar_hf.py +44 -16
- src/aurora/config.py +35 -1
- src/aurora/dados/estados_hf.py +120 -50
- src/aurora/memoria/interna.py +263 -0
- src/aurora/nucleo/modelo.py +43 -8
- src/aurora/percepcao/audio.py +4 -0
- src/aurora/percepcao/blocos.py +41 -0
- src/aurora/percepcao/imagem.py +4 -0
- src/aurora/percepcao/microunidades.py +443 -0
- src/aurora/percepcao/moe.py +9 -6
- src/aurora/raciocinio/ciclo.py +33 -4
- src/aurora/telemetria/hub.py +4 -1
- src/aurora/treino/confianca.py +169 -0
- src/aurora/treino/mtp.py +29 -7
- src/aurora/treino/prs_v8.py +152 -0
- src/aurora/treino/treinador.py +174 -20
- tests/test_aurora_v3.py +327 -0
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
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 25 |
|
| 26 |
-
|
| 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)
|
| 33 |
-
| **(
|
| 34 |
-
| **(
|
| 35 |
-
| **(
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 36 |
|
| 37 |
-
|
| 38 |
-
|
| 39 |
-
|
| 40 |
-
|
| 41 |
-
|
|
|
|
| 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 |
-
-
|
|
|
|
| 47 |
|
| 48 |
## Estrutura do repositório
|
| 49 |
|
| 50 |
```
|
| 51 |
-
src/aurora/
|
| 52 |
-
percepcao/
|
| 53 |
-
|
| 54 |
-
|
| 55 |
-
|
| 56 |
-
|
| 57 |
-
|
| 58 |
-
|
| 59 |
-
|
| 60 |
-
|
| 61 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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;
|
| 71 |
python3 scripts/03_treinar_tokenizador.py
|
| 72 |
-
python3 scripts/04_treinar.py --orcamento 1500 # segmentos; retoma do
|
| 73 |
-
python3 scripts/05_avaliar.py #
|
| 74 |
-
python3 scripts/06_publicar_hf.py #
|
| 75 |
```
|
| 76 |
|
| 77 |
-
## Evidências de qualidade (ver `
|
| 78 |
|
| 79 |
| Métrica | Treinado | Aleatório |
|
| 80 |
|---|---|---|
|
| 81 |
-
| ppl (LM) | **
|
| 82 |
-
| perda instrucao | 5.
|
| 83 |
-
| perda vqa (imagem real) |
|
| 84 |
-
| perda ocr (imagem real) | 5.
|
| 85 |
-
| perda asr (áudio real) |
|
| 86 |
-
| perda tts | 4.
|
| 87 |
-
|
| 88 |
-
|
| 89 |
-
|
| 90 |
-
|
| 91 |
-
|
| 92 |
-
|
| 93 |
-
|
| 94 |
-
- **
|
| 95 |
-
|
| 96 |
-
|
| 97 |
-
|
| 98 |
-
|
| 99 |
-
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 100 |
|
| 101 |
## Limitações honestas
|
| 102 |
|
| 103 |
-
-
|
| 104 |
-
|
| 105 |
-
|
| 106 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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
|
| 4 |
-
|
| 5 |
-
FASE Densa (épocas 0..2): máx conexões, MoE softmax-total
|
| 6 |
-
|
| 7 |
-
|
|
|
|
|
|
|
|
|
|
| 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/
|
| 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({"
|
|
|
|
| 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
|
| 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
|
| 8 |
-
|
| 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 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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/
|
| 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/
|
| 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/
|
| 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
|
| 4 |
|
| 5 |
-
README.md (model card
|
| 6 |
-
docs/matematica/ (provas 00–
|
| 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
|
| 87 |
-
"
|
|
|
|
|
|
|
| 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", "
|
| 115 |
if os.path.exists(rel):
|
| 116 |
-
api.upload_file(path_or_fileobj=rel, path_in_repo="
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 117 |
repo_id=args.repo, repo_type="model",
|
| 118 |
-
commit_message="
|
| 119 |
-
print("✓
|
| 120 |
|
| 121 |
-
# poda dos estados intermediários de retomada
|
|
|
|
|
|
|
| 122 |
try:
|
|
|
|
| 123 |
arquivos = api.list_repo_files(args.repo, repo_type="model")
|
| 124 |
-
a_apagar = [
|
| 125 |
-
|
| 126 |
-
|
| 127 |
-
|
| 128 |
-
|
|
|
|
|
|
|
|
|
|
| 129 |
if a_apagar:
|
| 130 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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 |
-
|
| 53 |
-
|
| 54 |
-
|
| 55 |
-
|
| 56 |
-
|
| 57 |
-
|
| 58 |
-
|
| 59 |
-
|
| 60 |
-
|
| 61 |
-
|
| 62 |
-
|
| 63 |
-
|
| 64 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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 |
-
|
| 74 |
-
|
| 75 |
-
|
| 76 |
-
|
| 77 |
-
|
| 78 |
-
|
| 79 |
-
|
| 80 |
-
|
| 81 |
-
|
| 82 |
-
|
| 83 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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 |
-
|
| 127 |
-
|
| 128 |
-
|
| 129 |
-
|
| 130 |
-
|
| 131 |
-
|
| 132 |
-
|
| 133 |
-
|
| 134 |
-
|
| 135 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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 |
-
|
| 149 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 150 |
except Exception:
|
| 151 |
pass # meta ilegível: segue com aviso implícito
|
| 152 |
try:
|
| 153 |
sd = _st_load(dados)
|
| 154 |
-
|
| 155 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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 |
-
|
| 166 |
-
for tag in
|
| 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 |
-
|
| 175 |
-
|
| 176 |
-
|
| 177 |
-
|
| 178 |
-
|
|
|
|
|
|
|
| 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 |
-
|
| 68 |
-
|
| 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
|
|
|
|
| 150 |
"""MTP sobre o estado oculto do MESMO forward (grafo compartilhado —
|
| 151 |
-
PCGrad separa os gradientes depois, doc 10 §5).
|
| 152 |
-
|
| 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 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 106 |
# gate duplo (eq. 10.1): afinidade por âncora + viés de grupo-tarefa
|
| 107 |
it = self.indice_grupo(tarefa)
|
| 108 |
-
s = (
|
| 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 |
-
|
| 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 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 89 |
decisao = "entregar"
|
| 90 |
-
elif p <
|
| 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 |
-
|
|
|
|
|
|
|
| 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
|
|
|
|
| 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 |
-
|
| 51 |
-
|
| 52 |
-
|
| 53 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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(
|
| 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(
|
| 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(
|
| 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 |
-
|
|
|
|
| 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(
|
| 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":
|
| 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 |
-
|
| 298 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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
|
| 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 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 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}-
|
| 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}-
|
| 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 |
-
|
|
|
|
|
|
|
| 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 =====")
|