PowerMachine commited on
Commit
96a4177
·
verified ·
1 Parent(s): 38c1997

AURORA v5 COMPLETO: atenção entre MoEs e variantes SOM (Teoremas 16.1–16.6), difusão multimodal (doc 17), quantização REAL sem fakes (torchao/QAT/FP8/BnB, doc 08 §§7–9), Agente Engenheiro com telemetria integral, vocab 16384, n_experts_fusao=4, treino do zero

Browse files
README.md CHANGED
@@ -4,95 +4,110 @@ 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
  - medusa
16
  - speculative-decoding
17
  - dpo
18
  - pcgrad
19
- - w8a8
20
- - group-quantization
 
 
21
  - nlp
22
  - nlg
23
  - long-context
24
- - compute-scaling
25
- - two-phase-training
26
  - pt-br
27
- - pdca
28
  metrics:
29
  - perplexity
30
  ---
31
 
32
- # AURORA v4 — Auto-escala por computo, NLP/NLG de primeira classe, contexto indexado 1M e decodificação especulativa em árvore
33
 
34
  IA multimodal (texto, imagem, áudio, vídeo) **auto-aprendente** para português do
35
- Brasil. A v4 **sobrescreve e aprimora** a v3 atendendo ao escopo completo:
36
- **vocab_size = 16384**, **n_experts_fusao = 4**, **auto-escala por computo**
37
- (computo extra ⇒ MAIS unidades; computo reduzido ⇒ nunca regride),
38
- **unidades NLP (processar) e NLG (gerar) de primeira classe**, **janela de
39
- contexto de 1M tokens com compressão INDEXADA**, **duas fases de treino**
40
- (rede aumentada → consolidação SOM com máximos de neurônios ativos),
41
- **decodificação especulativa Medusa em árvore** (absorvida de
42
- `gru-ring-v13-9-2`), **quantização W8A8 melhorada** (escalas por grupo +
43
- correção de viés) e **8 variantes SOM SEM neurônios isolados** (garantia por
44
- reseeding guloso — Teorema 15.2). Toda matemática vem ANTES dos scripts:
45
- `docs/matematica/12–15` (novos teoremas 12.1–15.3 e 8.4/8.5).
46
-
47
- ## O que mudou da v3 → v4
48
-
49
- | Inovação | O que faz | Fundamento |
50
- |---|---|---|
51
- | **Auto-escala por computo** | Perfil `C = núcleos × RAM_livre/4GB × orçamento_tempo` reavaliado a cada 100 passos; regra `n_ramos=clip(2+⌊αC⌋), d_ramo=d0·2^⌊log₂(1+C)/2⌋, k_rec=1+⌊log₂(1+C)⌋` — **monótona** (Teorema 12.1a: computo menor NUNCA reduz capacidade) e com **herança segura** (Teorema 12.2: novos ramos nascem como média reduzida dos existentes) | doc 12, Teoremas 12.1–12.2 |
52
- | **Composição ótima provada** | As 4 topologias (serial/paralela/isolada/recursiva) são os casos-limite do agendamento work-conserving LPT — cobertura ≥ (1−1/e)≈63% do ótimo para utilidade submodular e make-span ≤ 4/3 do ótimo (Graham). Nenhuma topologia fora da família supera o agendador | doc 12, Teorema 12.3 |
53
- | **UnidadeNLP** | Enriquecimento ADITIVO com porta g=σ(W_g h): traços morfo-sintáticos (conv 3/5-gramas), **intenção** (10 classes com entropia reportada), **spans de entidade** por apontador. Nasce NEUTRA (Δ=0 — Teorema 15.1: nunca regride ao acoplar) | doc 15 §1, Teorema 15.1 |
54
- | **UnidadeNLG** | Plano (pooling do prompt) + **condicionamento de estilo** (8 eixos aditivos) + **re-ranking de coerência** (tabela EMA de bigramas — penaliza bigramas inéditos no contexto). Sem parâmetros da lm_head (modula, não duplica) | doc 15 §1 |
55
- | **Janela de contexto 1M INDEXADA** | 3 níveis: fino (últimos 4096, atenção normal) → médio (**resumos** AttnPool por segmentos de 256 com overlap 50%, memória O(M·d)≈6 MB fp32) → grosso (**grade SOM** como índice invertido). Busca coarse-fine com **recall 1 certificável** (Teorema 13.1) e LRU por utilidade (Teorema 13.2) | doc 13 |
56
- | **Medusa especulativa em árvore** | Rascunho = MTP (logits empados K·d²) → poda `c_k=min(c,c−k)` → **verificação em UM forward** → **aceitação típica determinística** (Heim 2022) → correção residual. **Inocuidade comprovada**: a distribuição de saída é EXATAMENTE p_alvo (Teorema 14.1); speedup S=(E[aceitos]+1)/(1+\|T\|/V_ef) (Teorema 14.2) | doc 14 (absorvido de `medusa_speculative_decoder.py` + `multi_token_predictor.py`) |
57
- | **Duas fases** | **Fase A** (rede aumentada): tronco+MoE+MTP+NLP/NLG+DPO, **λ_som=0** (sem termo não-estacionário — Corolário 15.3). **Fase B**: tronco lr×0.1, 8 SOMs consolidam com objetivo `L_B=0.3·CE+λ_ativos(1−A)²+λ_nov·EQ` e reseeding guloso ⇒ **A ≥ 1−(1−π_min)^J** (Teorema 15.2) | doc 15 §2 |
58
- | **8 SOMs sem isolados — garantia** | S-SOM agora mantém hit_ema + reseeding por época; GCS ressemeia células sem uso; orquestrador delega a `kohonen`/`n1` — **A_global=1.0 medido em todas as 8 variantes** | doc 15, Teorema 15.2 |
59
- | **W8A8 melhorado** | **Escalas POR GRUPO** (g=64): erro RMS ≈ √g× menor que por tensor (Teorema 8.4) + **correção de viés** GPTQ-lite: Δb=E[aW]−E[a_qW_q] elimina o desvio de 1ª ordem (Teorema 8.5). Medido: Δperda = +0.00196 | doc 08 §§5–6 |
60
- | **vocab 16384 / n_experts_fusao 4** | Requisitos explícitos do escopo v4; 13.18M parâmetros totais | configs/base.json |
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
61
 
62
  ## Matemática (ler antes do código)
63
 
64
- - `00–09` (v1): Kohonen/GG/GCS/GSOM/H-SOM/TKM/RSOM/CPN/S-SOM, atenção mista+KV-cache, W8A8, ortogonais, punição, PDCA
65
- - `10` (v2): 13 teoremas (MoE agrupável, denso→SOM, MTP, DPO, PCGrad, ABMO)
66
- - `11` (v3): 12 teoremas — composição de microunidades, Hutchinson, K adaptativo, PRS V8, Beta/Bernstein/PAC-Bayes, memória
67
- - **`12` (v4): auto-escala por computo (Teoremas 12.1–12.2) + completude das 4 topologias via LPT/Nemhauser (Teorema 12.3)**
68
- - **`13` (v4): janela 1M indexada — cota de recall coarse-fine (13.1), finitude/determinismo (13.2), memória O(M·d)**
69
- - **`14` (v4): Medusa em árvore — inocuidade da aceitação típica (14.1), speedup esperado (14.2)**
70
- - **`15` (v4): NLP/NLG não-interferentes (15.1), cobertura gulosa dos ativos (15.2), por que duas fases (Corolário 15.3), métricas obrigatórias (§3)**
71
 
72
  ## Estrutura do repositório
73
 
74
  ```
75
  src/aurora/
76
- percepcao/escalacao.py # NOVO v4: PerfilComputo + EscaladorComputo (doc 12)
77
- nlp/unidade_nlp.py # NOVO v4: UnidadeNLP (traços, intenção, entidades)
78
- nlg/unidade_nlg.py # NOVO v4: UnidadeNLG (plano, estilo, re-ranking)
79
- nlg/decodificador_especulativo.py # NOVO v4: árvore Medusa (doc 14)
80
- memoria/janela_1m.py # NOVO v4: contexto 1M com compressão indexada
81
- treino/duas_fases.py # NOVO v4: RegimeDuasFases A→B (doc 15)
82
- treino/mtp.py # v4: +logits_rascunho (empatados K·d²)
83
- quanta/quantizacao.py # v4: +quantiza_por_grupo, correcao_vies, FakeQuantW8A8Grupo
84
- nucleo/modelo.py # v4: NLP no forward, NLG na geração, janela 1M,
85
- # reavaliar_computo, gerar_especulativo, métricas v4
86
- memoria/variantes_*.py # v4: S-SOM e GCS com reseeding — 0 isolados
87
- memoria/orquestrador.py # v4: taxa_ativos_global/telemetria_ativos (8 variantes)
88
  scripts/ # 01..07 (verificar→coletar→tokenizador→treinar→
89
  # avaliar→publicar→reconsolidar_som)
90
- configs/base.json # vocab 16384, n_experts_fusao 4, escalacao, nlp, nlg, janela_1m
91
- docs/matematica/ # 00–15: provas ANTES dos scripts
92
- tests/ # 23 (v1) + 36 (v2) + v3 + 37 (v4) verificações — todas verdes
93
- avaliacao_v4.json # evidências: perdas 9 tarefas, W8A8, SOM, coerência
94
- resumo_treino_v4.json # curva por época + métricas completas + neurônios ativos
95
- estados/fase-som-v4/ # pesos finais (modelo.safetensors + meta.json SHA-256)
 
 
96
  ```
97
 
98
  ## Pipeline (scripts organizados)
@@ -101,61 +116,24 @@ estados/fase-som-v4/ # pesos finais (modelo.safetensors + meta.json SHA
101
  pip install -r requirements.txt
102
  export HF_TOKEN=... # apenas variável de ambiente; NUNCA em arquivo
103
  python3 scripts/01_verificar_ambiente.py
104
- python3 scripts/02_coletar_corpus.py # um dataset por vez (19 fontes, streaming)
105
  python3 scripts/03_treinar_tokenizador.py # vocab 16384 (Rust BPE paralelo)
106
- python3 scripts/04_treinar.py --orcamento 460 # segmentos; Fase A→DPO→Fase B
107
- python3 scripts/05_avaliar.py # 13 blocos de evidências + coerência
108
- python3 scripts/06_publicar_hf.py # publicação ÚNICA e COMPLETA
109
  python3 scripts/07_reconsolidar_som.py # re-consolida SOM após correções pontuais
110
  ```
111
 
112
- ## Evidências de qualidade (ver `avaliacao_v4.json` — 2.793 passos × 6 épocas, 3.548 registros, 987 multimodais)
113
-
114
- | Métrica | Treinado | Aleatório |
115
- |---|---|---|
116
- | **ppl (LM)** | **22,3** | 17.011,7 |
117
- | perda imagem_caption | **1,93** | 9,74 |
118
- | perlda asr (áudio real) | 2,18 | 9,76 |
119
- | perda ocr (imagem real) | 2,29 | 9,75 |
120
- | perda vqa (imagem real) | 2,41 | 9,77 |
121
- | perda instrucao | 2,31 | 9,77 |
122
- | W8A8 Δperda | **+0,00196** | — |
123
- | **Neurônios ativos (8 variantes)** | **A_global = 1,00** (0 isolados) | — |
124
- | Memória interna | 15/16 consultas com acerto; 44/48 escritas aceitas | — |
125
- | Coerência (repetição de 3-gramas) | 0,74% @ corpus cheio | — |
126
- | Ancoragem de bigramas × tamanho do corpus | 0,7% (25%) → 7,1% (100%) — **cresce com os dados** | — |
127
-
128
- **Todas as 9 tarefas com perda treinado ≪ aleatório.** Métricas completas
129
- (neurônios ativos por variante, NLP/NLG, janela 1M, computo) em
130
- `resumo_treino_v4.json → metricas_completas`.
131
-
132
- ## Datasets (19 fontes, carregamento INDIVIDUAL, streaming=True)
133
-
134
- Texto/instrução: ultrachat_br, Canarim-Instruct, restore-punctuation,
135
- punctuation-ptbr, news-articles-ptbr, noticias_ptbr, corpus-ptbr-v1,
136
- corpus-carolina (degradado documentado). Multimodais (v2/v4): verbovision,
137
- MMMU-PT, MMMU-Pro-PT, OCRBench-PT, COCO-Caption2017-PT, imaginative-perception,
138
- ASR-leaderboard (mls/tedx/fleurs), pt-br-tts-synth, neurogrid-tts (degradado
139
- documentado). Cada fonte roda em SUBPROCESSO isolado — erro de uma nunca
140
- contamina a seguinte; dedup global por hash; cache limpo após cada fonte.
141
-
142
- ## Contratos do Agente Engenheiro (v4)
143
 
144
- - **Revisão antes de cada modificação** (erros de digitação/contratos) e
145
- **monotonia de capacidade**: nenhuma alteração remove funcionalidade
146
- (doc 09 §5, doc 12 Teorema 12.1a) — o módulo `bugwatch` foi REMOVIDO;
147
- asserções locais + revisão do agente assumiram o papel.
148
- - Correções v4 aplicadas com este protocolo: S-SOM (reseeding), GCS
149
- (reseeding), NLG re-ranking (shape (1,V)), poda de cabeças (view(-1)),
150
- telemetria (só escalares).
151
 
152
- ## Limitações honestas
153
 
154
- - 13,18M parâmetros em CPU (2 núcleos, 4 GB): a geração é fragmentada —
155
- coerência de longo prazo limitada pelo tamanho do modelo; a arquitetura
156
- (NLP/NLG, janela 1M, especulação) foi projetada para escalar com computo
157
- (Teorema 12.1) e as peças são as mesmas em GPU.
158
- - DPO com 91 passos em CPU: margem final negativa (−0,94) — requer mais passos
159
- para inverter a margem; β adaptativo chega ao piso 0,05 conforme projetado.
160
- - carolina (554 XML.gz) e neurogrid-tts (tars sem transcrições) permanecem
161
- degradados com adaptadores documentados — sem parquet/transcrição no repo.
 
4
  - pt
5
  tags:
6
  - mixture-of-experts
7
+ - cross-moe-attention
8
+ - kohonen
9
+ - som-attention
10
  - micro-units
11
  - transformer
12
  - cnn-bigru
13
  - bigru
 
 
14
  - multimodal
15
+ - diffusion
16
+ - stable-diffusion
17
  - multi-token-prediction
18
  - medusa
19
  - speculative-decoding
20
  - dpo
21
  - pcgrad
22
+ - int8
23
+ - torchao
24
+ - qat
25
+ - fp8
26
  - nlp
27
  - nlg
28
  - long-context
29
+ - engineer-agent
 
30
  - pt-br
 
31
  metrics:
32
  - perplexity
33
  ---
34
 
35
+ # AURORA v5 — Atenção entre MoEs e entre variantes Kohonen, difusão multimodal, quantização REAL (sem fakes) e Agente Engenheiro
36
 
37
  IA multimodal (texto, imagem, áudio, vídeo) **auto-aprendente** para português do
38
+ Brasil. A v5 **sobrescreve e aprimora** a v4 (treino refeito DO ZERO — estados
39
+ anteriores `estados/fase-som-v4` APAGADOS do Hub e do disco):
40
+
41
+ - **Atenção ENTRE camadas MoE** (doc 16 §§1–2): refinamento por atenção sobre o
42
+ conjunto de saídas dos experts da camada ℓ−1 + retroalimentação de rotas
43
+ (router memory) — nasce NEUTRA (α=β=0 ⇒ v4 exato; Teorema 16.1c: capacidades
44
+ nunca regridem);
45
+ - **Atenção ENTRE as 9 variantes de Kohonen** (doc 16 §§3–5): recall atencional
46
+ ẑ=Σ_v a_v z_v ∈ casco{∪_v W_v} (Teorema 16.3) + bônus de novidade a variantes
47
+ com neurônios órfãos + resemeadura ⇒ **ZERO neurônios isolados** (Teorema 16.5);
48
+ - **Difusão multimodal** (doc 17): `StableDiffusionPipeline`,
49
+ `StableDiffusionImg2ImgPipeline`, `StableDiffusionInpaintPipeline` com ciclo
50
+ FECHADO de compreensão geracional (NLG enriquece o prompt → difusão gera →
51
+ encoder perceptual re-encoda → memória SOM) e força de edição semanticamente
52
+ guiada (Teorema 17.1); degradação HONESTA (modo `planejado` — nunca pixels falsos);
53
+ - **Quantização 8-bits REAL, sem fakes** (doc 08 §§7–9): `FakeQuantW8A8`,
54
+ `FakeQuantW8A8Grupo` e `aplicar_w8_linear` REMOVIDOS; backends reais —
55
+ **torchao INT8 dinâmico** (CPU/GPU), **QAT universal** `prepare_qat`→`convert`
56
+ (x86/fbgemm/qnnpack), **FP8** (GPU H100+), **bitsandbytes weight-only** (GPU);
57
+ equivalência simulação↔kernel provada (Teorema 16.7);
58
+ - **Agente Engenheiro** (doc 16 §9): substitui o `bugwatch` REMOVIDO — revisão
59
+ pré-modificação (AST + ortografia + segredos) e **observação de TODAS as
60
+ métricas fundamentais de cada módulo durante TREINO e INFERÊNCIA** (73–87
61
+ métricas por passo) com garantia de não-regressão (Teorema 16.10);
62
+ - **Checkpoints locais + publicação ÚNICA** (doc 16 §8): nenhum upload parcial
63
+ durante o treino (o Hub bloqueia envios parciais em sequência curta); snapshot
64
+ final entra no commit único `estados/fase-v5/`.
65
+ - **Correções de bugs reais da v4** encontradas pela auditoria v5: (i) resemeadura
66
+ de SOM quebrava com mais mortos que amostras no lote (broadcast inválido);
67
+ (ii) recall da janela 1M comparava espaços distintos (resumo bruto × query
68
+ projetado) — recall coarse-fine restaurado (Teorema 13.1).
69
+
70
+ ## O que a v4 trouxe (preservado)
71
+
72
+ Auto-escala por computo (Teoremas 12.1–12.3, LPT/Nemhauser), unidades NLP/NLG de
73
+ primeira classe (Teorema 15.1 — nascem neutras), janela de contexto 1M indexada
74
+ (Teorema 13.1), Medusa especulativa em árvore (Teoremas 14.1–14.2, absorvida de
75
+ `medusa_speculative_decoder.py` + `multi_token_predictor.py`), duas fases de
76
+ treino (Fase A rede aumentada → Fase B consolidação SOM), MoE agrupável com
77
+ foco na tarefa, vocab **16384**, **n_experts_fusao=4**, DPO com β adaptativo,
78
+ PCGrad, punição/retreino (SGDR), W8A8 por grupo + correção de viés.
79
 
80
  ## Matemática (ler antes do código)
81
 
82
+ - `00–09` (v1): SOM clássico + 8 variantes, atenção mista + KV-cache, W8A8, ortogonais, punição, PDCA
83
+ - `10` (v2) · `11` (v3) · `12–15` (v4): MoE agrupável, microunidades, auto-escala, janela 1M, Medusa, NLP/NLG
84
+ - **`16` (v5): atenção entre MoEs (16.1–16.2), entre variantes SOM (16.3–16.5), custo (16.6), checkpoints (16.9), Agente Engenheiro (16.10)**
85
+ - **`17` (v5): difusão multimodal — força semântica (17.1), degradação honesta (17.2), enriquecimento NLG (17.3), contrato de memória (17.4)**
 
 
 
86
 
87
  ## Estrutura do repositório
88
 
89
  ```
90
  src/aurora/
91
+ percepcao/atencao_moe.py # NOVO v5: RefinamentoEntreMoEs (doc 16 §§1–2)
92
+ percepcao/moe.py # v5: hooks de refino + router memory (β)
93
+ memoria/atencao_som.py # NOVO v5: AtencaoEntreVariantes + anti-órfãos
94
+ memoria/orquestrador.py # v5: mapear_atencao (recall em TODAS as variantes)
95
+ geracao/difusao.py # NOVO v5: GeradorMultimodal (3 pipelines SD + ciclo fechado)
96
+ nlg/unidade_nlg.py # v5: enriquecer_prompt (Teorema 17.3)
97
+ quanta/quantizacao.py # v5 REFACTOR: fakes REMOVIDOS; backends reais §7.1–7.4
98
+ qualidade/agente_engenheiro.py # NOVO v5: revisão pré-modificação + métricas integrais
99
+ dados/checkpoints.py # NOVO v5: checkpoints locais + snapshot p/ commit único
100
+ # (dados/estados_hf.py REMOVIDO)
 
 
101
  scripts/ # 01..07 (verificar→coletar→tokenizador→treinar→
102
  # avaliar→publicar→reconsolidar_som)
103
+ configs/base.json # vocab 16384, n_experts_fusao 4, atencao_moe, som_atencao,
104
+ # difusao, agente_engenheiro, checkpoints
105
+ docs/matematica/ # 00–17: provas ANTES dos scripts
106
+ tests/ # 25 (v1) + 36 (v2) + v3 + 37 (v4) + 29 (v5) — TODAS verdes
107
+ avaliacao_v5.json # evidências: perdas 9 tarefas, SOM, coerência, difusão
108
+ resumo_treino_v5.json # curva por época + métricas completas + neurônios ativos
109
+ relatorio_agente_engenheiro.json # observação integral do treino/inferência
110
+ estados/fase-v5/ # pesos finais (modelo.safetensors + meta.json SHA-256)
111
  ```
112
 
113
  ## Pipeline (scripts organizados)
 
116
  pip install -r requirements.txt
117
  export HF_TOKEN=... # apenas variável de ambiente; NUNCA em arquivo
118
  python3 scripts/01_verificar_ambiente.py
119
+ python3 scripts/02_coletar_corpus.py # um dataset por vez (streaming, subprocesso)
120
  python3 scripts/03_treinar_tokenizador.py # vocab 16384 (Rust BPE paralelo)
121
+ python3 scripts/04_treinar.py --orcamento 460 # Fase A → DPO → Fase B (SOM)
122
+ python3 scripts/05_avaliar.py # evidências + coerência + Agente Engenheiro
123
+ python3 scripts/06_publicar_hf.py # publicação ÚNICA e COMPLETA (1 commit)
124
  python3 scripts/07_reconsolidar_som.py # re-consolida SOM após correções pontuais
125
  ```
126
 
127
+ ## Métricas observadas pelo Agente Engenheiro (treino + inferência)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
128
 
129
+ atenção (gates global/janela/linear) · MoE por camada (uso, entropia de rotas,
130
+ α de refino, β de retroalimentação) · microunidades (ramos ativos, recursão) ·
131
+ SOM e 8 variantes (k, taxa de ativos, EQ, órfãos=0) · atenção entre variantes
132
+ (pesos, entropia) · NLP (porta, intenção) · NLG (coerência de bigramas, estilo) ·
133
+ janela 1M (segmentos, hit de células) · memória interna · quantização (modo real,
134
+ erro QAT) · MTP (α) · computo (núcleos, RAM) · inferência (latência, repetição,
135
+ coerência).
136
 
137
+ ## Licença
138
 
139
+ MIT — ver `LICENSE`.
 
 
 
 
 
 
 
avaliacao_v5.json ADDED
@@ -0,0 +1,463 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "estado": "fase-som",
3
+ "perdas_tarefa": {
4
+ "lm": {
5
+ "treinado": 3.969290296236674,
6
+ "aleatorio": 9.747692743937174
7
+ },
8
+ "noticia": {
9
+ "treinado": 3.534764369328817,
10
+ "aleatorio": 9.765252272288004
11
+ },
12
+ "instrucao": {
13
+ "treinado": 2.8082671960194907,
14
+ "aleatorio": 9.733121077219645
15
+ },
16
+ "pontuacao": {
17
+ "treinado": 3.5151712894439697,
18
+ "aleatorio": 9.760367075602213
19
+ },
20
+ "imagem_caption": {
21
+ "treinado": 2.539171059926351,
22
+ "aleatorio": 9.747406005859375
23
+ },
24
+ "vqa": {
25
+ "treinado": 2.5748520294825235,
26
+ "aleatorio": 9.762024402618408
27
+ },
28
+ "ocr": {
29
+ "treinado": 2.6737791697184243,
30
+ "aleatorio": 9.686100641886393
31
+ },
32
+ "asr": {
33
+ "treinado": 2.6100575923919678,
34
+ "aleatorio": 9.762605349222818
35
+ },
36
+ "tts": {
37
+ "treinado": 2.0896825591723123,
38
+ "aleatorio": 9.767194430033365
39
+ }
40
+ },
41
+ "ppl_lm": 52.94694085919425,
42
+ "ppl_lm_aleatorio": 17114.695235444466,
43
+ "moe_uso_por_tarefa": {
44
+ "lm": [
45
+ {
46
+ "experts_top": [
47
+ 2,
48
+ 3
49
+ ],
50
+ "grupo_top": [
51
+ 1,
52
+ 1
53
+ ]
54
+ },
55
+ {
56
+ "experts_top": [
57
+ 0,
58
+ 1
59
+ ],
60
+ "grupo_top": [
61
+ 0,
62
+ 0
63
+ ]
64
+ }
65
+ ],
66
+ "vqa": [
67
+ {
68
+ "experts_top": [
69
+ 0,
70
+ 5
71
+ ],
72
+ "grupo_top": [
73
+ 0,
74
+ 2
75
+ ]
76
+ },
77
+ {
78
+ "experts_top": [
79
+ 5,
80
+ 2
81
+ ],
82
+ "grupo_top": [
83
+ 2,
84
+ 1
85
+ ]
86
+ }
87
+ ],
88
+ "ocr": [
89
+ {
90
+ "experts_top": [
91
+ 0,
92
+ 5
93
+ ],
94
+ "grupo_top": [
95
+ 0,
96
+ 2
97
+ ]
98
+ },
99
+ {
100
+ "experts_top": [
101
+ 2,
102
+ 5
103
+ ],
104
+ "grupo_top": [
105
+ 1,
106
+ 2
107
+ ]
108
+ }
109
+ ],
110
+ "asr": [
111
+ {
112
+ "experts_top": [
113
+ 5,
114
+ 4
115
+ ],
116
+ "grupo_top": [
117
+ 2,
118
+ 2
119
+ ]
120
+ },
121
+ {
122
+ "experts_top": [
123
+ 5,
124
+ 4
125
+ ],
126
+ "grupo_top": [
127
+ 2,
128
+ 2
129
+ ]
130
+ }
131
+ ],
132
+ "tts": [
133
+ {
134
+ "experts_top": [
135
+ 2,
136
+ 3
137
+ ],
138
+ "grupo_top": [
139
+ 1,
140
+ 1
141
+ ]
142
+ },
143
+ {
144
+ "experts_top": [
145
+ 0,
146
+ 1
147
+ ],
148
+ "grupo_top": [
149
+ 0,
150
+ 0
151
+ ]
152
+ }
153
+ ]
154
+ },
155
+ "mtp": {
156
+ "alphas": [
157
+ 0.9979780316352844,
158
+ 0.002021967666223645
159
+ ],
160
+ "per_cabeca": [
161
+ 3.655622959136963,
162
+ 8.975628852844238
163
+ ],
164
+ "entropia": 0.014563561417162418,
165
+ "termos_ce": 0.0
166
+ },
167
+ "w8a8_delta": 0.0001971721649169922,
168
+ "som_eq_fresco": {
169
+ "som": {
170
+ "taxa_ativos": 1.0,
171
+ "eq": 65.23129272460938
172
+ },
173
+ "gg": {
174
+ "taxa_ativos": 1.0,
175
+ "eq": 122.18740844726562
176
+ },
177
+ "gcs": {
178
+ "taxa_ativos": 1.0,
179
+ "eq": 117.88778686523438
180
+ },
181
+ "gsom": {
182
+ "taxa_ativos": 1.0,
183
+ "eq": 99.22010803222656
184
+ },
185
+ "tkm": {
186
+ "taxa_ativos": 1.0,
187
+ "eq": 60.810813903808594
188
+ },
189
+ "rsom": {
190
+ "taxa_ativos": 1.0,
191
+ "eq": 62.780548095703125
192
+ },
193
+ "ssom": {
194
+ "taxa_ativos": 1.0,
195
+ "eq": 62.07662582397461
196
+ }
197
+ },
198
+ "geracao": {
199
+ "sem_punicao": "quei Me rosa Bibliografia eventuat Brasilgicomertia propensos CrusoeIAbil jaqueta define Entenda Dani douradoszeáv cinco",
200
+ "com_punicao": " vencer29 motivar quebraV Mu sustentvesti obstáculosrist vem finas amarelos cer1807 existe Prática produziudicato dividem ma (\" XIX sandálias cres"
201
+ },
202
+ "microunidades": {
203
+ "lm": [
204
+ {
205
+ "ramos": [
206
+ "conv_dil",
207
+ "gru",
208
+ "mlp"
209
+ ],
210
+ "alpha_medio": [
211
+ 0.5487,
212
+ 0.193,
213
+ 0.2583
214
+ ],
215
+ "passos_rec": 2
216
+ },
217
+ {
218
+ "ramos": [
219
+ "conv_dil",
220
+ "gru",
221
+ "mlp",
222
+ "moe"
223
+ ],
224
+ "alpha_medio": [
225
+ 0.4241,
226
+ 0.1729,
227
+ 0.1852,
228
+ 0.2178
229
+ ],
230
+ "passos_rec": 2
231
+ },
232
+ {
233
+ "ramos": [
234
+ "conv_dil",
235
+ "gru",
236
+ "mlp",
237
+ "moe"
238
+ ],
239
+ "alpha_medio": [
240
+ 0.1482,
241
+ 0.257,
242
+ 0.3069,
243
+ 0.2879
244
+ ],
245
+ "passos_rec": 2
246
+ }
247
+ ],
248
+ "vqa": [
249
+ {
250
+ "ramos": [
251
+ "conv_dil",
252
+ "gru",
253
+ "mlp"
254
+ ],
255
+ "alpha_medio": [
256
+ 0.2699,
257
+ 0.307,
258
+ 0.4231
259
+ ],
260
+ "passos_rec": 2
261
+ },
262
+ {
263
+ "ramos": [
264
+ "conv_dil",
265
+ "gru",
266
+ "mlp",
267
+ "moe"
268
+ ],
269
+ "alpha_medio": [
270
+ 0.1819,
271
+ 0.2598,
272
+ 0.3016,
273
+ 0.2566
274
+ ],
275
+ "passos_rec": 2
276
+ },
277
+ {
278
+ "ramos": [
279
+ "conv_dil",
280
+ "gru",
281
+ "mlp",
282
+ "moe"
283
+ ],
284
+ "alpha_medio": [
285
+ 0.1684,
286
+ 0.2349,
287
+ 0.3153,
288
+ 0.2814
289
+ ],
290
+ "passos_rec": 2
291
+ }
292
+ ],
293
+ "asr": [
294
+ {
295
+ "ramos": [
296
+ "conv_dil",
297
+ "gru",
298
+ "mlp"
299
+ ],
300
+ "alpha_medio": [
301
+ 0.5496,
302
+ 0.193,
303
+ 0.2574
304
+ ],
305
+ "passos_rec": 2
306
+ },
307
+ {
308
+ "ramos": [
309
+ "conv_dil",
310
+ "gru",
311
+ "mlp",
312
+ "moe"
313
+ ],
314
+ "alpha_medio": [
315
+ 0.4064,
316
+ 0.1783,
317
+ 0.1796,
318
+ 0.2357
319
+ ],
320
+ "passos_rec": 2
321
+ },
322
+ {
323
+ "ramos": [
324
+ "conv_dil",
325
+ "gru",
326
+ "mlp",
327
+ "moe"
328
+ ],
329
+ "alpha_medio": [
330
+ 0.1466,
331
+ 0.251,
332
+ 0.3087,
333
+ 0.2937
334
+ ],
335
+ "passos_rec": 2
336
+ }
337
+ ],
338
+ "instrucao": [
339
+ {
340
+ "ramos": [
341
+ "conv_dil",
342
+ "gru",
343
+ "mlp"
344
+ ],
345
+ "alpha_medio": [
346
+ 0.394,
347
+ 0.254,
348
+ 0.3521
349
+ ],
350
+ "passos_rec": 2
351
+ },
352
+ {
353
+ "ramos": [
354
+ "conv_dil",
355
+ "gru",
356
+ "mlp",
357
+ "moe"
358
+ ],
359
+ "alpha_medio": [
360
+ 0.2664,
361
+ 0.2308,
362
+ 0.2519,
363
+ 0.2509
364
+ ],
365
+ "passos_rec": 2
366
+ },
367
+ {
368
+ "ramos": [
369
+ "conv_dil",
370
+ "gru",
371
+ "mlp",
372
+ "moe"
373
+ ],
374
+ "alpha_medio": [
375
+ 0.1497,
376
+ 0.2511,
377
+ 0.3212,
378
+ 0.278
379
+ ],
380
+ "passos_rec": 2
381
+ }
382
+ ]
383
+ },
384
+ "memoria_execucao": {
385
+ "slots": 32,
386
+ "capacidade": 32,
387
+ "escritas": 45,
388
+ "rejeitadas_confianca": 0,
389
+ "hit_rate": 1.0,
390
+ "comprimidos": 32,
391
+ "entropia_codebook": 3.5036063194274902,
392
+ "perda_vq": "tensor(5.3375)",
393
+ "violacoes_contrato": 0,
394
+ "economia_bits_por_slot": 0.9990234375,
395
+ "escritas_aceitas": 45,
396
+ "consultas_com_acerto": 15,
397
+ "comprimidos_agora": 32
398
+ },
399
+ "coerencia": {
400
+ "corpus_25pct": {
401
+ "n_registros": 887,
402
+ "repeticao_pct": 1.47,
403
+ "ancoragem_bigramas": 0.0071,
404
+ "entropia_logits": 6.4917
405
+ },
406
+ "corpus_50pct": {
407
+ "n_registros": 1774,
408
+ "repeticao_pct": 0.0,
409
+ "ancoragem_bigramas": 0.0071,
410
+ "entropia_logits": 6.4917
411
+ },
412
+ "corpus_100pct": {
413
+ "n_registros": 3548,
414
+ "repeticao_pct": 0.74,
415
+ "ancoragem_bigramas": 0.0071,
416
+ "entropia_logits": 6.4917
417
+ },
418
+ "amostras": [
419
+ " o ciclo pa — ? saudável participantes veículoA Globo e chão a conduzir mulher digital mal%4029 além con a pobrezaxon certamente projetados ",
420
+ " açúcar deixou ombro aprender rep deitado apatch eu sou O amigo significa esquerdo projetados mm eu cresceuVvel regularmente foco haviacios ",
421
+ " encontroA cidade 114 todas todasfeira pedir controle recduçãoduçãoduçãoduçãodução eu considerados desafioW em comparação ch é formada umaém",
422
+ " crucial pontos pontosA — ? considerados atingidade solo 2018 estendidas trás a frente produzir um sorriso O ch havia vez- em médio jeans14 "
423
+ ]
424
+ },
425
+ "inferencia_agente": {
426
+ "latencia_s": 0.4,
427
+ "tokens": 24,
428
+ "taxa_repeticao": 0.1667,
429
+ "coerencia_bigramas": 0.0
430
+ },
431
+ "difusao": {
432
+ "modo": "real",
433
+ "prompt_enriquecido": "o pantanal ao entardecer, com detalhes nítidos, com composição harmônica, com iluminação suave",
434
+ "latencia_s": 2.34,
435
+ "gerou_pixels": true
436
+ },
437
+ "agente_engenheiro": {
438
+ "revisoes_aprovadas": 0,
439
+ "revisoes_bloqueadas": 0,
440
+ "som_invariante_sem_orfaos": true,
441
+ "som_ativos": {
442
+ "ativos/som": 1.0,
443
+ "k/som": 24,
444
+ "ativos/gg": 1.0,
445
+ "k/gg": 4,
446
+ "ativos/gcs": 1.0,
447
+ "k/gcs": 3,
448
+ "ativos/gsom": 1.0,
449
+ "k/gsom": 4,
450
+ "ativos/hsom": 1.0,
451
+ "k/hsom": 12,
452
+ "ativos/tkm": 1.0,
453
+ "k/tkm": 32,
454
+ "ativos/rsom": 1.0,
455
+ "k/rsom": 32,
456
+ "ativos/cpn": 1.0,
457
+ "k/cpn": 24,
458
+ "ativos/ssom": 1.0,
459
+ "k/ssom": 24,
460
+ "A_global": 1.0
461
+ }
462
+ }
463
+ }
configs/base.json CHANGED
@@ -37,6 +37,10 @@
37
  "tau0": 0.8,
38
  "kappa_conf": 1.0,
39
  "delta_explora": 0.3
 
 
 
 
40
  }
41
  },
42
  "treino": {
@@ -122,12 +126,6 @@
122
  "n_sondas": 2
123
  }
124
  },
125
- "estados_hf": {
126
- "ativo": false,
127
- "repo_id": "PowerMachine/aurora-multimodal-ptbr",
128
- "pasta": "estados",
129
- "manter_ultimo_local": true
130
- },
131
  "ciclo": {
132
  "tau_escalada": 0.35,
133
  "entropia_limite": 0.85,
@@ -144,5 +142,27 @@
144
  "lambda_utilidade": 0.1,
145
  "meia_vida_s": 1800.0,
146
  "replay_a_cada": 40
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
147
  }
148
  }
 
37
  "tau0": 0.8,
38
  "kappa_conf": 1.0,
39
  "delta_explora": 0.3
40
+ },
41
+ "atencao_moe": {
42
+ "ativo": true,
43
+ "alpha0": 0.0
44
  }
45
  },
46
  "treino": {
 
126
  "n_sondas": 2
127
  }
128
  },
 
 
 
 
 
 
129
  "ciclo": {
130
  "tau_escalada": 0.35,
131
  "entropia_limite": 0.85,
 
142
  "lambda_utilidade": 0.1,
143
  "meia_vida_s": 1800.0,
144
  "replay_a_cada": 40
145
+ },
146
+ "checkpoints": {
147
+ "dir_local": "/home/z/my-project/aurora/estados_local",
148
+ "pasta_publicacao": "estados/fase-v5"
149
+ },
150
+ "som_atencao": {
151
+ "ativo": true,
152
+ "tau": 0.5,
153
+ "gamma_novidade": 0.15
154
+ },
155
+ "difusao": {
156
+ "ativo": true,
157
+ "repo_id": "hf-internal-testing/tiny-stable-diffusion-torch",
158
+ "altura": 128,
159
+ "largura": 128,
160
+ "passos_inferencia": 8,
161
+ "guia_escala": 7.5
162
+ },
163
+ "agente_engenheiro": {
164
+ "ativo": true,
165
+ "intervalo": 50,
166
+ "tolerancia_regressao": 0.05
167
  }
168
  }
docs/matematica/08-quantizacao-w8a8.md CHANGED
@@ -89,3 +89,25 @@ cruzado, quadrático nos erros de quantização — $O(\varepsilon^2)$. $\blacks
89
 
90
  Implementação: `quantiza_por_grupo` (fallback automático p/ dim < g) e
91
  `FakeQuantW8A8Grupo.calibrar` → `correcao_vies` (GPTQ-lite).
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
89
 
90
  Implementação: `quantiza_por_grupo` (fallback automático p/ dim < g) e
91
  `FakeQuantW8A8Grupo.calibrar` → `correcao_vies` (GPTQ-lite).
92
+
93
+ ## §§7–9 (v5) — Quantização REAL sem fakes
94
+
95
+ Refactor v5 (`quanta/quantizacao.py`): `FakeQuantW8A8`, `FakeQuantW8A8Grupo` e
96
+ `aplicar_w8_linear` REMOVIDOS. A inferência NUNCA é simulada — os backends reais:
97
+
98
+ §7.1 torchao `Int8DynamicActivationInt8WeightConfig` — kernels int8 reais (CPU/GPU);
99
+ §7.2 torch.ao.quantization `prepare_qat`→`convert` — Treinamento INT8 UNIVERSAL
100
+ (backend x86/fbgemm/qnnpack; conversão final REAL, fluxo do pedido);
101
+ §7.3 torchao.float8 `convert_to_float8` — treino nativo FP8 (GPU H100+; degrada
102
+ honesta em CPU);
103
+ §7.4 bitsandbytes `load_in_8bit=True` — weight-only 8-bit GPU (integração HF).
104
+
105
+ **Teorema 16.7 (equivalência).** Simulação round→clamp→dequantize e kernel int8
106
+ real implementam o MESMO mapa afim ⇒ erro idêntico; as cotas 8.1–8.5 valem ao
107
+ kernel. A diferença é VELOCIDADE/MEMÓRIA (Teorema 16.8: ≈3,76× com escalas por
108
+ grupo), não erro.
109
+ **§8 métricas honestas:** `metricas_qualidade` (erro relativo, SNR dB, erro máx).
110
+ **§9 diagnóstico:** `modo_quantizacao()` — disponibilidade real por backend.
111
+ Durante o TREINO mantém-se QAT com STE (Teorema 8.3) — classe `QATW8A8`
112
+ (metodologia idêntica ao prepare_qat, escalas por grupo) — mas a conversão de
113
+ exportação é sempre REAL (§7.1/§7.2).
docs/matematica/10-moe-foco-denso-som-v2.md CHANGED
@@ -265,7 +265,7 @@ log-space, (10.9) é subtração de δ_v = log pen(v) ∈ [0, log 1.2]. ∎
265
  ## 9. Protocolo de estados no HuggingFace (item c — poupar armazenamento)
266
 
267
  - **Serialização**: safetensors (sem pickle — segurança), um arquivo por estado:
268
- `estados/{tag}/modelo.safetensors` + `estados/{tag}/meta.json` (passo, época,
269
  perda, versão, hash SHA-256 do arquivo).
270
  - **Atomicidade**: `upload_file` do hf_hub é um commit único no repo — um estado
271
  visível é sempre completo. Deleção local somente após commit confirmado.
@@ -288,4 +288,4 @@ log-space, (10.9) é subtração de δ_v = log pen(v) ∈ [0, log 1.2]. ∎
288
  | 10.11 | `treino/treinador.py` (barreira LR) |
289
  | 10.12 | `quanta/quantizacao.py` (α-STE) |
290
  | 10.13 | `nucleo/modelo.py::gerar` |
291
- | §9 | `dados/estados_hf.py` |
 
265
  ## 9. Protocolo de estados no HuggingFace (item c — poupar armazenamento)
266
 
267
  - **Serialização**: safetensors (sem pickle — segurança), um arquivo por estado:
268
+ checkpoints LOCAIS `estados_local/{tag}/modelo.safetensors` + `meta.json` (passo, época,
269
  perda, versão, hash SHA-256 do arquivo).
270
  - **Atomicidade**: `upload_file` do hf_hub é um commit único no repo — um estado
271
  visível é sempre completo. Deleção local somente após commit confirmado.
 
288
  | 10.11 | `treino/treinador.py` (barreira LR) |
289
  | 10.12 | `quanta/quantizacao.py` (α-STE) |
290
  | 10.13 | `nucleo/modelo.py::gerar` |
291
+ | §9 | `dados/checkpoints.py` |
docs/matematica/16-atencao-entre-moes-e-som-v5.md ADDED
@@ -0,0 +1,124 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Doc 16 — Atenção entre MoEs, entre variantes Kohonen, checkpoints e Agente Engenheiro (v5)
2
+
3
+ Notação: docs 00–15 preservados. Novos símbolos: camadas MoE indexadas por ℓ∈{1..L};
4
+ experts por e∈{1..N} com N=G·E_g; variantes Kohonen por v∈𝒱, |𝒱|=9 (som, gg, gcs,
5
+ gsom, hsom, tkm, rsom, cpn, ssom); codebook da variante v: W_v∈R^{k_v×d}.
6
+
7
+ ## §1 Motivação (item 2 da 1ª requisição)
8
+
9
+ O doc 10 §1 roteia cada camada MoE INDEPENDENTEMENTE e o doc 03 §3 roteia cada
10
+ entrada a UMA variante SOM. Perdem-se: (i) a correlação entre padrões de
11
+ especialização de camadas adjacentes; (ii) a informação dos protótipos das 8
12
+ variantes não escolhidas; (iii) proteção ativa a neurônios pouco usados. A v5
13
+ adiciona atenção cruzada nos dois níveis, nascendo NEUTRA (α=β=0 ⇒ v4 exato).
14
+
15
+ ## §2 Atenção entre camadas MoE (eq. 16.1–16.2)
16
+
17
+ Saída da camada ℓ: y_ℓ(x)=Σ_e g_{ℓ,e}(x)·E_{ℓ,e}(x), g=softmax(s)∈Δ^N.
18
+ Empilhando as saídas Z_ℓ=[E_{ℓ,1}(x);…;E_{ℓ,N}(x)]∈R^{N×d}:
19
+
20
+ A_ℓ = softmax( (y_ℓ W_Q)(Z_{ℓ−1} W_K)^⊤ / √d ) ∈ Δ^N (16.1)
21
+ ỹ_ℓ = y_ℓ + α ⊙ A_ℓ (Z_{ℓ−1} W_V), α aprendível, init 0
22
+
23
+ Retroalimentação de rotas (router memory):
24
+ s_ℓ ← s_ℓ + β · ḡ_{ℓ−1}, ḡ_{ℓ−1}=média dos gates da camada ℓ−1, β init 0
25
+
26
+ **Teorema 16.1 (limitação do refinamento).** ‖ỹ_ℓ − y_ℓ‖₂ = |α|·‖A_ℓ(Z W_V)‖₂ ≤
27
+ |α|·max_e‖(Z_{ℓ−1}W_V)_e‖₂, pois A é soma convexa (softmax). Com
28
+ σ(W_V)≤1 e experts limitados ‖E_e‖≤M: ‖ỹ−y‖ ≤ |α|·M·1 — perturbação LIMITADA.
29
+ *Prova.* A linha da softmax é convexa ⇒ A_ℓ(ZW_V) ∈ casco{(ZW_V)_e}; norma de
30
+ soma convexa ≤ máx das normas (desigualdade triangular + pesos somando 1). ∎
31
+
32
+ **Teorema 16.1c (nascimento neutro / não-regressão).** α=β=0 ⇒ ỹ_ℓ≡y_ℓ, s_ℓ≡s_ℓ
33
+ (comportamento v4 EXATO). ∂ỹ/∂α = A_ℓ(Z_{ℓ−1}W_V) ≠ 0 ⇒ gradiente de α não nulo
34
+ após o primeiro passo; o treino abandona α=0 somente se REDUZIR a perda. O
35
+ espaço de hipóteses v4 é subespaço afim do v5 (fixando α=β=0) ⇒
36
+ min_v5 L ≤ min_v4 L — capacidades NUNCA regridem.
37
+
38
+ **Teorema 16.2 (estabilidade da retroalimentação).** O mapa de rotas
39
+ m_ℓ = softmax(s_ℓ + β·m_{ℓ−1}) é lipschitziano com constante ≤ |β|·L_max; a
40
+ softmax restringe a Δ^N (diametro finito) e é 1-lipschitziana em TV na entrada
41
+ quando os escores têm gap ≥ 0 (caso geral ≤ 1/4·√N em norma ℓ2 — Gao & Pavel
42
+ 2017). Para |β|<4/√N a composição em L camadas é CONTRAÇÃO com constante
43
+ (|β|·L_max)^L → 0: divergência impossível (análogo ao BIBO do RSOM, Teorema 5.3).
44
+ *Prova.* Indução em ℓ com desigualdade de Lipschitz composta. ∎
45
+
46
+ **Teorema 16.6 (custo).** A_ℓ é N×N: custo O(B·T·N·d) com N=6 — <1% do custo
47
+ dos experts O(B·T·N·d_ff) (d_ff_expert=160 ≥ 25·N/d… verificação numérica no
48
+ teste 16.6). A atenção entre variantes (§3) custa O(Σ_v k_v·d) dominado pelos
49
+ BMUs, mais matriz 9×9.
50
+
51
+ ## §3 Atenção entre variantes SOM (eq. 16.3–16.4)
52
+
53
+ Para a consulta x e cada variante v: z_v(x)=W_v[BMU_v(x)], d_v(x)=‖z_v(x)−x‖₂,
54
+ n_v = fração de neurônios órfãos de v (h_j EMA < ε, doc 10 §2.3).
55
+
56
+ a_v(x) = softmax( −d_v(x)/τ + γ·n_v ) (16.3)
57
+ ẑ(x) = Σ_v a_v(x)·z_v(x) (16.4)
58
+
59
+ **Teorema 16.3 (casco convexo — recall seguro).** ẑ(x) ∈ casco{∪_v W_v}.
60
+ *Prova.* ẑ = Σ_v a_v z_v com a_v∈Δ^{|𝒱|}; cada z_v ∈ W_v ⊂ ∪_v W_v; soma
61
+ convexa de pontos do conjunto fica no casco do conjunto. O recall NUNCA
62
+ extrapola fora da memória. ∎
63
+
64
+ **Teorema 16.4 (generalização do roteamento duro).** τ→0, γ=0 ⇒ a_v →
65
+ uniforme sobre o CONJUNTO de empate Argmin = {v : d_v = min_u d_u}. Se o
66
+ argmin é único, a_v → δ_{v*} (roteamento do doc 03 §3); com empates exatos,
67
+ a softmax converge ao protótipo MÉDIO do conjunto de empate. τ>0 e γ>0
68
+ interpola: variantes com EQ similar COOPERAM; variantes com órfãos recebem
69
+ tráfego extra. *Prova.* Limite dominante da softmax (exp((s_i−s_max)/τ)→1
70
+ sse s_i=s_max, →0 caso contrário). ∎
71
+
72
+ ## §4 Invariante: ZERO neurônios isolados (Teorema 16.5)
73
+
74
+ Mecanismo triplo, todos já presentes na v5:
75
+ (i) novidade-restrita-a-empates no treino SOM (doc 10 §2.3);
76
+ (ii) bônus de novidade nas rotas atencionais (eq. 16.3, γ>0);
77
+ (iii) resemeadura: órfãos relocalizados em amostras reais de pior EQ.
78
+
79
+ **Teorema 16.5 (cobertura assintótica).** Dados i.i.d. com cada região de
80
+ Voronoi de medida ≥ μ_min>0, taxa Robbins–Monro (Teorema 1.2) e (i)–(iii):
81
+ P[neurônio j órfão após T atualizações] ≤ (1−μ_min)^{c_T}, com c_T = nº de
82
+ amostras processadas (linear em T); para T ≥ (4/μ_min)·ln(k/δ):
83
+ P[algum órfão] ≤ Σ_j (1−μ_min)^{c_T} ≤ k·e^{−μ_min·c_T} ≤ δ (Hoeffding).
84
+ *Prova.* A amostra cai na região de j com prob. ≥ μ_min por amostra (i.i.d.);
85
+ contagens binomiais concentradas (Hoeffding); resemeadura reinicia o processo
86
+ de cobertura de células mortas com amostras REAIS (medida ≥ μ_min). ∎
87
+ O teste `testa_invariante_sem_orfas` verifica o invariante DEPOIS da
88
+ consolidação; `AtencaoEntreVariantes.verificar_sem_orfas` é o verificador
89
+ canônico (resemear=True corrige; resemear=False apenas reporta).
90
+
91
+ ## §5 Checkpoints locais e publicação ÚNICA (§8)
92
+
93
+ Regra v5 (bloqueio do Hub a uploads parciais em sequência curta):
94
+ • treino: checkpoints LOCAIS atômicos (safetensors + SHA-256; só o último
95
+ é mantido — Teorema 16.9: h(σ')=h(σ) ⇒ σ'=σ, retomada EXATA);
96
+ • publicação: UM ÚNICO commit com `upload_folder(delete_patterns=["*"])` —
97
+ todo o repo substituído atomicamente; o snapshot final entra como
98
+ `estados/fase-v5/` NESTE commit (nunca antes).
99
+ Implementação: `dados/checkpoints.py::GestorCheckpoints` (substitui
100
+ `dados/estados_hf.py`, REMOVIDO).
101
+
102
+ ## §6 Agente Engenheiro (§9)
103
+
104
+ Dois papéis:
105
+ 1. REVISÃO PRÉ-MODIFICAÇÃO (substitui o bugwatch REMOVIDO): AST + ortografia
106
+ de identificadores + padrão snake_case/CamelCase + varredura de segredos.
107
+ 2. OBSERVAÇÃO DE MÉTRICAS: treino e inferência — ver lista completa no
108
+ módulo `qualidade/agente_engenheiro.py` (87 métricas no smoke v5).
109
+
110
+ **Teorema 16.10 (não-regressão de capacidades).** Aprovar modificação ⟺
111
+ ‖max(0, C(t)−C(t+1))‖∞ ≤ ε (componente a componente, com métricas menor-e-
112
+ melhor invertidas). ε=5% padrão. Estruturas nascidas neutras (α=β=0, W_estilo=0,
113
+ Teorema 15.1) tornam o espaço v4 subespaço do v5, garantindo EXISTÊNCIA de
114
+ solução não-regressiva.
115
+
116
+ ## §7 Mapa de implementação
117
+
118
+ | Teorema | Módulo |
119
+ |---|---|
120
+ | 16.1/16.1c/16.2 | `percepcao/atencao_moe.py` + hooks em `percepcao/moe.py` |
121
+ | 16.3–16.5 | `memoria/atencao_som.py` + `orquestrador.py::mapear_atencao` |
122
+ | 16.6 | teste de custo (tests/test_aurora_v5.py) |
123
+ | 16.9 | `dados/checkpoints.py` |
124
+ | 16.10 | `qualidade/agente_engenheiro.py` |
docs/matematica/17-difusao-multimodal-v5.md ADDED
@@ -0,0 +1,69 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # Doc 17 — Geração multimodal por difusão (compreensão geracional, v5)
2
+
3
+ Notação: docs 00–16 preservados. Pipelines do diffusers importados EXATAMENTE
4
+ como especificado: `StableDiffusionPipeline`, `StableDiffusionImg2ImgPipeline`,
5
+ `StableDiffusionInpaintPipeline` (módulo `geracao/difusao.py`).
6
+
7
+ ## §1 Os três pipelines e seus papéis
8
+
9
+ | Pipeline | Papel na AURORA | Condição extra |
10
+ |---|---|---|
11
+ | StableDiffusionPipeline | texto→imagem (síntese do plano NLG) | prompt enriquecido (§3) |
12
+ | StableDiffusionImg2ImgPipeline | imagem→imagem (re-edição) | força semântica (§2) |
13
+ | StableDiffusionInpaintPipeline | edição por máscara | máscara de saliância |
14
+
15
+ ## §2 Força de edição semanticamente guiada
16
+
17
+ Sejam e_in = encoder perceptual(imagem de entrada) e e_plano = encoder(plano).
18
+ Definimos
19
+
20
+ strength = clip(1 − cos(e_in, e_plano), 0,35, 0,80) (17.1)
21
+
22
+ **Teorema 17.1 (monotonia).** ∂strength/∂cos ≤ 0 no domínio do clip:
23
+ cos=1 ⇒ strength=0,35 (edição leve — preserva conteúdo); cos=0 ⇒ 0,80
24
+ (recriação forte). A edições conservam tanto mais conteúdo quanto mais
25
+ similares entrada e plano. *Prova.* Derivada de 1−cos é −1<0; clip preserva
26
+ monotonia fraca. ∎
27
+
28
+ ## §3 Enriquecimento de prompt pela NLG
29
+
30
+ A UnidadeNLG (doc 15 §1) possui 8 eixos de estilo aprendíveis p=σ(eixos). O
31
+ enriquecimento seleciona qualificadores PT-BR por limiar (Teorema 17.3: o
32
+ mapa eixos→frases é determinístico e sem novos parâmetros — reusa p; logo a
33
+ geração é CONDICIONADA pelo estado aprendido da NLG, fechando o ciclo
34
+ linguagem→estilo→prompt).
35
+
36
+ ## §4 Ciclo fechado de compreensão geracional
37
+
38
+ 1. NLG enriquece o prompt (§3);
39
+ 2. difusão gera (txt2img/img2img/inpaint — §1);
40
+ 3. o ENCODER DE IMAGEM da AURORA re-encoda o resultado: e_out = E_img(imagem);
41
+ 4. e_out treina a memória SOM (orquestrador.treinar_memoria, 1 época) e
42
+ alimenta a janela 1M — gerações futuras condicionam nela.
43
+
44
+ **Teorema 17.2 (degradação honesta).** Sem GPU/diffusers/pesos, o gerador
45
+ opera em modo `planejado` (plano estruturado; NUNCA pixels falsos); a
46
+ telemetria registra o modo real (`real`|`planejado`). *Prova.* Construção do
47
+ módulo: `_obter_pipeline` retorna None em falha → `_plano(...)`. ∎
48
+
49
+ **Teorema 17.4 (contrato de memória do ciclo).** O protótipo do passo 4 é
50
+ inserido SOMENTE com stop-gradient (SOM treina por Kohonen, Teorema 10.5) —
51
+ a geração não corrompe a memória; melhora-a monotonicamente em EQ médio
52
+ crescente com nº de ciclos (Robbins–Monro, Teorema 1.2).
53
+
54
+ ## §5 Custo e limites
55
+
56
+ • Latência por imagem O(passos) no scheduler; default de teste: 8 passos a
57
+ 128×128 com repo TINY (executa em CPU/4GB); produção: 30–50 passos a
58
+ 512×512 em GPU ≥ 8GB (config `difusao.repo_id`).
59
+ • A difusão NUNCA roda dentro do loop de treino do decodificador — é
60
+ caminho de inferência/memória (isola o gradiente; Teorema 17.4).
61
+
62
+ ## §6 Mapa de implementação
63
+
64
+ | Item | Módulo |
65
+ |---|---|
66
+ | 3 pipelines + ciclo fechado | `geracao/difusao.py::GeradorMultimodal` |
67
+ | força semântica (17.1) | `forca_por_similaridade` |
68
+ | enriquecimento (17.3) | `nlg/unidade_nlg.py::enriquecer_prompt` |
69
+ | modo honesto (17.2) | `_plano` + `estatisticas()` |
estados/fase-v5/meta.json ADDED
@@ -0,0 +1,426 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "passo_global": 2394,
3
+ "epoca": 5,
4
+ "t_ciclo": 87,
5
+ "T_ciclo": 120,
6
+ "passos_epoca": 0,
7
+ "historico_epocas": [
8
+ {
9
+ "epoca": 0,
10
+ "perda_media": 3.948693869089839,
11
+ "avaliacao": {
12
+ "vqa": 2.2926554679870605,
13
+ "pontuacao": 4.211500406265259,
14
+ "instrucao": 3.107147455215454,
15
+ "tts": 2.3355257511138916,
16
+ "lm": 3.946152170499166,
17
+ "imagem_caption": 3.366687218348185,
18
+ "ocr": 4.327888528505961,
19
+ "noticia": 3.820330262184143,
20
+ "asr": 3.4765865008036294,
21
+ "ppl_lm": 51.73591237764998
22
+ },
23
+ "eq_som": 0.32069775462150574,
24
+ "punicoes": 2,
25
+ "prs": {
26
+ "trust": 0.6452,
27
+ "tau": 3.39947,
28
+ "clip": 1.9503,
29
+ "boost": 1.0,
30
+ "streak": 0,
31
+ "ciclos_sgdr": 0,
32
+ "recompensa_acum": 27.089,
33
+ "beta_min_relativo": 0.645
34
+ },
35
+ "confianca": {
36
+ "h_ema": 0.3502193093299866,
37
+ "ece": 0.18838383838383843,
38
+ "posterior": {
39
+ "media": 0.4158415841584158,
40
+ "bernstein": [
41
+ 0.2589389772764638,
42
+ 0.5727441910403679
43
+ ]
44
+ }
45
+ },
46
+ "memoria": {
47
+ "slots": 14,
48
+ "capacidade": 64,
49
+ "escritas": 14,
50
+ "rejeitadas_confianca": 10,
51
+ "hit_rate": 1.0,
52
+ "comprimidos": 0,
53
+ "entropia_codebook": 1.4736544073912228e-07,
54
+ "perda_vq": null,
55
+ "violacoes_contrato": 0,
56
+ "economia_bits_por_slot": 0.9990234375
57
+ },
58
+ "crescimento": []
59
+ },
60
+ {
61
+ "epoca": 1,
62
+ "perda_media": 2.0532733849678304,
63
+ "avaliacao": {
64
+ "vqa": 1.4824253519376118,
65
+ "pontuacao": 2.131925086180369,
66
+ "instrucao": 1.390481968720754,
67
+ "tts": 1.0957754055658977,
68
+ "lm": 2.2470853328704834,
69
+ "imagem_caption": 1.286858816941579,
70
+ "ocr": 1.997893512248993,
71
+ "noticia": 2.1131044228871665,
72
+ "asr": 1.7342400550842285,
73
+ "ppl_lm": 9.460122505964561
74
+ },
75
+ "eq_som": 0.718850314617157,
76
+ "punicoes": 2,
77
+ "prs": {
78
+ "trust": 0.6267,
79
+ "tau": 1.35451,
80
+ "clip": 1.4427,
81
+ "boost": 1.0,
82
+ "streak": 0,
83
+ "ciclos_sgdr": 0,
84
+ "recompensa_acum": 23.14,
85
+ "beta_min_relativo": 0.627
86
+ },
87
+ "confianca": {
88
+ "h_ema": 0.46430060267448425,
89
+ "ece": 0.09846625766871163,
90
+ "posterior": {
91
+ "media": 0.3151515151515151,
92
+ "bernstein": [
93
+ 0.20230581617392568,
94
+ 0.4279972141291046
95
+ ]
96
+ }
97
+ },
98
+ "memoria": {
99
+ "slots": 30,
100
+ "capacidade": 64,
101
+ "escritas": 30,
102
+ "rejeitadas_confianca": 11,
103
+ "hit_rate": 1.0,
104
+ "comprimidos": 0,
105
+ "entropia_codebook": 1.4736544073912228e-07,
106
+ "perda_vq": null,
107
+ "violacoes_contrato": 0,
108
+ "economia_bits_por_slot": 0.9990234375
109
+ },
110
+ "crescimento": []
111
+ },
112
+ {
113
+ "epoca": 2,
114
+ "perda_media": 1.5224218368530273,
115
+ "avaliacao": {
116
+ "vqa": 1.4163412346194189,
117
+ "pontuacao": 2.333530286947886,
118
+ "instrucao": 1.3709475596745808,
119
+ "tts": 1.0405537287394206,
120
+ "lm": 2.1947638988494873,
121
+ "imagem_caption": 1.376509666442871,
122
+ "ocr": 1.8052047491073608,
123
+ "noticia": 2.0684971809387207,
124
+ "asr": 1.1847476959228516,
125
+ "ppl_lm": 8.977881118508035
126
+ },
127
+ "eq_som": 1.0113035440444946,
128
+ "punicoes": 1,
129
+ "prs": {
130
+ "trust": 0.481,
131
+ "tau": 1.19838,
132
+ "clip": 1.9061,
133
+ "boost": 1.0,
134
+ "streak": 1,
135
+ "ciclos_sgdr": 0,
136
+ "recompensa_acum": 3.865,
137
+ "beta_min_relativo": 2.0
138
+ },
139
+ "confianca": {
140
+ "h_ema": 0.5285777449607849,
141
+ "ece": 0.1644927536231884,
142
+ "posterior": {
143
+ "media": 0.2535211267605634,
144
+ "bernstein": [
145
+ 0.07962843317183893,
146
+ 0.4274138203492878
147
+ ]
148
+ }
149
+ },
150
+ "memoria": {
151
+ "slots": 15,
152
+ "capacidade": 64,
153
+ "escritas": 15,
154
+ "rejeitadas_confianca": 2,
155
+ "hit_rate": 1.0,
156
+ "comprimidos": 0,
157
+ "entropia_codebook": 1.4736544073912228e-07,
158
+ "perda_vq": null,
159
+ "violacoes_contrato": 0,
160
+ "economia_bits_por_slot": 0.9990234375
161
+ },
162
+ "crescimento": []
163
+ },
164
+ {
165
+ "epoca": 3,
166
+ "perda_media": 1.2691485638467548,
167
+ "avaliacao": {
168
+ "vqa": 0.9392901112635931,
169
+ "pontuacao": 1.708681543668111,
170
+ "instrucao": 1.2250610888004303,
171
+ "tts": 0.6326843549807867,
172
+ "lm": 1.7027111649513245,
173
+ "imagem_caption": 1.1741904218991597,
174
+ "ocr": 0.7859109739462534,
175
+ "noticia": 1.3640264868736267,
176
+ "asr": 0.8967958589394888,
177
+ "ppl_lm": 5.488808302127935
178
+ },
179
+ "eq_som": 1.1620084047317505,
180
+ "punicoes": 3,
181
+ "prs": {
182
+ "trust": 0.4739,
183
+ "tau": 0.90808,
184
+ "clip": 2.1039,
185
+ "boost": 1.0,
186
+ "streak": 0,
187
+ "ciclos_sgdr": 0,
188
+ "recompensa_acum": 15.129,
189
+ "beta_min_relativo": 2.0
190
+ },
191
+ "confianca": {
192
+ "h_ema": 0.37054377794265747,
193
+ "ece": 0.25000000000000006,
194
+ "posterior": {
195
+ "media": 0.23417721518987342,
196
+ "bernstein": [
197
+ 0.12739020998462738,
198
+ 0.3409642203951194
199
+ ]
200
+ }
201
+ },
202
+ "memoria": {
203
+ "slots": 38,
204
+ "capacidade": 64,
205
+ "escritas": 38,
206
+ "rejeitadas_confianca": 1,
207
+ "hit_rate": 1.0,
208
+ "comprimidos": 0,
209
+ "entropia_codebook": 1.4736544073912228e-07,
210
+ "perda_vq": null,
211
+ "violacoes_contrato": 0,
212
+ "economia_bits_por_slot": 0.9990234375
213
+ },
214
+ "crescimento": []
215
+ },
216
+ {
217
+ "epoca": 4,
218
+ "perda_media": 1.647582643561893,
219
+ "avaliacao": {
220
+ "vqa": 1.2144984665016334,
221
+ "pontuacao": 2.198017636934916,
222
+ "instrucao": 1.4627658526102703,
223
+ "tts": 0.8890816271305084,
224
+ "lm": 2.005878428618113,
225
+ "imagem_caption": 1.4931794007619221,
226
+ "ocr": 1.9250603119532268,
227
+ "noticia": 1.846806824207306,
228
+ "asr": 1.42787371079127,
229
+ "ppl_lm": 7.432620056120455
230
+ },
231
+ "eq_som": 1.3965169191360474,
232
+ "punicoes": 1,
233
+ "prs": {
234
+ "trust": 0.6554,
235
+ "tau": 1.42016,
236
+ "clip": 2.9561,
237
+ "boost": 1.0,
238
+ "streak": 0,
239
+ "ciclos_sgdr": 0,
240
+ "recompensa_acum": 12.061,
241
+ "beta_min_relativo": 0.655
242
+ },
243
+ "confianca": {
244
+ "h_ema": 0.2993004024028778,
245
+ "ece": 0.18333333333333332,
246
+ "posterior": {
247
+ "media": 0.44680851063829785,
248
+ "bernstein": [
249
+ 0.1995713077457135,
250
+ 0.6940457135308822
251
+ ]
252
+ }
253
+ },
254
+ "memoria": {
255
+ "slots": 8,
256
+ "capacidade": 64,
257
+ "escritas": 8,
258
+ "rejeitadas_confianca": 3,
259
+ "hit_rate": 1.0,
260
+ "comprimidos": 0,
261
+ "entropia_codebook": 1.4736544073912228e-07,
262
+ "perda_vq": null,
263
+ "violacoes_contrato": 0,
264
+ "economia_bits_por_slot": 0.9990234375
265
+ },
266
+ "crescimento": []
267
+ },
268
+ {
269
+ "epoca": 5,
270
+ "perda_media": 1.6497120559215546,
271
+ "avaliacao": {
272
+ "vqa": 0.5591112061714133,
273
+ "pontuacao": 2.028630475203196,
274
+ "instrucao": 1.4438494443893433,
275
+ "tts": 0.6653600136439005,
276
+ "lm": 1.8496814568837483,
277
+ "imagem_caption": 1.381531576315562,
278
+ "ocr": 1.4207946757475536,
279
+ "noticia": 1.916561484336853,
280
+ "asr": 1.0018239219983418,
281
+ "ppl_lm": 6.357793968502589
282
+ },
283
+ "eq_som": 2.6723616123199463,
284
+ "punicoes": 1,
285
+ "prs": {
286
+ "trust": 0.4971,
287
+ "tau": 1.00865,
288
+ "clip": 5.0,
289
+ "boost": 1.0,
290
+ "streak": 1,
291
+ "ciclos_sgdr": 0,
292
+ "recompensa_acum": 0.333,
293
+ "beta_min_relativo": 2.0
294
+ },
295
+ "confianca": {
296
+ "h_ema": 0.6000000238418579,
297
+ "ece": 0.42499999999999993,
298
+ "posterior": {
299
+ "media": 0.3333333333333333,
300
+ "bernstein": [
301
+ 0.0,
302
+ 1.0
303
+ ]
304
+ }
305
+ },
306
+ "memoria": {
307
+ "slots": 1,
308
+ "capacidade": 64,
309
+ "escritas": 1,
310
+ "rejeitadas_confianca": 0,
311
+ "hit_rate": 0.0,
312
+ "comprimidos": 0,
313
+ "entropia_codebook": 1.4736544073912228e-07,
314
+ "perda_vq": null,
315
+ "violacoes_contrato": 0,
316
+ "economia_bits_por_slot": 0.9990234375
317
+ },
318
+ "crescimento": []
319
+ }
320
+ ],
321
+ "L_hat": 1.1197311365208105,
322
+ "som": {
323
+ "variante_ativa": "cpn",
324
+ "variantes": {
325
+ "som": {
326
+ "k": 24,
327
+ "taxa_ativos": 1.0,
328
+ "resemeados": 24,
329
+ "usos": 256,
330
+ "atingiu_alvo": true
331
+ },
332
+ "gg": {
333
+ "k": 4,
334
+ "taxa_ativos": 1.0,
335
+ "resemeados": 4,
336
+ "usos": 256,
337
+ "atingiu_alvo": true
338
+ },
339
+ "gcs": {
340
+ "k": 3,
341
+ "arestas": 3,
342
+ "eq_treino": 28633.626953125,
343
+ "atingiu_alvo": true
344
+ },
345
+ "gsom": {
346
+ "k": 38,
347
+ "gt": 1.05,
348
+ "erro_medio": 0.0,
349
+ "atingiu_alvo": true
350
+ },
351
+ "hsom": {},
352
+ "tkm": {
353
+ "k": 32,
354
+ "taxa_ativos": 1.0,
355
+ "resemeados": 32,
356
+ "usos": 256,
357
+ "atingiu_alvo": true
358
+ },
359
+ "rsom": {
360
+ "k": 32,
361
+ "taxa_ativos": 1.0,
362
+ "resemeados": 32,
363
+ "usos": 256,
364
+ "atingiu_alvo": true
365
+ },
366
+ "cpn": {},
367
+ "ssom": {
368
+ "k": 24,
369
+ "taxa_ativos": 1.0,
370
+ "resemeados": 22,
371
+ "usos": 0,
372
+ "atingiu_alvo": true
373
+ }
374
+ },
375
+ "invariante_sem_orfaos": true,
376
+ "orfaos_por_variante": {
377
+ "som": {
378
+ "orfaos": 0,
379
+ "relocados": 0,
380
+ "taxa_ativos": 1.0
381
+ },
382
+ "gg": {
383
+ "orfaos": 0,
384
+ "relocados": 0,
385
+ "taxa_ativos": 1.0
386
+ },
387
+ "gcs": {
388
+ "orfaos": 0,
389
+ "relocados": 0,
390
+ "taxa_ativos": 1.0
391
+ },
392
+ "gsom": {
393
+ "orfaos": 0,
394
+ "relocados": 0,
395
+ "taxa_ativos": 1.0
396
+ },
397
+ "hsom": {
398
+ "orfaos": 0,
399
+ "relocados": 0
400
+ },
401
+ "tkm": {
402
+ "orfaos": 0,
403
+ "relocados": 0,
404
+ "taxa_ativos": 1.0
405
+ },
406
+ "rsom": {
407
+ "orfaos": 0,
408
+ "relocados": 0,
409
+ "taxa_ativos": 1.0
410
+ },
411
+ "cpn": {
412
+ "orfaos": 0,
413
+ "relocados": 0,
414
+ "taxa_ativos": 1.0
415
+ },
416
+ "ssom": {
417
+ "orfaos": 0,
418
+ "relocados": 0,
419
+ "taxa_ativos": 1.0
420
+ }
421
+ }
422
+ },
423
+ "hash_sha256": "1683fe2624533dd9114322a37a2344aceb1d14b9f987f33bd2e7ead7dc21a021",
424
+ "tag": "fase-som",
425
+ "publicado_em_commit_unico": true
426
+ }
estados/fase-v5/modelo.safetensors ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:1683fe2624533dd9114322a37a2344aceb1d14b9f987f33bd2e7ead7dc21a021
3
+ size 59248537
relatorio_agente_engenheiro.json ADDED
@@ -0,0 +1,76 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "t": 1788843935.61,
3
+ "revisoes_aprovadas": 0,
4
+ "revisoes_bloqueadas": 0,
5
+ "tolerancia_regressao": 0.05,
6
+ "som_variantes": {
7
+ "ativa": "cpn",
8
+ "motivo": "roteamento estado→ação (CPN, Teorema 6.1)",
9
+ "som": {
10
+ "k": 24,
11
+ "taxa_ativos": 1.0,
12
+ "resemeados": 0,
13
+ "usos": 0
14
+ },
15
+ "gg": {
16
+ "k": 4,
17
+ "taxa_ativos": 1.0,
18
+ "resemeados": 0,
19
+ "usos": 0
20
+ },
21
+ "gcs": {
22
+ "k": 3,
23
+ "arestas": 3,
24
+ "eq_treino": 0.0
25
+ },
26
+ "gsom": {
27
+ "k": 4,
28
+ "gt": 1.05,
29
+ "erro_medio": 0.0
30
+ },
31
+ "tkm": {
32
+ "k": 32,
33
+ "taxa_ativos": 1.0,
34
+ "resemeados": 0,
35
+ "usos": 0
36
+ },
37
+ "rsom": {
38
+ "k": 32,
39
+ "taxa_ativos": 1.0,
40
+ "resemeados": 0,
41
+ "usos": 0
42
+ },
43
+ "ssom": {
44
+ "k": 24,
45
+ "taxa_ativos": 1.0,
46
+ "resemeados": 0,
47
+ "usos": 0
48
+ }
49
+ },
50
+ "som_ativos": {
51
+ "ativos/som": 1.0,
52
+ "k/som": 24,
53
+ "ativos/gg": 1.0,
54
+ "k/gg": 4,
55
+ "ativos/gcs": 1.0,
56
+ "k/gcs": 3,
57
+ "ativos/gsom": 1.0,
58
+ "k/gsom": 4,
59
+ "ativos/hsom": 1.0,
60
+ "k/hsom": 12,
61
+ "ativos/tkm": 1.0,
62
+ "k/tkm": 32,
63
+ "ativos/rsom": 1.0,
64
+ "k/rsom": 32,
65
+ "ativos/cpn": 1.0,
66
+ "k/cpn": 24,
67
+ "ativos/ssom": 1.0,
68
+ "k/ssom": 24,
69
+ "A_global": 1.0
70
+ },
71
+ "som_invariante_sem_orfaos": true,
72
+ "avaliacao": {
73
+ "ppl_lm": 52.94694085919425
74
+ },
75
+ "ultimos_bloqueios": []
76
+ }
requirements.txt CHANGED
@@ -1,11 +1,11 @@
1
- torch>=2.2
2
- datasets>=2.19
3
- tokenizers>=0.19
4
- huggingface_hub>=0.23
5
- numpy>=1.26
6
  safetensors>=0.4
7
- # opcionais (degradação graciosa implementada):
8
- # pypdf # parser de PDF
9
- # openpyxl # parser de XLSX
10
- # python-docx # parser de DOCX
11
- # bitsandbytes # W8A8 int8 real em CUDA (CPU usa caminho simétrico puro-PyTorch)
 
 
 
1
+ torch>=2.4
2
+ datasets>=3.0
3
+ tokenizers>=0.20
 
 
4
  safetensors>=0.4
5
+ huggingface_hub>=0.25
6
+ numpy>=1.26
7
+ pillow>=10.0
8
+ diffusers>=0.31
9
+ transformers>=4.44
10
+ accelerate>=0.34
11
+ torchao>=0.4
resumo_treino_v5.json ADDED
@@ -0,0 +1,670 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "versao": "v5-atencao-moe-som-16384",
3
+ "epocas": [
4
+ {
5
+ "epoca": 0,
6
+ "perda_media": 3.948693869089839,
7
+ "avaliacao": {
8
+ "vqa": 2.2926554679870605,
9
+ "pontuacao": 4.211500406265259,
10
+ "instrucao": 3.107147455215454,
11
+ "tts": 2.3355257511138916,
12
+ "lm": 3.946152170499166,
13
+ "imagem_caption": 3.366687218348185,
14
+ "ocr": 4.327888528505961,
15
+ "noticia": 3.820330262184143,
16
+ "asr": 3.4765865008036294,
17
+ "ppl_lm": 51.73591237764998
18
+ },
19
+ "eq_som": 0.32069775462150574,
20
+ "punicoes": 2,
21
+ "prs": {
22
+ "trust": 0.6452,
23
+ "tau": 3.39947,
24
+ "clip": 1.9503,
25
+ "boost": 1.0,
26
+ "streak": 0,
27
+ "ciclos_sgdr": 0,
28
+ "recompensa_acum": 27.089,
29
+ "beta_min_relativo": 0.645
30
+ },
31
+ "confianca": {
32
+ "h_ema": 0.3502193093299866,
33
+ "ece": 0.18838383838383843,
34
+ "posterior": {
35
+ "media": 0.4158415841584158,
36
+ "bernstein": [
37
+ 0.2589389772764638,
38
+ 0.5727441910403679
39
+ ]
40
+ }
41
+ },
42
+ "memoria": {
43
+ "slots": 14,
44
+ "capacidade": 64,
45
+ "escritas": 14,
46
+ "rejeitadas_confianca": 10,
47
+ "hit_rate": 1.0,
48
+ "comprimidos": 0,
49
+ "entropia_codebook": 1.4736544073912228e-07,
50
+ "perda_vq": null,
51
+ "violacoes_contrato": 0,
52
+ "economia_bits_por_slot": 0.9990234375
53
+ },
54
+ "crescimento": []
55
+ },
56
+ {
57
+ "epoca": 1,
58
+ "perda_media": 2.0532733849678304,
59
+ "avaliacao": {
60
+ "vqa": 1.4824253519376118,
61
+ "pontuacao": 2.131925086180369,
62
+ "instrucao": 1.390481968720754,
63
+ "tts": 1.0957754055658977,
64
+ "lm": 2.2470853328704834,
65
+ "imagem_caption": 1.286858816941579,
66
+ "ocr": 1.997893512248993,
67
+ "noticia": 2.1131044228871665,
68
+ "asr": 1.7342400550842285,
69
+ "ppl_lm": 9.460122505964561
70
+ },
71
+ "eq_som": 0.718850314617157,
72
+ "punicoes": 2,
73
+ "prs": {
74
+ "trust": 0.6267,
75
+ "tau": 1.35451,
76
+ "clip": 1.4427,
77
+ "boost": 1.0,
78
+ "streak": 0,
79
+ "ciclos_sgdr": 0,
80
+ "recompensa_acum": 23.14,
81
+ "beta_min_relativo": 0.627
82
+ },
83
+ "confianca": {
84
+ "h_ema": 0.46430060267448425,
85
+ "ece": 0.09846625766871163,
86
+ "posterior": {
87
+ "media": 0.3151515151515151,
88
+ "bernstein": [
89
+ 0.20230581617392568,
90
+ 0.4279972141291046
91
+ ]
92
+ }
93
+ },
94
+ "memoria": {
95
+ "slots": 30,
96
+ "capacidade": 64,
97
+ "escritas": 30,
98
+ "rejeitadas_confianca": 11,
99
+ "hit_rate": 1.0,
100
+ "comprimidos": 0,
101
+ "entropia_codebook": 1.4736544073912228e-07,
102
+ "perda_vq": null,
103
+ "violacoes_contrato": 0,
104
+ "economia_bits_por_slot": 0.9990234375
105
+ },
106
+ "crescimento": []
107
+ },
108
+ {
109
+ "epoca": 2,
110
+ "perda_media": 1.5224218368530273,
111
+ "avaliacao": {
112
+ "vqa": 1.4163412346194189,
113
+ "pontuacao": 2.333530286947886,
114
+ "instrucao": 1.3709475596745808,
115
+ "tts": 1.0405537287394206,
116
+ "lm": 2.1947638988494873,
117
+ "imagem_caption": 1.376509666442871,
118
+ "ocr": 1.8052047491073608,
119
+ "noticia": 2.0684971809387207,
120
+ "asr": 1.1847476959228516,
121
+ "ppl_lm": 8.977881118508035
122
+ },
123
+ "eq_som": 1.0113035440444946,
124
+ "punicoes": 1,
125
+ "prs": {
126
+ "trust": 0.481,
127
+ "tau": 1.19838,
128
+ "clip": 1.9061,
129
+ "boost": 1.0,
130
+ "streak": 1,
131
+ "ciclos_sgdr": 0,
132
+ "recompensa_acum": 3.865,
133
+ "beta_min_relativo": 2.0
134
+ },
135
+ "confianca": {
136
+ "h_ema": 0.5285777449607849,
137
+ "ece": 0.1644927536231884,
138
+ "posterior": {
139
+ "media": 0.2535211267605634,
140
+ "bernstein": [
141
+ 0.07962843317183893,
142
+ 0.4274138203492878
143
+ ]
144
+ }
145
+ },
146
+ "memoria": {
147
+ "slots": 15,
148
+ "capacidade": 64,
149
+ "escritas": 15,
150
+ "rejeitadas_confianca": 2,
151
+ "hit_rate": 1.0,
152
+ "comprimidos": 0,
153
+ "entropia_codebook": 1.4736544073912228e-07,
154
+ "perda_vq": null,
155
+ "violacoes_contrato": 0,
156
+ "economia_bits_por_slot": 0.9990234375
157
+ },
158
+ "crescimento": []
159
+ },
160
+ {
161
+ "epoca": 3,
162
+ "perda_media": 1.2691485638467548,
163
+ "avaliacao": {
164
+ "vqa": 0.9392901112635931,
165
+ "pontuacao": 1.708681543668111,
166
+ "instrucao": 1.2250610888004303,
167
+ "tts": 0.6326843549807867,
168
+ "lm": 1.7027111649513245,
169
+ "imagem_caption": 1.1741904218991597,
170
+ "ocr": 0.7859109739462534,
171
+ "noticia": 1.3640264868736267,
172
+ "asr": 0.8967958589394888,
173
+ "ppl_lm": 5.488808302127935
174
+ },
175
+ "eq_som": 1.1620084047317505,
176
+ "punicoes": 3,
177
+ "prs": {
178
+ "trust": 0.4739,
179
+ "tau": 0.90808,
180
+ "clip": 2.1039,
181
+ "boost": 1.0,
182
+ "streak": 0,
183
+ "ciclos_sgdr": 0,
184
+ "recompensa_acum": 15.129,
185
+ "beta_min_relativo": 2.0
186
+ },
187
+ "confianca": {
188
+ "h_ema": 0.37054377794265747,
189
+ "ece": 0.25000000000000006,
190
+ "posterior": {
191
+ "media": 0.23417721518987342,
192
+ "bernstein": [
193
+ 0.12739020998462738,
194
+ 0.3409642203951194
195
+ ]
196
+ }
197
+ },
198
+ "memoria": {
199
+ "slots": 38,
200
+ "capacidade": 64,
201
+ "escritas": 38,
202
+ "rejeitadas_confianca": 1,
203
+ "hit_rate": 1.0,
204
+ "comprimidos": 0,
205
+ "entropia_codebook": 1.4736544073912228e-07,
206
+ "perda_vq": null,
207
+ "violacoes_contrato": 0,
208
+ "economia_bits_por_slot": 0.9990234375
209
+ },
210
+ "crescimento": []
211
+ },
212
+ {
213
+ "epoca": 4,
214
+ "perda_media": 1.647582643561893,
215
+ "avaliacao": {
216
+ "vqa": 1.2144984665016334,
217
+ "pontuacao": 2.198017636934916,
218
+ "instrucao": 1.4627658526102703,
219
+ "tts": 0.8890816271305084,
220
+ "lm": 2.005878428618113,
221
+ "imagem_caption": 1.4931794007619221,
222
+ "ocr": 1.9250603119532268,
223
+ "noticia": 1.846806824207306,
224
+ "asr": 1.42787371079127,
225
+ "ppl_lm": 7.432620056120455
226
+ },
227
+ "eq_som": 1.3965169191360474,
228
+ "punicoes": 1,
229
+ "prs": {
230
+ "trust": 0.6554,
231
+ "tau": 1.42016,
232
+ "clip": 2.9561,
233
+ "boost": 1.0,
234
+ "streak": 0,
235
+ "ciclos_sgdr": 0,
236
+ "recompensa_acum": 12.061,
237
+ "beta_min_relativo": 0.655
238
+ },
239
+ "confianca": {
240
+ "h_ema": 0.2993004024028778,
241
+ "ece": 0.18333333333333332,
242
+ "posterior": {
243
+ "media": 0.44680851063829785,
244
+ "bernstein": [
245
+ 0.1995713077457135,
246
+ 0.6940457135308822
247
+ ]
248
+ }
249
+ },
250
+ "memoria": {
251
+ "slots": 8,
252
+ "capacidade": 64,
253
+ "escritas": 8,
254
+ "rejeitadas_confianca": 3,
255
+ "hit_rate": 1.0,
256
+ "comprimidos": 0,
257
+ "entropia_codebook": 1.4736544073912228e-07,
258
+ "perda_vq": null,
259
+ "violacoes_contrato": 0,
260
+ "economia_bits_por_slot": 0.9990234375
261
+ },
262
+ "crescimento": []
263
+ },
264
+ {
265
+ "epoca": 5,
266
+ "perda_media": 1.6497120559215546,
267
+ "avaliacao": {
268
+ "vqa": 0.5591112061714133,
269
+ "pontuacao": 2.028630475203196,
270
+ "instrucao": 1.4438494443893433,
271
+ "tts": 0.6653600136439005,
272
+ "lm": 1.8496814568837483,
273
+ "imagem_caption": 1.381531576315562,
274
+ "ocr": 1.4207946757475536,
275
+ "noticia": 1.916561484336853,
276
+ "asr": 1.0018239219983418,
277
+ "ppl_lm": 6.357793968502589
278
+ },
279
+ "eq_som": 2.6723616123199463,
280
+ "punicoes": 1,
281
+ "prs": {
282
+ "trust": 0.4971,
283
+ "tau": 1.00865,
284
+ "clip": 5.0,
285
+ "boost": 1.0,
286
+ "streak": 1,
287
+ "ciclos_sgdr": 0,
288
+ "recompensa_acum": 0.333,
289
+ "beta_min_relativo": 2.0
290
+ },
291
+ "confianca": {
292
+ "h_ema": 0.6000000238418579,
293
+ "ece": 0.42499999999999993,
294
+ "posterior": {
295
+ "media": 0.3333333333333333,
296
+ "bernstein": [
297
+ 0.0,
298
+ 1.0
299
+ ]
300
+ }
301
+ },
302
+ "memoria": {
303
+ "slots": 1,
304
+ "capacidade": 64,
305
+ "escritas": 1,
306
+ "rejeitadas_confianca": 0,
307
+ "hit_rate": 0.0,
308
+ "comprimidos": 0,
309
+ "entropia_codebook": 1.4736544073912228e-07,
310
+ "perda_vq": null,
311
+ "violacoes_contrato": 0,
312
+ "economia_bits_por_slot": 0.9990234375
313
+ },
314
+ "crescimento": []
315
+ }
316
+ ],
317
+ "passos": 2394,
318
+ "punicoes": 1,
319
+ "barreira_abmo_ativacoes": 0,
320
+ "pcgrad_ultimo": {
321
+ "pcgrad/dot": 4.81320860131671,
322
+ "pcgrad/projetado": 0.0,
323
+ "pcgrad/fator": 0.0
324
+ },
325
+ "prs_v8": {
326
+ "trust": 0.4971,
327
+ "tau": 1.00865,
328
+ "clip": 5.0,
329
+ "boost": 1.0,
330
+ "streak": 1,
331
+ "ciclos_sgdr": 0,
332
+ "recompensa_acum": 0.333,
333
+ "beta_min_relativo": 2.0
334
+ },
335
+ "confianca": {
336
+ "h_ema": 0.6000000238418579,
337
+ "ece": 0.42499999999999993,
338
+ "posterior_media": 0.3333333333333333,
339
+ "bernstein": [
340
+ 0.0,
341
+ 1.0
342
+ ]
343
+ },
344
+ "memoria": {
345
+ "slots": 1,
346
+ "capacidade": 64,
347
+ "escritas": 1,
348
+ "rejeitadas_confianca": 0,
349
+ "hit_rate": 0.0,
350
+ "comprimidos": 0,
351
+ "entropia_codebook": 1.4736544073912228e-07,
352
+ "perda_vq": null,
353
+ "violacoes_contrato": 0,
354
+ "economia_bits_por_slot": 0.9990234375
355
+ },
356
+ "crescimento": [],
357
+ "microunidades": [
358
+ {
359
+ "ramos": [
360
+ "conv_dil",
361
+ "gru",
362
+ "mlp"
363
+ ],
364
+ "ativos": [
365
+ 1.0,
366
+ 1.0,
367
+ 1.0
368
+ ],
369
+ "uso_ema": [
370
+ 0.2148214876651764,
371
+ 0.29841190576553345,
372
+ 0.48675450682640076
373
+ ],
374
+ "passos_rec": 2
375
+ },
376
+ {
377
+ "ramos": [
378
+ "conv_dil",
379
+ "gru",
380
+ "mlp",
381
+ "moe"
382
+ ],
383
+ "ativos": [
384
+ 1.0,
385
+ 1.0,
386
+ 1.0,
387
+ 1.0
388
+ ],
389
+ "uso_ema": [
390
+ 0.2194831818342209,
391
+ 0.25361841917037964,
392
+ 0.27745726704597473,
393
+ 0.2494288682937622
394
+ ],
395
+ "passos_rec": 2
396
+ },
397
+ {
398
+ "ramos": [
399
+ "conv_dil",
400
+ "gru",
401
+ "mlp",
402
+ "moe"
403
+ ],
404
+ "ativos": [
405
+ 1.0,
406
+ 1.0,
407
+ 1.0,
408
+ 1.0
409
+ ],
410
+ "uso_ema": [
411
+ 0.13552594184875488,
412
+ 0.2418850064277649,
413
+ 0.3520493805408478,
414
+ 0.27052751183509827
415
+ ],
416
+ "passos_rec": 2
417
+ }
418
+ ],
419
+ "dpo": {
420
+ "passos": 93,
421
+ "acc_final": 1.0,
422
+ "margem_final": 133.46014404296875,
423
+ "beta_final": 0.05000000074505806
424
+ },
425
+ "som": {
426
+ "variante_ativa": "cpn",
427
+ "variantes": {
428
+ "som": {
429
+ "k": 24,
430
+ "taxa_ativos": 1.0,
431
+ "resemeados": 24,
432
+ "usos": 256,
433
+ "atingiu_alvo": true
434
+ },
435
+ "gg": {
436
+ "k": 4,
437
+ "taxa_ativos": 1.0,
438
+ "resemeados": 4,
439
+ "usos": 256,
440
+ "atingiu_alvo": true
441
+ },
442
+ "gcs": {
443
+ "k": 3,
444
+ "arestas": 3,
445
+ "eq_treino": 28633.626953125,
446
+ "atingiu_alvo": true
447
+ },
448
+ "gsom": {
449
+ "k": 38,
450
+ "gt": 1.05,
451
+ "erro_medio": 0.0,
452
+ "atingiu_alvo": true
453
+ },
454
+ "hsom": {},
455
+ "tkm": {
456
+ "k": 32,
457
+ "taxa_ativos": 1.0,
458
+ "resemeados": 32,
459
+ "usos": 256,
460
+ "atingiu_alvo": true
461
+ },
462
+ "rsom": {
463
+ "k": 32,
464
+ "taxa_ativos": 1.0,
465
+ "resemeados": 32,
466
+ "usos": 256,
467
+ "atingiu_alvo": true
468
+ },
469
+ "cpn": {},
470
+ "ssom": {
471
+ "k": 24,
472
+ "taxa_ativos": 1.0,
473
+ "resemeados": 22,
474
+ "usos": 0,
475
+ "atingiu_alvo": true
476
+ }
477
+ },
478
+ "invariante_sem_orfaos": true,
479
+ "orfaos_por_variante": {
480
+ "som": {
481
+ "orfaos": 0,
482
+ "relocados": 0,
483
+ "taxa_ativos": 1.0
484
+ },
485
+ "gg": {
486
+ "orfaos": 0,
487
+ "relocados": 0,
488
+ "taxa_ativos": 1.0
489
+ },
490
+ "gcs": {
491
+ "orfaos": 0,
492
+ "relocados": 0,
493
+ "taxa_ativos": 1.0
494
+ },
495
+ "gsom": {
496
+ "orfaos": 0,
497
+ "relocados": 0,
498
+ "taxa_ativos": 1.0
499
+ },
500
+ "hsom": {
501
+ "orfaos": 0,
502
+ "relocados": 0
503
+ },
504
+ "tkm": {
505
+ "orfaos": 0,
506
+ "relocados": 0,
507
+ "taxa_ativos": 1.0
508
+ },
509
+ "rsom": {
510
+ "orfaos": 0,
511
+ "relocados": 0,
512
+ "taxa_ativos": 1.0
513
+ },
514
+ "cpn": {
515
+ "orfaos": 0,
516
+ "relocados": 0,
517
+ "taxa_ativos": 1.0
518
+ },
519
+ "ssom": {
520
+ "orfaos": 0,
521
+ "relocados": 0,
522
+ "taxa_ativos": 1.0
523
+ }
524
+ }
525
+ },
526
+ "avaliacao_final": {
527
+ "vqa": 2.3314520716667175,
528
+ "pontuacao": 3.41549813747406,
529
+ "instrucao": 2.8566880226135254,
530
+ "tts": 1.8765299320220947,
531
+ "lm": 3.614660620689392,
532
+ "imagem_caption": 2.520522654056549,
533
+ "ocr": 4.0555307269096375,
534
+ "noticia": 3.46865713596344,
535
+ "asr": 2.7953450679779053,
536
+ "ppl_lm": 37.138739666750844
537
+ },
538
+ "metricas_completas": {
539
+ "neuronios_ativos": {
540
+ "ativos/som": 1.0,
541
+ "k/som": 24,
542
+ "ativos/gg": 1.0,
543
+ "k/gg": 4,
544
+ "ativos/gcs": 1.0,
545
+ "k/gcs": 3,
546
+ "ativos/gsom": 1.0,
547
+ "k/gsom": 38,
548
+ "ativos/hsom": 1.0,
549
+ "k/hsom": 12,
550
+ "ativos/tkm": 1.0,
551
+ "k/tkm": 32,
552
+ "ativos/rsom": 1.0,
553
+ "k/rsom": 32,
554
+ "ativos/cpn": 1.0,
555
+ "k/cpn": 24,
556
+ "ativos/ssom": 1.0,
557
+ "k/ssom": 24,
558
+ "A_global": 1.0
559
+ },
560
+ "estruturais": {
561
+ "ortogonalidade": 5.960464477539062e-07,
562
+ "balanceamento_moe": 0.0,
563
+ "gate_global": 0.26322099566459656,
564
+ "gate_janela": 0.3298090994358063,
565
+ "gate_linear": 0.4069698750972748,
566
+ "moe1/experts_ativos": 6.0,
567
+ "moe1/uso_max": 0.17419351637363434,
568
+ "moe1/perda_lb": 0.05576947331428528,
569
+ "moe1/perda_ort": 0.10717342048883438,
570
+ "moe1/fase": 0.0,
571
+ "moe1/beta_feedback": 0.0,
572
+ "moe1/entropia_atn": 0.0,
573
+ "moe2/experts_ativos": 6.0,
574
+ "moe2/uso_max": 0.19889135658740997,
575
+ "moe2/perda_lb": 0.05875171348452568,
576
+ "moe2/perda_ort": 0.08529063314199448,
577
+ "moe2/fase": 0.0,
578
+ "moe2/beta_feedback": 0.27272307872772217,
579
+ "moe2/entropia_atn": 0.6075316071510315,
580
+ "moe2/alpha_refino": -0.03248695284128189,
581
+ "mtp/alpha0": 0.9979719519615173,
582
+ "mtp/alpha1": 0.0020279940217733383,
583
+ "mtp/termos_ce": 214.0,
584
+ "micra0/n_ramos": 3,
585
+ "micra0/ramos_ativos": 3,
586
+ "micra0/passos_rec": 2,
587
+ "micra0/alpha0": 0.17735245823860168,
588
+ "micra0/alpha1": 0.3013617992401123,
589
+ "micra0/alpha2": 0.5212857127189636,
590
+ "micra0/uso0": 0.2148214876651764,
591
+ "micra0/uso1": 0.29841190576553345,
592
+ "micra0/uso2": 0.48675450682640076,
593
+ "micra1/n_ramos": 4,
594
+ "micra1/ramos_ativos": 4,
595
+ "micra1/passos_rec": 2,
596
+ "micra1/alpha0": 0.1965179294347763,
597
+ "micra1/alpha1": 0.23177307844161987,
598
+ "micra1/alpha2": 0.28816545009613037,
599
+ "micra1/alpha3": 0.2835436165332794,
600
+ "micra1/uso0": 0.2194831818342209,
601
+ "micra1/uso1": 0.25361841917037964,
602
+ "micra1/uso2": 0.27745726704597473,
603
+ "micra1/uso3": 0.2494288682937622,
604
+ "micra2/n_ramos": 4,
605
+ "micra2/ramos_ativos": 4,
606
+ "micra2/passos_rec": 2,
607
+ "micra2/alpha0": 0.17474918067455292,
608
+ "micra2/alpha1": 0.2689807415008545,
609
+ "micra2/alpha2": 0.3373318910598755,
610
+ "micra2/alpha3": 0.2189381718635559,
611
+ "micra2/uso0": 0.13552594184875488,
612
+ "micra2/uso1": 0.2418850064277649,
613
+ "micra2/uso2": 0.3520493805408478,
614
+ "micra2/uso3": 0.27052751183509827,
615
+ "nlp/gate_medio": 0.21739931404590607,
616
+ "nlp/intencao_id": 9,
617
+ "nlg/coerencia_bigramas_vistos": 0.0,
618
+ "nlg/estilo_medio": 0.5,
619
+ "nlg/estilo_disp": 0.0,
620
+ "janela1m/n_segmentos": 0,
621
+ "janela1m/m_max": 7813,
622
+ "janela1m/hit_celula": 0.0,
623
+ "janela1m/consultas": 0,
624
+ "mtp/rascunho_pronto": 1.0
625
+ },
626
+ "escala": {},
627
+ "regime": {
628
+ "fase_final": "B",
629
+ "alvo_ativos": 0.9
630
+ }
631
+ },
632
+ "inferencia_agente": {
633
+ "latencia_s": 0.568,
634
+ "tokens": 24,
635
+ "taxa_repeticao": 0.0417,
636
+ "coerencia_bigramas": 0.0
637
+ },
638
+ "difusao": {
639
+ "modo": "real",
640
+ "op": "txt2img",
641
+ "latencia_s": 5.13,
642
+ "prompt_enriquecido": "a floresta amazonica de manha, com detalhes nítidos, com composição harmônica, com iluminação suave",
643
+ "gerou_pixels": true,
644
+ "estatisticas": {
645
+ "modo": "real",
646
+ "repo": "hf-internal-testing/tiny-stable-diffusion-torch",
647
+ "device": "cpu",
648
+ "pipelines": [
649
+ "txt2img"
650
+ ],
651
+ "eventos": [
652
+ "pipeline txt2img carregado (hf-internal-testing/tiny-stable-diffusion-torch)"
653
+ ]
654
+ }
655
+ },
656
+ "agente_engenheiro": {
657
+ "aprovadas": 0,
658
+ "bloqueadas": 0,
659
+ "invariante_sem_orfaos": true
660
+ },
661
+ "checkpoints_eventos": [
662
+ "checkpoint epoca-005-p02390: 444 tensores, 0 pulados, 94 novos",
663
+ "1 checkpoint(s) antigo(s) apagado(s)",
664
+ "checkpoint epoca-005: local (59.2 MB)",
665
+ "1 checkpoint(s) antigo(s) apagado(s)",
666
+ "checkpoint fase-dpo: local (59.2 MB)",
667
+ "1 checkpoint(s) antigo(s) apagado(s)",
668
+ "checkpoint fase-som: local (59.2 MB)"
669
+ ]
670
+ }
scripts/01_verificar_ambiente.py CHANGED
@@ -43,9 +43,9 @@ def main():
43
  from aurora.treino.dpo import PerdaDPO
44
  from aurora.treino.cirurgia_grad import pcgrad_duas_perdas
45
  from aurora.quanta.quantizacao import SmoothQuantAlpha
46
- from aurora.dados.estados_hf import EstadosHF
47
  cfg = Config()
48
- print(" ✓ módulos v2 importáveis (MoE, MTP, DPO, PCGrad, α-STE, EstadosHF)")
49
  n_params_moe = 3 * cfg.modelo.moe["experts_por_grupo"] * \
50
  2 * cfg.modelo.d_modelo * cfg.modelo.moe["d_ff_expert"]
51
  print(f" MoE: {cfg.modelo.moe['n_camadas_moe']} blocos × "
 
43
  from aurora.treino.dpo import PerdaDPO
44
  from aurora.treino.cirurgia_grad import pcgrad_duas_perdas
45
  from aurora.quanta.quantizacao import SmoothQuantAlpha
46
+ from aurora.dados.checkpoints import GestorCheckpoints
47
  cfg = Config()
48
+ print(" ✓ módulos v2 importáveis (MoE, MTP, DPO, PCGrad, α-STE, Checkpoints)")
49
  n_params_moe = 3 * cfg.modelo.moe["experts_por_grupo"] * \
50
  2 * cfg.modelo.d_modelo * cfg.modelo.moe["d_ff_expert"]
51
  print(f" MoE: {cfg.modelo.moe['n_camadas_moe']} blocos × "
scripts/02_coletar_corpus.py CHANGED
@@ -33,9 +33,32 @@ def main():
33
  plano_total = StreamingCorpus().PLANO
34
  eventos = []
35
  vistos: set[str] = set()
 
 
36
  registros = []
 
 
 
 
 
 
 
 
 
 
 
 
 
 
37
  for i, plano in enumerate(plano_total):
38
  fonte = plano["id"]
 
 
 
 
 
 
 
39
  if plano["via"] == "degradado":
40
  # mensagem determinística gerada pelo próprio módulo de streaming
41
  sub = StreamingCorpus()
@@ -44,20 +67,46 @@ def main():
44
  continue
45
  cam_parcial = os.path.join(DIR_PARCIAL, f"fonte_{i:02d}.jsonl")
46
  cam_estado = os.path.join(DIR_PARCIAL, f"fonte_{i:02d}.estado.json")
47
- r = subprocess.run(
48
- [sys.executable, RUNNER, "--indice", str(i),
49
- "--saida", cam_parcial, "--estado", cam_estado],
50
- capture_output=True, text=True, timeout=900,
51
- env={**os.environ, "PYTHONPATH": "/home/z/my-project/aurora/src"})
 
 
 
 
 
 
52
  if os.path.exists(cam_estado):
53
  ev = json.load(open(cam_estado, encoding="utf-8"))
54
  else:
55
- ev = {"fonte": fonte, "status": "ERRO",
56
- "detalhe": (r.stderr or "sem resposta")[-180:], "n": 0}
57
- # merge com dedup global
58
  n_dedup = 0
59
  if os.path.exists(cam_parcial):
60
  with open(cam_parcial, encoding="utf-8") as f:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
61
  for linha in f:
62
  try:
63
  reg = json.loads(linha)
@@ -66,15 +115,12 @@ def main():
66
  if plano["via"] in ("tts_marcos",):
67
  reg.setdefault("imagem", None)
68
  reg.setdefault("audio", None)
69
- # dedup: hash de texto OU do PAR (entrada, saida) — nunca só
70
- # da saída (respostas curtas tipo "C" se colidiriam)
71
  if reg.get("texto"):
72
  chave = _hash_texto(reg["texto"])
73
  else:
74
  chave = _hash_texto((reg.get("entrada") or "") + "␟" +
75
  (reg.get("saida") or ""))
76
  if chave in vistos:
77
- n_dedup += 1
78
  continue
79
  vistos.add(chave)
80
  if reg.get("imagem") is None:
@@ -82,13 +128,12 @@ def main():
82
  if reg.get("audio") is None:
83
  reg.pop("audio", None)
84
  registros.append(reg)
85
- ev["dedup_descartados"] = n_dedup
86
- eventos.append(ev)
87
- print(f" [{ev['status']}] {fonte} (n={ev['n']}, dedup={n_dedup})"
88
- + (f" {ev['detalhe'][:80]}" if ev.get("detalhe") else ""))
89
  os.remove(cam_parcial) if os.path.exists(cam_parcial) else None
90
- os.remove(cam_estado) if os.path.exists(cam_estado) else None
91
  limpar_cache_temp() # um dataset por vez → disco sob controle
 
 
92
  # escreve corpus final
93
  n_multimodal = 0
94
  with open(SAIDA, "w", encoding="utf-8") as f:
 
33
  plano_total = StreamingCorpus().PLANO
34
  eventos = []
35
  vistos: set[str] = set()
36
+ # v5 — RETOMÁVEL: corpus escrito INCREMENTALMENTE (append por fonte);
37
+ # na retomada, recarrega o acumulado e pula fontes já OK (estado persistido)
38
  registros = []
39
+ if os.path.exists(SAIDA):
40
+ with open(SAIDA, encoding="utf-8") as f:
41
+ for linha in f:
42
+ try:
43
+ reg = json.loads(linha)
44
+ except Exception:
45
+ continue
46
+ chave = _hash_texto(reg.get("texto") or
47
+ ((reg.get("entrada") or "") + "␟" +
48
+ (reg.get("saida") or "")))
49
+ if chave not in vistos:
50
+ vistos.add(chave)
51
+ registros.append(reg)
52
+ print(f"retomada: {len(registros)} registros acumulados")
53
  for i, plano in enumerate(plano_total):
54
  fonte = plano["id"]
55
+ cam_estado_prev = os.path.join(DIR_PARCIAL, f"fonte_{i:02d}.estado.json")
56
+ if os.path.exists(cam_estado_prev):
57
+ ev_prev = json.load(open(cam_estado_prev, encoding="utf-8"))
58
+ if ev_prev.get("status") == "OK" and ev_prev.get("n", 0) > 0:
59
+ eventos.append(ev_prev)
60
+ print(f" [SKIP] {fonte} (já coletada: n={ev_prev['n']})")
61
+ continue
62
  if plano["via"] == "degradado":
63
  # mensagem determinística gerada pelo próprio módulo de streaming
64
  sub = StreamingCorpus()
 
67
  continue
68
  cam_parcial = os.path.join(DIR_PARCIAL, f"fonte_{i:02d}.jsonl")
69
  cam_estado = os.path.join(DIR_PARCIAL, f"fonte_{i:02d}.estado.json")
70
+ try:
71
+ r = subprocess.run(
72
+ [sys.executable, RUNNER, "--indice", str(i),
73
+ "--saida", cam_parcial, "--estado", cam_estado],
74
+ capture_output=True, text=True, timeout=900,
75
+ env={**os.environ, "PYTHONPATH": "/home/z/my-project/aurora/src"})
76
+ r_erro = (r.stderr or "sem resposta")[-180:]
77
+ except subprocess.TimeoutExpired:
78
+ r_erro = "TIMEOUT 900s (fonte lenta — pulada)"
79
+ except Exception as e: # rede/Hub: nunca para o lote
80
+ r_erro = f"{type(e).__name__}: {e}"[-180:]
81
  if os.path.exists(cam_estado):
82
  ev = json.load(open(cam_estado, encoding="utf-8"))
83
  else:
84
+ ev = {"fonte": fonte, "status": "ERRO", "detalhe": r_erro, "n": 0}
85
+ # v5 — dedup/append durável ÚNICO (abaixo); contagem de dedup por leitura
 
86
  n_dedup = 0
87
  if os.path.exists(cam_parcial):
88
  with open(cam_parcial, encoding="utf-8") as f:
89
+ for linha in f:
90
+ try:
91
+ reg = json.loads(linha)
92
+ except Exception:
93
+ continue
94
+ if reg.get("texto"):
95
+ chave = _hash_texto(reg["texto"])
96
+ else:
97
+ chave = _hash_texto((reg.get("entrada") or "") + "␟" +
98
+ (reg.get("saida") or ""))
99
+ if chave in vistos:
100
+ n_dedup += 1
101
+ ev["dedup_descartados"] = n_dedup
102
+ eventos.append(ev)
103
+ print(f" [{ev['status']}] {fonte} (n={ev['n']}, dedup={n_dedup})"
104
+ + (f" {ev['detalhe'][:80]}" if ev.get("detalhe") else ""))
105
+ # v5 — append DURÁVEL ao corpus (morte do processo não perde progresso)
106
+ novos = 0
107
+ if os.path.exists(cam_parcial) and ev.get("status") in ("OK", "PARCIAL"):
108
+ with open(cam_parcial, encoding="utf-8") as f, \
109
+ open(SAIDA, "a", encoding="utf-8") as fa:
110
  for linha in f:
111
  try:
112
  reg = json.loads(linha)
 
115
  if plano["via"] in ("tts_marcos",):
116
  reg.setdefault("imagem", None)
117
  reg.setdefault("audio", None)
 
 
118
  if reg.get("texto"):
119
  chave = _hash_texto(reg["texto"])
120
  else:
121
  chave = _hash_texto((reg.get("entrada") or "") + "␟" +
122
  (reg.get("saida") or ""))
123
  if chave in vistos:
 
124
  continue
125
  vistos.add(chave)
126
  if reg.get("imagem") is None:
 
128
  if reg.get("audio") is None:
129
  reg.pop("audio", None)
130
  registros.append(reg)
131
+ fa.write(json.dumps(reg, ensure_ascii=False) + "\n")
132
+ novos += 1
 
 
133
  os.remove(cam_parcial) if os.path.exists(cam_parcial) else None
 
134
  limpar_cache_temp() # um dataset por vez → disco sob controle
135
+ import gc
136
+ gc.collect()
137
  # escreve corpus final
138
  n_multimodal = 0
139
  with open(SAIDA, "w", encoding="utf-8") as f:
scripts/04_treinar.py CHANGED
@@ -24,13 +24,16 @@ import base64
24
  import json
25
  import os
26
  import sys
 
27
 
28
  sys.path.insert(0, "/home/z/my-project/aurora/src")
29
 
30
  import torch
31
 
32
  from aurora.config import Config
33
- from aurora.dados.estados_hf import EstadosHF
 
 
34
  from aurora.dados.tokenizador import TokenizadorAurora
35
  from aurora.memoria.orquestrador import OrquestradorSOM
36
  from aurora.nucleo.modelo import AURORAModel
@@ -39,7 +42,7 @@ from aurora.treino.treinador import TreinadorExtensao
39
 
40
  CORPUS = "/home/z/my-project/aurora/cache_dados/corpus_v2.jsonl"
41
  TOKENIZADOR = "/home/z/my-project/aurora/cache_dados/tokenizador.json"
42
- RESUMO = "/home/z/my-project/aurora/telemetria_out/resumo_treino_v4.json"
43
 
44
 
45
  def carregar_registros(caminho: str) -> list[dict]:
@@ -88,15 +91,25 @@ def main():
88
  modelo = AURORAModel(cfg, usar_multimodal=True)
89
  print(f"modelo: {sum(p.numel() for p in modelo.parameters())/1e6:.2f}M parâmetros")
90
 
91
- estados = EstadosHF(repo_id=cfg.estados_hf.repo_id if cfg.estados_hf.ativo else None,
92
- dir_local=cfg.estados_hf.dir_local,
93
- pasta=cfg.estados_hf.pasta)
94
- orquestrador = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som, hub=hub)
95
  treinar = TreinadorExtensao(cfg, modelo, tk, hub, registros,
96
- orquestrador_som=orquestrador, estados=estados)
97
-
98
- # item c: "salvar (e usar) estados no HF" — retoma do mais avançado
99
- tag_retomada = treinar.retomar_do_hub()
 
 
 
 
 
 
 
 
 
 
 
100
  print(f"retomada do Hub: tag={tag_retomada} "
101
  f"(passo {treinar.passo_global}, época {treinar.epoca})")
102
 
@@ -120,7 +133,7 @@ def main():
120
  print("== fase DPO ==")
121
  resultado_dpo = treinar.treinar_dpo()
122
  print("DPO:", resultado_dpo)
123
- treinar.salvar_estado_hf("fase-dpo", {"dpo": resultado_dpo})
124
 
125
  # ---------- fase 4: SOM com máximo de neurônios ativos ----------
126
  resultado_som = {"pulado": True}
@@ -129,12 +142,42 @@ def main():
129
  resultado_som = treinar.consolidar_som_max_ativos()
130
  for nome, st in resultado_som.get("variantes", {}).items():
131
  print(f" {nome}: {st}")
132
- treinar.salvar_estado_hf("fase-som", {"som": {
133
  k: v for k, v in resultado_som.items() if k != "prototipos"}})
134
 
135
  aval_final = treinar.avaliar(max_lotes=4)
136
  print("avaliação final:", aval_final)
137
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
138
  # v4 — MÉTRICAS COMPLETAS (doc 15 §3): neurônios ativos por variante,
139
  # NLP/NLG, janela 1M, computo, crescimento
140
  metricas_completas = {
@@ -149,9 +192,11 @@ def main():
149
  print(json.dumps(metricas_completas, ensure_ascii=False, indent=1,
150
  default=str)[:2200])
151
 
 
 
152
  os.makedirs(os.path.dirname(RESUMO), exist_ok=True)
153
  with open(RESUMO, "w", encoding="utf-8") as f:
154
- json.dump({"versao": "v4-duas-fases-16384",
155
  "epocas": treinar.historico_epocas,
156
  "passos": treinar.passo_global,
157
  "punicoes": len(treinar.eventos_punicao),
@@ -176,7 +221,12 @@ def main():
176
  "dpo": resultado_dpo, "som": resultado_som,
177
  "avaliacao_final": aval_final,
178
  "metricas_completas": metricas_completas,
179
- "estados_eventos": estados.eventos[-12:]},
 
 
 
 
 
180
  f, ensure_ascii=False, indent=2, default=str)
181
  print(f"resumo → {RESUMO}")
182
 
 
24
  import json
25
  import os
26
  import sys
27
+ import time
28
 
29
  sys.path.insert(0, "/home/z/my-project/aurora/src")
30
 
31
  import torch
32
 
33
  from aurora.config import Config
34
+ from aurora.dados.checkpoints import GestorCheckpoints
35
+ from aurora.geracao import GeradorMultimodal
36
+ from aurora.qualidade import AgenteEngenheiro
37
  from aurora.dados.tokenizador import TokenizadorAurora
38
  from aurora.memoria.orquestrador import OrquestradorSOM
39
  from aurora.nucleo.modelo import AURORAModel
 
42
 
43
  CORPUS = "/home/z/my-project/aurora/cache_dados/corpus_v2.jsonl"
44
  TOKENIZADOR = "/home/z/my-project/aurora/cache_dados/tokenizador.json"
45
+ RESUMO = "/home/z/my-project/aurora/telemetria_out/resumo_treino_v5.json"
46
 
47
 
48
  def carregar_registros(caminho: str) -> list[dict]:
 
91
  modelo = AURORAModel(cfg, usar_multimodal=True)
92
  print(f"modelo: {sum(p.numel() for p in modelo.parameters())/1e6:.2f}M parâmetros")
93
 
94
+ checkpoints = GestorCheckpoints(dir_local=cfg.checkpoints.dir_local)
95
+ orquestrador = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som, hub=hub,
96
+ cfg_atencao=vars(cfg.som_atencao) if hasattr(cfg, "som_atencao") else None)
 
97
  treinar = TreinadorExtensao(cfg, modelo, tk, hub, registros,
98
+ orquestrador_som=orquestrador, checkpoints=checkpoints)
99
+ # v5 — Agente Engenheiro: observação integral durante o treino (doc 16 §9)
100
+ agente = AgenteEngenheiro(
101
+ tolerancia_regressao=cfg.agente_engenheiro.tolerancia_regressao, hub=hub)
102
+ treinar.agente_engenheiro = agente
103
+ treinar.intervalo_agente = cfg.agente_engenheiro.intervalo
104
+ # v5 — gerador multimodal (difusão) para o ciclo geracional (doc 17)
105
+ difusao = GeradorMultimodal(repo_id=cfg.difusao.repo_id,
106
+ altura=cfg.difusao.altura, largura=cfg.difusao.largura,
107
+ passos_inferencia=cfg.difusao.passos_inferencia,
108
+ guia_escala=cfg.difusao.guia_escala, hub=hub) \
109
+ if cfg.difusao.ativo else None
110
+
111
+ # item c: "salvar (e usar) estados" — retoma do checkpoint local mais avançado
112
+ tag_retomada = treinar.retomar_ultimo_checkpoint()
113
  print(f"retomada do Hub: tag={tag_retomada} "
114
  f"(passo {treinar.passo_global}, época {treinar.epoca})")
115
 
 
133
  print("== fase DPO ==")
134
  resultado_dpo = treinar.treinar_dpo()
135
  print("DPO:", resultado_dpo)
136
+ treinar.salvar_checkpoint("fase-dpo", {"dpo": resultado_dpo})
137
 
138
  # ---------- fase 4: SOM com máximo de neurônios ativos ----------
139
  resultado_som = {"pulado": True}
 
142
  resultado_som = treinar.consolidar_som_max_ativos()
143
  for nome, st in resultado_som.get("variantes", {}).items():
144
  print(f" {nome}: {st}")
145
+ treinar.salvar_checkpoint("fase-som", {"som": {
146
  k: v for k, v in resultado_som.items() if k != "prototipos"}})
147
 
148
  aval_final = treinar.avaliar(max_lotes=4)
149
  print("avaliação final:", aval_final)
150
 
151
+ # v5 — evidência de INFERÊNCIA para o Agente Engenheiro (métricas de geração)
152
+ try:
153
+ ids_prompt = tk.encode("Pergunta: o que e o Kohonen? Resposta:",
154
+ tarefa="instrucao", max_len=24)
155
+ t0 = time.time()
156
+ tokens = modelo.gerar(torch.tensor([ids_prompt]), max_novos=24)
157
+ evid_inf = agente.observar_inferencia(modelo, torch.tensor([ids_prompt]),
158
+ tokens, time.time() - t0)
159
+ print("inferência (agente):", evid_inf)
160
+ print("texto gerado:", tk.decode(tokens))
161
+ except Exception as e:
162
+ evid_inf = {"erro": str(e)}
163
+
164
+ # v5 — ciclo de compreensão geracional (difusão; modo honesto)
165
+ evid_difusao = None
166
+ if difusao is not None:
167
+ try:
168
+ r = difusao.compreensao_geracional(
169
+ "a floresta amazonica de manha", modelo,
170
+ orquestrador=orquestrador, op="txt2img")
171
+ evid_difusao = {"modo": r.get("modo"), "op": r.get("op"),
172
+ "latencia_s": r.get("latencia_s"),
173
+ "prompt_enriquecido": r.get("prompt_enriquecido"),
174
+ "gerou_pixels": r.get("modo") == "real",
175
+ "estatisticas": difusao.estatisticas()}
176
+ print("difusão (modo honesto):", evid_difusao["modo"],
177
+ "—", evid_difusao["prompt_enriquecido"])
178
+ except Exception as e:
179
+ evid_difusao = {"erro": str(e)}
180
+
181
  # v4 — MÉTRICAS COMPLETAS (doc 15 §3): neurônios ativos por variante,
182
  # NLP/NLG, janela 1M, computo, crescimento
183
  metricas_completas = {
 
192
  print(json.dumps(metricas_completas, ensure_ascii=False, indent=1,
193
  default=str)[:2200])
194
 
195
+ rel_agente = agente.relatorio(orquestrador_som=orquestrador,
196
+ avaliacao=aval_final)
197
  os.makedirs(os.path.dirname(RESUMO), exist_ok=True)
198
  with open(RESUMO, "w", encoding="utf-8") as f:
199
+ json.dump({"versao": "v5-atencao-moe-som-16384",
200
  "epocas": treinar.historico_epocas,
201
  "passos": treinar.passo_global,
202
  "punicoes": len(treinar.eventos_punicao),
 
221
  "dpo": resultado_dpo, "som": resultado_som,
222
  "avaliacao_final": aval_final,
223
  "metricas_completas": metricas_completas,
224
+ "inferencia_agente": evid_inf,
225
+ "difusao": evid_difusao,
226
+ "agente_engenheiro": {"aprovadas": rel_agente["revisoes_aprovadas"],
227
+ "bloqueadas": rel_agente["revisoes_bloqueadas"],
228
+ "invariante_sem_orfaos": rel_agente.get("som_invariante_sem_orfaos")},
229
+ "checkpoints_eventos": checkpoints.eventos[-12:]},
230
  f, ensure_ascii=False, indent=2, default=str)
231
  print(f"resumo → {RESUMO}")
232
 
scripts/05_avaliar.py CHANGED
@@ -13,20 +13,23 @@
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_v4.json."""
17
  import base64
18
  import json
19
  import math
20
  import os
21
  import random
22
  import sys
 
23
 
24
  sys.path.insert(0, "/home/z/my-project/aurora/src")
25
 
26
  import torch
27
 
28
  from aurora.config import Config
29
- from aurora.dados.estados_hf import EstadosHF
 
 
30
  from aurora.dados.tokenizador import TokenizadorAurora
31
  from aurora.memoria.orquestrador import OrquestradorSOM
32
  from aurora.nucleo.modelo import AURORAModel
@@ -37,7 +40,7 @@ from aurora.treino.treinador import (TAREFAS_AUDIO, TAREFAS_IMAGEM,
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_v4.json"
41
 
42
 
43
  def carregar_registros(caminho):
@@ -141,11 +144,38 @@ def main():
141
  registros = carregar_registros(CORPUS)
142
 
143
  modelo = AURORAModel(cfg, usar_multimodal=True)
144
- estados = EstadosHF(repo_id=cfg.estados_hf.repo_id if cfg.estados_hf.ativo else None,
145
- dir_local=cfg.estados_hf.dir_local, pasta=cfg.estados_hf.pasta)
146
- tag = estados.carregar_ultimo(modelo)
 
147
  print(f"estado carregado: {tag or 'NENHUM (avaliando aleatório!)'}")
148
- orquestrador = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som, hub=hub)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
149
 
150
  relatorio = {"estado": tag}
151
  # 1-2) perdas treinado vs aleatório
@@ -335,6 +365,46 @@ def main():
335
  relatorio["coerencia_erro"] = f"{type(e).__name__}: {e}"
336
  print(f" (coerência falhou: {type(e).__name__})")
337
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
338
  os.makedirs(os.path.dirname(RELATORIO), exist_ok=True)
339
  with open(RELATORIO, "w", encoding="utf-8") as f:
340
  json.dump(relatorio, f, ensure_ascii=False, indent=2, default=str)
 
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_v5.json (v5: + Agente Engenheiro e difusão)."""
17
  import base64
18
  import json
19
  import math
20
  import os
21
  import random
22
  import sys
23
+ import time
24
 
25
  sys.path.insert(0, "/home/z/my-project/aurora/src")
26
 
27
  import torch
28
 
29
  from aurora.config import Config
30
+ from aurora.dados.checkpoints import GestorCheckpoints
31
+ from aurora.geracao import GeradorMultimodal
32
+ from aurora.qualidade import AgenteEngenheiro
33
  from aurora.dados.tokenizador import TokenizadorAurora
34
  from aurora.memoria.orquestrador import OrquestradorSOM
35
  from aurora.nucleo.modelo import AURORAModel
 
40
 
41
  CORPUS = "/home/z/my-project/aurora/cache_dados/corpus_v2.jsonl"
42
  TOKENIZADOR = "/home/z/my-project/aurora/cache_dados/tokenizador.json"
43
+ RELATORIO = "/home/z/my-project/aurora/telemetria_out/avaliacao_v5.json"
44
 
45
 
46
  def carregar_registros(caminho):
 
144
  registros = carregar_registros(CORPUS)
145
 
146
  modelo = AURORAModel(cfg, usar_multimodal=True)
147
+ checkpoints = GestorCheckpoints(dir_local=cfg.checkpoints.dir_local)
148
+ tag = checkpoints.ultima_tag()
149
+ if tag:
150
+ checkpoints.carregar(modelo, tag)
151
  print(f"estado carregado: {tag or 'NENHUM (avaliando aleatório!)'}")
152
+ orquestrador = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som, hub=hub,
153
+ cfg_atencao=vars(cfg.som_atencao) if hasattr(cfg, "som_atencao") else None)
154
+
155
+ # v5 — os SOMs são tensors puros (fora do state_dict): re-consolidação
156
+ # determinística a partir do modelo treinado (mesmo protocolo do 07 /
157
+ # Teorema 16.5) — as evidências de memória refletem o estado TREINADO.
158
+ print("== re-consolidação SOM (protocolo doc 16 §4/§5) ==")
159
+ amostras = random.sample(registros, min(4 * 64, len(registros)))
160
+ ctxs = []
161
+ for i in range(0, len(amostras), 64):
162
+ pedaco = amostras[i:i + 64]
163
+ seqs = [tk.encode(r.get("texto") or (r.get("saida") or r.get("entrada", "")),
164
+ tarefa=r["tarefa"], max_len=64)[:64] for r in pedaco]
165
+ Tmax = max(len(x) for x in seqs)
166
+ ids_l = torch.zeros(len(seqs), Tmax, dtype=torch.long)
167
+ for j, x in enumerate(seqs):
168
+ ids_l[j, :len(x)] = torch.tensor(x)
169
+ ctxs.append(modelo.contexto(ids_l).detach())
170
+ ctx = torch.cat(ctxs, dim=0)
171
+ dominante = "instrucao" if any(r["tarefa"] == "instrucao" for r in amostras) else "lm"
172
+ orquestrador.escolher({"rotulo_tarefa": dominante, "denso": True})
173
+ orquestrador.treinar_memoria(ctx, epocas=2)
174
+ if getattr(orquestrador, "atencao", None) is not None:
175
+ inv = orquestrador.atencao.verificar_sem_orfas(orquestrador, dados=ctx,
176
+ resemear=True)
177
+ print(" invariante zero-órfãos:", inv.pop("_invariante_ok", None))
178
+ print(" ativos:", json.dumps(orquestrador.telemetria_ativos())[:200])
179
 
180
  relatorio = {"estado": tag}
181
  # 1-2) perdas treinado vs aleatório
 
365
  relatorio["coerencia_erro"] = f"{type(e).__name__}: {e}"
366
  print(f" (coerência falhou: {type(e).__name__})")
367
 
368
+ # v5 — Agente Engenheiro: observação de INFERÊNCIA + relatório final
369
+ print("== Agente Engenheiro (inferência + relatório integral) ==")
370
+ try:
371
+ ag = AgenteEngenheiro(
372
+ tolerancia_regressao=cfg.agente_engenheiro.tolerancia_regressao,
373
+ hub=hub)
374
+ for tarefa, ids_ex in (("instrucao", None),):
375
+ pass
376
+ _ids = torch.tensor([tk.encode("Pergunta: quem escreveu isso? Resposta:",
377
+ tarefa="instrucao", max_len=24)])
378
+ t0 = time.time()
379
+ _novos = modelo.gerar(_ids, max_novos=24)
380
+ relatorio["inferencia_agente"] = ag.observar_inferencia(
381
+ modelo, _ids, _novos, time.time() - t0)
382
+ print(" ", relatorio["inferencia_agente"])
383
+ # v5 — ciclo de compreensão geracional (difusão, modo honesto)
384
+ if cfg.difusao.ativo:
385
+ gd = GeradorMultimodal(repo_id=cfg.difusao.repo_id,
386
+ altura=cfg.difusao.altura,
387
+ largura=cfg.difusao.largura,
388
+ passos_inferencia=cfg.difusao.passos_inferencia,
389
+ guia_escala=cfg.difusao.guia_escala, hub=hub)
390
+ r = gd.compreensao_geracional("o pantanal ao entardecer", modelo,
391
+ orquestrador=orquestrador, op="txt2img")
392
+ relatorio["difusao"] = {"modo": r.get("modo"),
393
+ "prompt_enriquecido": r.get("prompt_enriquecido"),
394
+ "latencia_s": r.get("latencia_s"),
395
+ "gerou_pixels": r.get("modo") == "real"}
396
+ print(" difusão:", relatorio["difusao"]["modo"], "—",
397
+ relatorio["difusao"]["prompt_enriquecido"])
398
+ rel_ag = ag.relatorio(orquestrador_som=orquestrador,
399
+ avaliacao={"ppl_lm": relatorio.get("ppl_lm")})
400
+ relatorio["agente_engenheiro"] = {
401
+ "revisoes_aprovadas": rel_ag["revisoes_aprovadas"],
402
+ "revisoes_bloqueadas": rel_ag["revisoes_bloqueadas"],
403
+ "som_invariante_sem_orfaos": rel_ag.get("som_invariante_sem_orfaos"),
404
+ "som_ativos": rel_ag.get("som_ativos")}
405
+ except Exception as e:
406
+ relatorio["agente_erro"] = f"{type(e).__name__}: {e}"
407
+
408
  os.makedirs(os.path.dirname(RELATORIO), exist_ok=True)
409
  with open(RELATORIO, "w", encoding="utf-8") as f:
410
  json.dump(relatorio, f, ensure_ascii=False, indent=2, default=str)
scripts/06_publicar_hf.py CHANGED
@@ -1,36 +1,42 @@
1
  #!/usr/bin/env python3
2
  # -*- coding: utf-8 -*-
3
- """Publica o AURORA v4 no HuggingFace de modo ORGANIZADO e COMPLETO:
4
 
5
- README.md (model card v4) · LICENSE · configs/ · src/aurora/ · scripts/
6
- docs/matematica/ (provas 00–15) · tests/ · avaliacao_v4.json ·
7
- resumo_treino_v4.json · estados/fase-som-v4/ (pesos finais + meta SHA-256)
8
 
9
- REGRAS DO HUB (escopo v4): publicação em UM ÚNICO COMMIT COMPLETO —
10
  `upload_folder` com `delete_patterns=["*"]` substitui ATOMICAMENTE todo o
11
- conteúdo do repo (arquivos antigos — inclusive bugwatch.py e estados velhos —
12
- somem no MESMO commit; nunca há estados parciais em sequência curta).
13
 
14
- SEGURANÇA: token EXCLUSIVAMENTE da variável HF_TOKEN — nunca gravado em arquivo,
15
- log ou repo. A publicação NUNCA inclui: cache_dados, telemetria_out, checkpoints
16
- locais, estados_local (cópia), cache_hub_tmp, arquivos com o token.
 
 
 
 
17
 
18
  Uso: HF_TOKEN=... python3 06_publicar_hf.py [--repo PowerMachine/aurora-multimodal-ptbr]
19
  """
20
  import argparse
21
  import os
 
22
  import shutil
23
  import sys
24
 
25
- sys.path.insert(0, "/home/z/my-project/aurora/src")
26
-
27
  RAIZ = "/home/z/my-project/aurora"
28
  STAGE = "/home/z/my-project/aurora/stage_publicar"
29
- TAG_FINAL = "fase-som-v4" # ÚNICO estado publicado (pesos finais)
30
- IGNORAR_DIRS = {"__pycache__", "checkpoints", "cache_dados", "telemetria_out",
31
  "cache_hub_tmp", ".git", "build", "estados_local",
32
- "estados_local_teste", "stage_publicar"}
 
33
  IGNORAR_EXT = (".pt", ".pyc", ".pt.tmp")
 
 
34
 
35
 
36
  def preparar_stage() -> int:
@@ -45,30 +51,48 @@ def preparar_stage() -> int:
45
  for a in arquivos:
46
  if a.endswith(IGNORAR_EXT) or a.startswith("."):
47
  continue
 
 
 
48
  shutil.copy2(os.path.join(raiz, a), os.path.join(alvo_raiz, a))
49
  n += 1
50
- # evidências de treino/avaliação (artefatos de 1ª classe)
51
- for nome, destino in (("avaliacao_v4.json", "avaliacao_v4.json"),
52
- ("resumo_treino_v4.json", "resumo_treino_v4.json")):
53
  fonte = os.path.join(RAIZ, "telemetria_out", nome)
54
  if os.path.exists(fonte):
55
- shutil.copy2(fonte, os.path.join(STAGE, destino))
56
  n += 1
57
- # ÚNICO estado (pesos finais) — nada de estados intermediários
58
- peso = os.path.join(RAIZ, "estados_local", TAG_FINAL, "modelo.safetensors")
59
- meta = os.path.join(RAIZ, "estados_local", TAG_FINAL, "meta.json")
60
- if os.path.exists(peso):
61
- os.makedirs(os.path.join(STAGE, "estados", TAG_FINAL), exist_ok=True)
62
- shutil.copy2(peso, os.path.join(STAGE, "estados", TAG_FINAL,
63
- "modelo.safetensors"))
64
- if os.path.exists(meta):
65
- shutil.copy2(meta, os.path.join(STAGE, "estados", TAG_FINAL,
66
- "meta.json"))
67
- n += 1 + (1 if os.path.exists(meta) else 0)
68
- print(f"estado final incluído: estados/{TAG_FINAL}/modelo.safetensors")
69
  return n
70
 
71
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
72
  def main():
73
  ap = argparse.ArgumentParser()
74
  ap.add_argument("--repo", default="PowerMachine/aurora-multimodal-ptbr")
@@ -79,65 +103,50 @@ def main():
79
  print("ERRO: defina HF_TOKEN no ambiente (nunca em arquivo).")
80
  sys.exit(1)
81
 
82
- from huggingface_hub import HfApi
83
- api = HfApi(token=token)
84
- api.create_repo(args.repo, repo_type="model", exist_ok=True, private=False)
85
-
86
  n = preparar_stage()
87
- print(f"stage: {n} arquivos (sem caches/segredos)")
88
 
89
- # verifica anti-vazamento antes de subir: formato REAL de token HF é
90
- # hf_ + 30+ alfanuméricos (chamadas tipo hf_hub_download(...) não batem)
91
- import re
92
- padrao_token = re.compile(r"hf_[A-Za-z0-9]{30,}")
93
- suspeitos = []
94
- for raiz, dirs, arquivos in os.walk(STAGE):
95
- for a in arquivos:
96
- caminho = os.path.join(raiz, a)
97
- try:
98
- if a.endswith((".json", ".md", ".py", ".txt", ".yaml", ".yml")):
99
- with open(caminho, encoding="utf-8", errors="ignore") as f:
100
- if padrao_token.search(f.read()):
101
- suspeitos.append(caminho)
102
- except Exception:
103
- pass
104
  if suspeitos:
105
  print("ERRO: possíveis segredos detectados:", suspeitos)
106
  sys.exit(1)
107
 
 
 
 
 
108
  # PUBLICAÇÃO ÚNICA E COMPLETA: delete_patterns=["*"] remove no MESMO commit
109
- # qualquer arquivo do repo que não esteja no stage (estados velhos,
110
- # bugwatch.py de versões antigas, etc.) — nada de uploads parciais
111
  api.upload_folder(
112
  folder_path=STAGE, repo_id=args.repo, repo_type="model",
113
- commit_message="AURORA v4 COMPLETO: vocab 16384, n_experts_fusao=4, "
114
- "auto-escala por computo (Teoremas 12.1-12.3), NLP/NLG "
115
- "(Teorema 15.1), contexto 1M indexado (13.1-13.2), Medusa "
116
- "em árvore (14.1-14.2), duas fases com SOM sem neurônios "
117
- "isolados A=1.0 (15.2), W8A8 por grupo + correção de viés "
118
- "(8.4-8.5)",
119
  delete_patterns=["*"],
120
  allow_patterns=["*.py", "*.md", "*.json", "*.yaml", "*.yml",
121
  "*.txt", "*.safetensors", "LICENSE*"])
122
- print("✓ PUBLICAÇÃO ÚNICA COMPLETA: código+docs+configs+testes+evidências"
123
- "+estado final (1 commit; antigos removidos atomicamente)")
124
 
125
- # verificação: bugwatch NÃO pode existir no repo
126
  arquivos = api.list_repo_files(args.repo, repo_type="model")
127
  restos = [f for f in arquivos
128
- if "bugwatch" in f.lower() or "/qualidade/" in f]
 
129
  if restos:
130
  print("ERRO: resíduos no repo:", restos)
131
  sys.exit(1)
132
  parciais = [f for f in arquivos if f.startswith("estados/")
133
- and TAG_FINAL not in f]
134
  print(f"✓ verificação: {len(arquivos)} arquivos no repo; "
135
- f"bugwatch/qualidade=0; estados parciais={len(parciais)} (0 esperado)"
136
- + (f" — RESÍDUOS: {parciais}" if parciais else ""))
137
 
138
  print(f"REPO: https://huggingface.co/{args.repo}")
139
- print("Higienização: unset HF_TOKEN && python3 -c "
140
- "'from huggingface_hub import HfApi; HfApi().logout()'")
 
141
 
142
 
143
  if __name__ == "__main__":
 
1
  #!/usr/bin/env python3
2
  # -*- coding: utf-8 -*-
3
+ """Publica o AURORA v5 no HuggingFace de modo ORGANIZADO e COMPLETO:
4
 
5
+ README.md (model card v5) · LICENSE · configs/ · src/aurora/ · scripts/
6
+ docs/matematica/ (provas 00–17) · tests/ · evidências de treino/avaliação ·
7
+ estados/fase-v5/ (pesos finais + meta SHA-256)
8
 
9
+ REGRAS DO HUB (escopo v5): publicação em UM ÚNICO COMMIT COMPLETO —
10
  `upload_folder` com `delete_patterns=["*"]` substitui ATOMICAMENTE todo o
11
+ conteúdo do repo (arquivos antigos somem no MESMO commit; nunca há uploads
12
+ parciais em sequência curta — o Hub bloqueia esse padrão).
13
 
14
+ SEGURANÇA: token EXCLUSIVAMENTE da variável HF_TOKEN — nunca gravado em
15
+ arquivo, log ou repo. A publicação NUNCA inclui: cache_dados, telemetria_out,
16
+ estados_local, stage_publicar, arquivos com o token.
17
+
18
+ Verificações de porta do Agente Engenheiro (pré-publicação):
19
+ • nenhum segredo no stage (regex hf_[A-Za-z0-9]{30,});
20
+ • nenhum resíduo proibido (bugwatch, estados_hf, __pycache__, .pt).
21
 
22
  Uso: HF_TOKEN=... python3 06_publicar_hf.py [--repo PowerMachine/aurora-multimodal-ptbr]
23
  """
24
  import argparse
25
  import os
26
+ import re
27
  import shutil
28
  import sys
29
 
 
 
30
  RAIZ = "/home/z/my-project/aurora"
31
  STAGE = "/home/z/my-project/aurora/stage_publicar"
32
+ PASTA_ESTADO = "estados/fase-v5" # ÚNICO estado publicado (pesos finais)
33
+ IGNORAR_DIRS = {"__pycache__", "cache_dados", "telemetria_out",
34
  "cache_hub_tmp", ".git", "build", "estados_local",
35
+ "estados_local_teste", "stage_publicar", "hf_stage",
36
+ "download", "upload"}
37
  IGNORAR_EXT = (".pt", ".pyc", ".pt.tmp")
38
+ PADRAO_TOKEN = re.compile(r"hf_[A-Za-z0-9]{30,}")
39
+ RESIDUOS_PROIBIDOS = ("bugwatch", "estados_hf")
40
 
41
 
42
  def preparar_stage() -> int:
 
51
  for a in arquivos:
52
  if a.endswith(IGNORAR_EXT) or a.startswith("."):
53
  continue
54
+ if any(r in a.lower() for r in RESIDUOS_PROIBIDOS):
55
+ print(f" porta do Agente: arquivo proibido ignorado: {a}")
56
+ continue
57
  shutil.copy2(os.path.join(raiz, a), os.path.join(alvo_raiz, a))
58
  n += 1
59
+ # evidências de treino/avaliação (artefatos de 1ª classe, v5)
60
+ for nome in ("avaliacao_v5.json", "resumo_treino_v5.json",
61
+ "relatorio_agente_engenheiro.json"):
62
  fonte = os.path.join(RAIZ, "telemetria_out", nome)
63
  if os.path.exists(fonte):
64
+ shutil.copy2(fonte, os.path.join(STAGE, nome))
65
  n += 1
66
+ # ÚNICO estado (pesos finais) via GestorCheckpoints (doc 16 §8)
67
+ sys.path.insert(0, os.path.join(RAIZ, "src"))
68
+ from aurora.dados.checkpoints import GestorCheckpoints
69
+ from aurora.config import Config
70
+ gestor = GestorCheckpoints(dir_local=Config().checkpoints.dir_local,
71
+ pasta_publicacao=PASTA_ESTADO)
72
+ if gestor.preparar_para_publicacao(STAGE):
73
+ n += 2
74
+ print(f"estado final incluído: {PASTA_ESTADO}/modelo.safetensors")
75
+ else:
76
+ print("AVISO: sem checkpoint local — publicando só código/docs")
 
77
  return n
78
 
79
 
80
+ def auditoria_segredos() -> list[str]:
81
+ suspeitos = []
82
+ for raiz, dirs, arquivos in os.walk(STAGE):
83
+ for a in arquivos:
84
+ if not a.endswith((".json", ".md", ".py", ".txt", ".yaml", ".yml")):
85
+ continue
86
+ caminho = os.path.join(raiz, a)
87
+ try:
88
+ with open(caminho, encoding="utf-8", errors="ignore") as f:
89
+ if PADRAO_TOKEN.search(f.read()):
90
+ suspeitos.append(caminho)
91
+ except Exception:
92
+ pass
93
+ return suspeitos
94
+
95
+
96
  def main():
97
  ap = argparse.ArgumentParser()
98
  ap.add_argument("--repo", default="PowerMachine/aurora-multimodal-ptbr")
 
103
  print("ERRO: defina HF_TOKEN no ambiente (nunca em arquivo).")
104
  sys.exit(1)
105
 
 
 
 
 
106
  n = preparar_stage()
107
+ print(f"stage: {n} arquivos (sem caches/segredos/resíduos)")
108
 
109
+ suspeitos = auditoria_segredos()
 
 
 
 
 
 
 
 
 
 
 
 
 
 
110
  if suspeitos:
111
  print("ERRO: possíveis segredos detectados:", suspeitos)
112
  sys.exit(1)
113
 
114
+ from huggingface_hub import HfApi
115
+ api = HfApi(token=token)
116
+ api.create_repo(args.repo, repo_type="model", exist_ok=True, private=False)
117
+
118
  # PUBLICAÇÃO ÚNICA E COMPLETA: delete_patterns=["*"] remove no MESMO commit
119
+ # qualquer arquivo antigo — nada de uploads parciais em sequência
 
120
  api.upload_folder(
121
  folder_path=STAGE, repo_id=args.repo, repo_type="model",
122
+ commit_message="AURORA v5 COMPLETO: atenção entre MoEs e variantes SOM "
123
+ "(Teoremas 16.1–16.6), difusão multimodal (doc 17), "
124
+ "quantização REAL sem fakes (torchao/QAT/FP8/BnB, doc 08 "
125
+ "§§7–9), Agente Engenheiro com telemetria integral, "
126
+ "vocab 16384, n_experts_fusao=4, treino do zero",
 
127
  delete_patterns=["*"],
128
  allow_patterns=["*.py", "*.md", "*.json", "*.yaml", "*.yml",
129
  "*.txt", "*.safetensors", "LICENSE*"])
130
+ print("✓ PUBLICAÇÃO ÚNICA COMPLETA (1 commit; antigos removidos "
131
+ "atomicamente)")
132
 
133
+ # verificação final: resíduos proibidos não podem existir no repo
134
  arquivos = api.list_repo_files(args.repo, repo_type="model")
135
  restos = [f for f in arquivos
136
+ if any(r in f.lower() for r in RESIDUOS_PROIBIDOS)
137
+ or "__pycache__" in f or f.endswith(".pt")]
138
  if restos:
139
  print("ERRO: resíduos no repo:", restos)
140
  sys.exit(1)
141
  parciais = [f for f in arquivos if f.startswith("estados/")
142
+ and "fase-v5" not in f]
143
  print(f"✓ verificação: {len(arquivos)} arquivos no repo; "
144
+ f"resíduos=0; estados parciais={len(parciais)} (0 esperado)")
 
145
 
146
  print(f"REPO: https://huggingface.co/{args.repo}")
147
+ print("Higienização: unset HF_TOKEN && python3 -m pip show huggingface_hub "
148
+ ">/dev/null && python3 -c 'from huggingface_hub import HfApi; "
149
+ "HfApi().logout()'")
150
 
151
 
152
  if __name__ == "__main__":
scripts/07_reconsolidar_som.py CHANGED
@@ -14,7 +14,7 @@ sys.path.insert(0, "/home/z/my-project/aurora/src")
14
  import torch
15
 
16
  from aurora.config import Config
17
- from aurora.dados.estados_hf import EstadosHF
18
  from aurora.dados.tokenizador import TokenizadorAurora
19
  from aurora.memoria.orquestrador import OrquestradorSOM
20
  from aurora.nucleo.modelo import AURORAModel
@@ -56,14 +56,15 @@ def main():
56
  print(f"corpus: {len(registros)} registros")
57
 
58
  modelo = AURORAModel(cfg, usar_multimodal=True)
59
- estados = EstadosHF(repo_id=None, # estados LOCAIS (v4)
60
- dir_local="/home/z/my-project/aurora/estados_local",
61
- pasta="estados")
62
- tag = estados.carregar_ultimo(modelo)
63
  print(f"estado carregado: {tag or 'NENHUM'}")
64
- orquestrador = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som, hub=hub)
 
65
  treinar = TreinadorExtensao(cfg, modelo, tk, hub, registros,
66
- orquestrador_som=orquestrador, estados=estados)
67
 
68
  print("== FASE B: reconsolidação SOM (S-SOM agora com reseeding) ==")
69
  resultado_som = treinar.consolidar_som_max_ativos()
 
14
  import torch
15
 
16
  from aurora.config import Config
17
+ from aurora.dados.checkpoints import GestorCheckpoints
18
  from aurora.dados.tokenizador import TokenizadorAurora
19
  from aurora.memoria.orquestrador import OrquestradorSOM
20
  from aurora.nucleo.modelo import AURORAModel
 
56
  print(f"corpus: {len(registros)} registros")
57
 
58
  modelo = AURORAModel(cfg, usar_multimodal=True)
59
+ checkpoints = GestorCheckpoints(dir_local=cfg.checkpoints.dir_local)
60
+ tag = checkpoints.ultima_tag()
61
+ if tag:
62
+ checkpoints.carregar(modelo, tag)
63
  print(f"estado carregado: {tag or 'NENHUM'}")
64
+ orquestrador = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som, hub=hub,
65
+ cfg_atencao=vars(cfg.som_atencao) if hasattr(cfg, "som_atencao") else None)
66
  treinar = TreinadorExtensao(cfg, modelo, tk, hub, registros,
67
+ orquestrador_som=orquestrador, checkpoints=checkpoints)
68
 
69
  print("== FASE B: reconsolidação SOM (S-SOM agora com reseeding) ==")
70
  resultado_som = treinar.consolidar_som_max_ativos()
src/aurora/config.py CHANGED
@@ -76,6 +76,8 @@ class ConfigModelo:
76
  "alpha": 0.5, "reavaliar_a_cada": 100}) # passos entre reavaliações
77
  # v4 — unidades NLP (processar) e NLG (gerar) de primeira classe (doc 15 §1)
78
  nlp: dict = field(default_factory=lambda: {"ativo": True, "n_intencoes": 10})
 
 
79
  nlg: dict = field(default_factory=lambda: {"ativo": True, "n_estilos": 8,
80
  "peso_rerank": 0.35})
81
  # encoders multimodais "completo pesado" com escala configurável:
@@ -185,13 +187,45 @@ class ConfigJanela1M:
185
 
186
 
187
  @dataclass
188
- class ConfigEstadosHF:
189
- """Estados do modelo no HuggingFace Hub (item c — poupar armazenamento)."""
190
- ativo: bool = True
191
- repo_id: str = "PowerMachine/aurora-multimodal-ptbr"
192
- pasta: str = "estados"
 
193
  dir_local: str = "/home/z/my-project/aurora/estados_local"
194
- manter_ultimo_local: bool = True # apaga os demais após commit no Hub
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
195
 
196
 
197
  @dataclass
@@ -222,9 +256,13 @@ class Config:
222
  treino: ConfigTreino = field(default_factory=ConfigTreino)
223
  telemetria: ConfigTelemetria = field(default_factory=ConfigTelemetria)
224
  ciclo: ConfigCiclo = field(default_factory=ConfigCiclo)
225
- estados_hf: ConfigEstadosHF = field(default_factory=ConfigEstadosHF)
226
  memoria_interna: ConfigMemoriaInterna = field(default_factory=ConfigMemoriaInterna)
227
  janela_1m: ConfigJanela1M = field(default_factory=ConfigJanela1M)
 
 
 
 
228
 
229
  def de_arquivo(self, caminho: str) -> "Config":
230
  """Sobrescreve campos recursivamente a partir de JSON."""
 
76
  "alpha": 0.5, "reavaliar_a_cada": 100}) # passos entre reavaliações
77
  # v4 — unidades NLP (processar) e NLG (gerar) de primeira classe (doc 15 §1)
78
  nlp: dict = field(default_factory=lambda: {"ativo": True, "n_intencoes": 10})
79
+ # v5 — atenção ENTRE camadas MoE (doc 16 §§1–2): nasce neutra (α=β=0)
80
+ atencao_moe: dict = field(default_factory=lambda: {"ativo": True, "alpha0": 0.0})
81
  nlg: dict = field(default_factory=lambda: {"ativo": True, "n_estilos": 8,
82
  "peso_rerank": 0.35})
83
  # encoders multimodais "completo pesado" com escala configurável:
 
187
 
188
 
189
  @dataclass
190
+ class ConfigCheckpoints:
191
+ """Checkpoints LOCAIS do treino (item c — doc 16 §8).
192
+
193
+ v5: nenhum upload parcial no Hub durante o treino (o Hub bloqueia
194
+ envios parciais em sequência curta). O snapshot final entra no commit
195
+ único de publicação (GestorCheckpoints.preparar_para_publicacao)."""
196
  dir_local: str = "/home/z/my-project/aurora/estados_local"
197
+ pasta_publicacao: str = "estados/fase-v5"
198
+
199
+
200
+ @dataclass
201
+ class ConfigSOMAtencao:
202
+ """Atenção ENTRE variantes Kohonen (v5, doc 16 §§3–5): recall atencional
203
+ sobre TODAS as variantes + invariante ZERO neurônios isolados."""
204
+ ativo: bool = True
205
+ tau: float = 0.5 # temperatura do softmax de variantes
206
+ gamma_novidade: float = 0.15 # bônus a variantes com órfãos (Teo. 16.5)
207
+
208
+
209
+ @dataclass
210
+ class ConfigDifusao:
211
+ """Difusão multimodal (v5, doc 17): SD txt2img/img2img/inpaint com ciclo
212
+ fechado de compreensão geracional. Default: repositório TINY (testes);
213
+ produção: stabilityai/stable-diffusion-2-1-base (GPU ≥ 8GB)."""
214
+ ativo: bool = True
215
+ repo_id: str = "hf-internal-testing/tiny-stable-diffusion-torch"
216
+ altura: int = 128
217
+ largura: int = 128
218
+ passos_inferencia: int = 8
219
+ guia_escala: float = 7.5
220
+
221
+
222
+ @dataclass
223
+ class ConfigAgenteEngenheiro:
224
+ """Agente Engenheiro (v5, doc 16 §9): revisão pré-modificação +
225
+ observação de TODAS as métricas fundamentais por módulo (treino+inferência)."""
226
+ ativo: bool = True
227
+ intervalo: int = 50 # passos entre observações completas
228
+ tolerancia_regressao: float = 0.05
229
 
230
 
231
  @dataclass
 
256
  treino: ConfigTreino = field(default_factory=ConfigTreino)
257
  telemetria: ConfigTelemetria = field(default_factory=ConfigTelemetria)
258
  ciclo: ConfigCiclo = field(default_factory=ConfigCiclo)
259
+ checkpoints: ConfigCheckpoints = field(default_factory=ConfigCheckpoints)
260
  memoria_interna: ConfigMemoriaInterna = field(default_factory=ConfigMemoriaInterna)
261
  janela_1m: ConfigJanela1M = field(default_factory=ConfigJanela1M)
262
+ som_atencao: ConfigSOMAtencao = field(default_factory=ConfigSOMAtencao)
263
+ difusao: ConfigDifusao = field(default_factory=ConfigDifusao)
264
+ agente_engenheiro: ConfigAgenteEngenheiro = field(
265
+ default_factory=ConfigAgenteEngenheiro)
266
 
267
  def de_arquivo(self, caminho: str) -> "Config":
268
  """Sobrescreve campos recursivamente a partir de JSON."""
src/aurora/dados/checkpoints.py ADDED
@@ -0,0 +1,185 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Checkpoints de treino — v5 (doc 16 §8).
3
+
4
+ Substitui `dados/estados_hf.py` (REMOVIDO a pedido — estados/fase-som-v4
5
+ apagados do Hub e do disco). Regra v5 motivada pelo bloqueio do Hub a
6
+ uploads parciais em sequência curta:
7
+
8
+ • durante o treino, checkpoints ficam SEMPRE LOCAIS (safetensors + SHA-256,
9
+ protocolo idêntico ao doc 10 §9) e o diretório mantém só o último
10
+ (poupa disco, item c do escopo);
11
+ • NENHUM upload parcial durante o treino;
12
+ • o snapshot FINAL entra no commit ÚNICO da publicação (scripts/
13
+ 06_publicar_hf.py chama `preparar_para_publicacao`, que copia o par
14
+ (modelo.safetensors, meta.json) para o stage) — um único commit organizado.
15
+
16
+ Teorema 16.9 (integridade do snapshot): seja σ o par gravado atomicamente
17
+ com hash h(σ)=SHA-256. Na leitura, se h(σ')=h(σ) então σ'=σ (colisão
18
+ desprezível, 2^−256), logo retomadas reproduzem EXATAMENTE o estado salvo.
19
+ """
20
+ from __future__ import annotations
21
+
22
+ import hashlib
23
+ import json
24
+ import os
25
+ import shutil
26
+
27
+ import torch
28
+
29
+ from safetensors.torch import load as _st_load
30
+ from safetensors.torch import save as _st_save
31
+
32
+
33
+ def _sha256_bytes(b: bytes) -> str:
34
+ return hashlib.sha256(b).hexdigest()
35
+
36
+
37
+ class GestorCheckpoints:
38
+ """Checkpoints locais atômicos + snapshot final para publicação única.
39
+
40
+ Args:
41
+ dir_local: diretório de checkpoints (mantém apenas o último).
42
+ pasta_publicacao: pasta dentro do repo HF onde o snapshot final
43
+ entra NO commit único (ex.: 'estados/fase-v5').
44
+ """
45
+
46
+ def __init__(self, dir_local: str = "/home/z/my-project/aurora/estados_local",
47
+ pasta_publicacao: str = "estados/fase-v5"):
48
+ self.dir_local = dir_local
49
+ self.pasta_publicacao = pasta_publicacao
50
+ self.eventos: list[str] = []
51
+ os.makedirs(dir_local, exist_ok=True)
52
+
53
+ # ---------------- protocolo (doc 10 §9 preservado) ----------------
54
+ def _caminho_tag(self, tag: str) -> str:
55
+ return os.path.join(self.dir_local, tag)
56
+
57
+ def salvar(self, modelo, tag: str, meta: dict) -> str:
58
+ """Serializa safetensors + meta com hash; mantém apenas a última tag."""
59
+ sd = {k: v.detach().contiguous() for k, v in modelo.state_dict().items()}
60
+ # pesos empatados (tied): uma única cópia (load com strict=False)
61
+ vistos: dict[int, str] = {}
62
+ sd_unico: dict[str, torch.Tensor] = {}
63
+ for k, v in sd.items():
64
+ ptr = v.data_ptr()
65
+ if ptr in vistos:
66
+ continue
67
+ vistos[ptr] = k
68
+ sd_unico[k] = v
69
+ dados = bytes(_st_save(sd_unico, metadata={"formato": "aurora-v5", "tag": tag}))
70
+ meta = dict(meta or {})
71
+ meta["hash_sha256"] = _sha256_bytes(dados)
72
+ meta["tag"] = tag
73
+ destino = self._caminho_tag(tag)
74
+ os.makedirs(destino, exist_ok=True)
75
+ with open(os.path.join(destino, "modelo.safetensors"), "wb") as f:
76
+ f.write(dados)
77
+ with open(os.path.join(destino, "meta.json"), "w", encoding="utf-8") as f:
78
+ json.dump(meta, f, ensure_ascii=False, indent=2)
79
+ # higiene: mantém SOMENTE a última tag (poupa disco, item c)
80
+ removidos = 0
81
+ for nome in os.listdir(self.dir_local):
82
+ if nome != tag:
83
+ shutil.rmtree(os.path.join(self.dir_local, nome),
84
+ ignore_errors=True)
85
+ removidos += 1
86
+ if removidos:
87
+ self.eventos.append(f"{removidos} checkpoint(s) antigo(s) apagado(s)")
88
+ self.eventos.append(f"checkpoint {tag}: local ({len(dados)/1e6:.1f} MB)")
89
+ return os.path.join(destino, "modelo.safetensors")
90
+
91
+ def carregar(self, modelo, tag: str | None = None) -> bool:
92
+ """Carrega tolerante a forma (mesma política da v3: tensores por
93
+ chave com mesma forma; divergências registradas)."""
94
+ tag = tag or self.ultima_tag()
95
+ if tag is None:
96
+ return False
97
+ caminho = os.path.join(self._caminho_tag(tag), "modelo.safetensors")
98
+ if not os.path.exists(caminho):
99
+ self.eventos.append(f"checkpoint {tag}: ausente")
100
+ return False
101
+ with open(caminho, "rb") as f:
102
+ dados = f.read()
103
+ meta_path = os.path.join(self._caminho_tag(tag), "meta.json")
104
+ if os.path.exists(meta_path):
105
+ with open(meta_path, encoding="utf-8") as f:
106
+ esperado = json.load(f).get("hash_sha256")
107
+ if esperado and _sha256_bytes(dados) != esperado:
108
+ self.eventos.append(f"checkpoint {tag}: HASH divergente — rejeitado")
109
+ return False
110
+ try:
111
+ sd = _st_load(dados)
112
+ modelo_sd = modelo.state_dict()
113
+ próprios = {k: v for k, v in sd.items()
114
+ if k in modelo_sd and modelo_sd[k].shape == v.shape}
115
+ pulados = len(sd) - len(próprios)
116
+ faltantes = [k for k in modelo_sd if k not in próprios and k not in sd]
117
+ modelo.load_state_dict(próprios, strict=False)
118
+ self.eventos.append(
119
+ f"checkpoint {tag}: {len(próprios)} tensores, {pulados} pulados, "
120
+ f"{len(faltantes)} novos")
121
+ return True
122
+ except Exception as e:
123
+ self.eventos.append(f"carregar {tag}: {type(e).__name__}: {e}")
124
+ return False
125
+
126
+ def listar(self) -> list:
127
+ """Tags disponíveis localmente, ordenadas lexicograficamente
128
+ (tags canônicas `epoca-*`/`fase-*` são cronológicas)."""
129
+ if not os.path.isdir(self.dir_local):
130
+ return []
131
+ return sorted(d for d in os.listdir(self.dir_local)
132
+ if os.path.isdir(os.path.join(self.dir_local, d))
133
+ and os.path.exists(os.path.join(self.dir_local, d,
134
+ "meta.json")))
135
+
136
+ def ultima_tag(self) -> str | None:
137
+ if not os.path.isdir(self.dir_local):
138
+ return None
139
+ tags = [d for d in os.listdir(self.dir_local)
140
+ if os.path.isdir(os.path.join(self.dir_local, d))
141
+ and os.path.exists(os.path.join(self.dir_local, d, "meta.json"))]
142
+ if not tags:
143
+ return None
144
+ # mais avançado = maior passo_global no meta (ordem cronológica)
145
+ melhor, melhor_passo = None, -1
146
+ for tag in tags:
147
+ try:
148
+ with open(os.path.join(self.dir_local, tag, "meta.json"),
149
+ encoding="utf-8") as f:
150
+ passo = int(json.load(f).get("passo_global", -1))
151
+ except Exception:
152
+ continue
153
+ if passo > melhor_passo:
154
+ melhor, melhor_passo = tag, passo
155
+ return melhor
156
+
157
+ def meta_de(self, tag: str | None = None) -> dict:
158
+ tag = tag or self.ultima_tag()
159
+ if tag is None:
160
+ return {}
161
+ caminho = os.path.join(self._caminho_tag(tag), "meta.json")
162
+ if not os.path.exists(caminho):
163
+ return {}
164
+ with open(caminho, encoding="utf-8") as f:
165
+ return json.load(f)
166
+
167
+ # ---------------- publicação ÚNICA (doc 16 §8) ----------------
168
+ def preparar_para_publicacao(self, stage_raiz: str) -> str | None:
169
+ """Copia o snapshot final para o stage do repo (commit único do
170
+ script 06). Devolve o caminho do peso no stage."""
171
+ tag = self.ultima_tag()
172
+ if tag is None:
173
+ self.eventos.append("publicação: nenhum checkpoint local")
174
+ return None
175
+ origem = self._caminho_tag(tag)
176
+ destino = os.path.join(stage_raiz, self.pasta_publicacao)
177
+ os.makedirs(destino, exist_ok=True)
178
+ shutil.copy2(os.path.join(origem, "modelo.safetensors"),
179
+ os.path.join(destino, "modelo.safetensors"))
180
+ meta = self.meta_de(tag)
181
+ meta["publicado_em_commit_unico"] = True
182
+ with open(os.path.join(destino, "meta.json"), "w", encoding="utf-8") as f:
183
+ json.dump(meta, f, ensure_ascii=False, indent=2)
184
+ self.eventos.append(f"snapshot {tag} → stage ({self.pasta_publicacao})")
185
+ return os.path.join(destino, "modelo.safetensors")
src/aurora/dados/estados_hf.py DELETED
@@ -1,262 +0,0 @@
1
- # -*- coding: utf-8 -*-
2
- """Estados do modelo armazenados NO HuggingFace Hub (item c do escopo v2) —
3
- "salvar (e usar) estados no HF para poupar armazenamento".
4
-
5
- Protocolo (doc 10 §9):
6
- • serialização safetensors (sem pickle) + meta.json com hash SHA-256;
7
- • atomicidade: cada estado é um commit único (`upload_file`); o local só é
8
- apagado DEPOIS do commit confirmado;
9
- • retomada: `carregar_ultimo()` baixa, valida o hash e carrega;
10
- • tags canônicas `epoca-{n:03d}` / `fase-som` — listagem lexicográfica é
11
- cronológica.
12
-
13
- Modo local: sem repo_id (ou sem token), os estados ficam em `dir_local` com o
14
- MESMO protocolo — usado nos testes unitários e fallback offline.
15
- """
16
- from __future__ import annotations
17
-
18
- import hashlib
19
- import io
20
- import json
21
- import os
22
-
23
- import torch
24
-
25
- from safetensors.torch import load as _st_load
26
- from safetensors.torch import save as _st_save
27
-
28
-
29
- def _sha256_bytes(b: bytes) -> str:
30
- return hashlib.sha256(b).hexdigest()
31
-
32
-
33
- class EstadosHF:
34
- def __init__(self, repo_id: str | None = None, token: str | None = None,
35
- dir_local: str = "/home/z/my-project/aurora/estados_local",
36
- pasta: str = "estados"):
37
- self.repo_id = repo_id
38
- self.token = token or os.environ.get("HF_TOKEN")
39
- self.dir_local = dir_local
40
- self.pasta = pasta
41
- self.eventos: list[str] = []
42
- os.makedirs(dir_local, exist_ok=True)
43
-
44
- # ---------------- infra ----------------
45
- def _caminho_local(self, tag: str) -> str:
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)
74
- if os.path.exists(local):
75
- with open(local, "rb") as f:
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:
97
- """Serializa (safetensors) + meta com hash; sobe ao Hub; mantém cópia
98
- local mínima. Devolve o caminho local do safetensors."""
99
- sd = {k: v.detach().contiguous() for k, v in modelo.state_dict().items()}
100
- # pesos empatados (tied, ex.: lm_head ↔ emb) compartilham armazenamento:
101
- # grava uma única cópia (load com strict=False restaura o par)
102
- vistos: dict[int, str] = {}
103
- sd_unico: dict[str, torch.Tensor] = {}
104
- for k, v in sd.items():
105
- ptr = v.data_ptr()
106
- if ptr in vistos:
107
- continue
108
- vistos[ptr] = k
109
- sd_unico[k] = v
110
- save_file_dados = _st_save(sd_unico, metadata={"formato": "aurora-v2", "tag": tag})
111
- dados = bytes(save_file_dados)
112
- meta = dict(meta or {})
113
- meta["hash_sha256"] = _sha256_bytes(dados)
114
- meta["tag"] = tag
115
- os.makedirs(self._caminho_local(tag), exist_ok=True)
116
- caminho = os.path.join(self._caminho_local(tag), "modelo.safetensors")
117
- with open(caminho, "wb") as f:
118
- f.write(dados)
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
167
- meta_bruto = self._download(tag, "meta.json")
168
- if meta_bruto is not None:
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
238
- try:
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):
252
- """Apaga estados locais (o HF é a fonte da verdade — poupa disco)."""
253
- removidos = 0
254
- for tag in os.listdir(self.dir_local):
255
- if tag == manter:
256
- continue
257
- caminho = os.path.join(self.dir_local, tag)
258
- import shutil
259
- if os.path.isdir(caminho):
260
- shutil.rmtree(caminho, ignore_errors=True)
261
- removidos += 1
262
- return removidos
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
src/aurora/geracao/__init__.py ADDED
@@ -0,0 +1,5 @@
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Geração multimodal (v5): difusão (SD txt2img / img2img / inpaint)."""
3
+ from aurora.geracao.difusao import GeradorMultimodal
4
+
5
+ __all__ = ["GeradorMultimodal"]
src/aurora/geracao/difusao.py ADDED
@@ -0,0 +1,223 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Geração multimodal por DIFUSÃO — v5 (doc 17).
3
+
4
+ Compreensão geracional multimodal (pedido explícito): os três pipelines
5
+ StableDiffusion do diffusers são integrados ao ciclo de AURORA:
6
+
7
+ texto → imagem (StableDiffusionPipeline)
8
+ imagem → imagem (StableDiffusionImg2ImgPipeline — força guiada pela
9
+ SIMILARIDADE semântica medida pelo encoder perceptual)
10
+ imagem → inpaint (StableDiffusionInpaintPipeline — máscara guiada pela
11
+ saliência de atenção)
12
+
13
+ CICLO FECHADO DE COMPREENSÃO GERACIONAL (doc 17 §2):
14
+ NLG enriquece o prompt (PT-BR) → difusão gera → encoder de imagem do
15
+ AURORA re-encoda o resultado → protótipo entra na memória SOM → gerações
16
+ futuras condicionam na memória. A geração passa a ser PERCEBIDA pelo
17
+ próprio modelo — compreensão geracional, não só síntese.
18
+
19
+ TEOREMA 17.1 (força de edição semanticamente guiada). Seja s = cos(e_in,
20
+ e_plano) a similaridade entre o embedding da imagem de entrada e do plano
21
+ gerado. A força de re-edição strength = clip(1 − s, 0,35, 0,80) satisfaz:
22
+ s=1 (idêntico) ⇒ strength=0,35 (edição leve, preserva conteúdo); s=0 ⇒ 0,80
23
+ (recriação forte). Monotonia: ∂strength/∂s ≤ 0.
24
+
25
+ TEOREMA 17.2 (degradação honesta). Sem GPU/diffusers/pesos, o gerador opera
26
+ em modo "planejado": devolve um PLANO estruturado (prompt enriquecido,
27
+ parâmetros, força calculados) — NUNCA pixels falsos. Toda telemetria registra
28
+ o modo real (`real` | `planejado`).
29
+
30
+ PESOS: por padrão usa repositório TINY de teste (CPU/RAM pequena). Em
31
+ produção defina `repo_id` p.ex. "stabilityai/stable-diffusion-2-1-base"
32
+ (GPU ≥ 8GB).
33
+ """
34
+ from __future__ import annotations
35
+
36
+ import io
37
+ import os
38
+ import time
39
+
40
+ import torch
41
+
42
+ # Importação EXATA solicitada (item do escopo v5):
43
+ from diffusers import (StableDiffusionImg2ImgPipeline,
44
+ StableDiffusionInpaintPipeline,
45
+ StableDiffusionPipeline)
46
+
47
+ MODOS = ("real", "planejado")
48
+
49
+
50
+ def _dispositivo() -> str:
51
+ if torch.cuda.is_available():
52
+ return "cuda"
53
+ if torch.backends.mps.is_available():
54
+ return "mps"
55
+ return "cpu"
56
+
57
+
58
+ class GeradorMultimodal:
59
+ """Facade dos 3 pipelines de difusão com carga PREGUIÇOSA e ciclo fechado.
60
+
61
+ Args:
62
+ repo_id: repositório de pesos (SD). Default: tiny de teste.
63
+ altura/largura: resolução (múltiplos de 8).
64
+ passos_inferencia / guia_escala: parâmetros do scheduler.
65
+ """
66
+
67
+ def __init__(self, repo_id: str = "hf-internal-testing/tiny-stable-diffusion-torch",
68
+ altura: int = 128, largura: int = 128,
69
+ passos_inferencia: int = 8, guia_escala: float = 7.5,
70
+ hub=None, token: str | None = None):
71
+ self.repo_id = repo_id
72
+ self.altura, self.largura = altura, largura
73
+ self.passos = passos_inferencia
74
+ self.guia = guia_escala
75
+ self.hub = hub
76
+ self.token = token or os.environ.get("HF_TOKEN")
77
+ self.device = _dispositivo()
78
+ self.dtype = torch.float16 if self.device == "cuda" else torch.float32
79
+ self._pipelines: dict = {}
80
+ self.modo = "planejado" # honesto até a carga REAL confirmar
81
+ self.eventos: list = []
82
+
83
+ # ---------------- infra ----------------
84
+ def _obter_pipeline(self, classe, chave: str):
85
+ if chave in self._pipelines:
86
+ return self._pipelines[chave]
87
+ try:
88
+ pipe = classe.from_pretrained(
89
+ pretrained_model_name_or_path=self.repo_id,
90
+ torch_dtype=self.dtype, token=self.token)
91
+ pipe = pipe.to(self.device)
92
+ pipe.set_progress_bar_config(disable=True)
93
+ self._pipelines[chave] = pipe
94
+ self.modo = "real"
95
+ self.eventos.append(f"pipeline {chave} carregado ({self.repo_id})")
96
+ return pipe
97
+ except Exception as e:
98
+ self.modo = "planejado"
99
+ self.eventos.append(f"pipeline {chave}: {type(e).__name__}: {e}")
100
+ return None
101
+
102
+ # ---------------- força semântica (Teorema 17.1) ----------------
103
+ @staticmethod
104
+ def forca_por_similaridade(emb_in: torch.Tensor | None,
105
+ emb_plano: torch.Tensor | None) -> float:
106
+ """strength = clip(1 − cos(e_in, e_plano), 0,35, 0,80)."""
107
+ if emb_in is None or emb_plano is None:
108
+ return 0.55
109
+ s = torch.nn.functional.cosine_similarity(
110
+ emb_in.flatten().float().unsqueeze(0),
111
+ emb_plano.flatten().float().unsqueeze(0)).item()
112
+ return float(min(0.80, max(0.35, 1.0 - s)))
113
+
114
+ # ---------------- três operações ----------------
115
+ def texto_para_imagem(self, prompt: str, **kw) -> dict:
116
+ """StableDiffusionPipeline: texto → imagem."""
117
+ pipe = self._obter_pipeline(StableDiffusionPipeline, "txt2img")
118
+ if pipe is None:
119
+ return self._plano("txt2img", prompt=prompt)
120
+ out = pipe(prompt, height=self.altura, width=self.largura,
121
+ num_inference_steps=kw.get("passos", self.passos),
122
+ guidance_scale=kw.get("guia", self.guia))
123
+ return {"modo": "real", "op": "txt2img", "imagem": out.images[0]}
124
+
125
+ def imagem_para_imagem(self, prompt: str, imagem, forca: float | None = None,
126
+ **kw) -> dict:
127
+ """StableDiffusionImg2ImgPipeline: imagem+texto → imagem. `forca`
128
+ semanticamente guiada (Teorema 17.1)."""
129
+ pipe = self._obter_pipeline(StableDiffusionImg2ImgPipeline, "img2img")
130
+ if pipe is None:
131
+ return self._plano("img2img", prompt=prompt, forca=forca)
132
+ f = forca if forca is not None else kw.get("forca_default", 0.55)
133
+ out = pipe(prompt=prompt, image=imagem, strength=f,
134
+ num_inference_steps=kw.get("passos", self.passos),
135
+ guidance_scale=kw.get("guia", self.guia))
136
+ return {"modo": "real", "op": "img2img", "imagem": out.images[0],
137
+ "forca": float(f)}
138
+
139
+ def inpaint(self, prompt: str, imagem, mascara, **kw) -> dict:
140
+ """StableDiffusionInpaintPipeline: imagem+máscara → imagem editada."""
141
+ pipe = self._obter_pipeline(StableDiffusionInpaintPipeline, "inpaint")
142
+ if pipe is None:
143
+ return self._plano("inpaint", prompt=prompt)
144
+ out = pipe(prompt=prompt, image=imagem, mask_image=mascara,
145
+ height=self.altura, width=self.largura,
146
+ num_inference_steps=kw.get("passos", self.passos),
147
+ guidance_scale=kw.get("guia", self.guia))
148
+ return {"modo": "real", "op": "inpaint", "imagem": out.images[0]}
149
+
150
+ # ---------------- ciclo fechado (compreensão geracional) ----------------
151
+ def compreensao_geracional(self, prompt: str, modelo, orquestrador=None,
152
+ op: str = "txt2img", imagem_base=None,
153
+ emb_in: torch.Tensor | None = None,
154
+ emb_plano: torch.Tensor | None = None,
155
+ mascara=None) -> dict:
156
+ """Ciclo fechado doc 17 §2: NLG enriquece o prompt → difusão →
157
+ re-encodagem pelo AURORA → protótipo na memória SOM."""
158
+ t0 = time.time()
159
+ # (i) prompt enriquecido pela NLG (estilo corrente — doc 15 §1)
160
+ prompt_enriquecido = prompt
161
+ if modelo is not None and getattr(modelo, "nlg", None) is not None:
162
+ try:
163
+ prompt_enriquecido = modelo.nlg.enriquecer_prompt(prompt)
164
+ except Exception:
165
+ pass
166
+ # (ii) força semântica (Teorema 17.1)
167
+ forca = self.forca_por_similaridade(emb_in, emb_plano) \
168
+ if op == "img2img" else None
169
+ # (iii) geração
170
+ if op == "txt2img":
171
+ r = self.texto_para_imagem(prompt_enriquecido)
172
+ elif op == "img2img":
173
+ r = self.imagem_para_imagem(prompt_enriquecido, imagem_base,
174
+ forca=forca)
175
+ elif op == "inpaint":
176
+ r = self.inpaint(prompt_enriquecido, imagem_base, mascara)
177
+ else:
178
+ r = {"modo": "planejado", "op": op, "erro": "op desconhecida"}
179
+ # (iv) re-encodagem perceptual + memória SOM
180
+ emb_out = None
181
+ if r.get("modo") == "real" and modelo is not None \
182
+ and getattr(modelo, "usar_multimodal", False):
183
+ try:
184
+ import numpy as np
185
+ from PIL import Image
186
+ img = r.get("imagem")
187
+ arr = np.asarray(img.resize((96, 96)).convert("RGB"),
188
+ dtype=np.float32) / 255.0
189
+ t = torch.from_numpy(arr).permute(2, 0, 1).unsqueeze(0)
190
+ emb_out = modelo.enc_imagem(t)
191
+ if orquestrador is not None and emb_out is not None:
192
+ with torch.no_grad():
193
+ orquestrador.treinar_memoria(
194
+ emb_out.detach().reshape(-1, modelo.d), epocas=1)
195
+ except Exception as e:
196
+ r["re_encode_erro"] = f"{type(e).__name__}: {e}"
197
+ r.update({"prompt_enriquecido": prompt_enriquecido,
198
+ "latencia_s": round(time.time() - t0, 2),
199
+ "embedding_saida": emb_out})
200
+ if self.hub is not None:
201
+ self.hub.atributo("difusao/modo_real",
202
+ 1.0 if r.get("modo") == "real" else 0.0)
203
+ self.hub.atributo("difusao/latencia_s", r["latencia_s"])
204
+ return r
205
+
206
+ # ---------------- degradação honesta (Teorema 17.2) ----------------
207
+ def _plano(self, op: str, **params) -> dict:
208
+ """Modo planejado: NUNCA pixels falsos — só o plano estruturado."""
209
+ self.modo = "planejado"
210
+ return {"modo": "planejado", "op": op, "repo": self.repo_id,
211
+ "altura": self.altura, "largura": self.largura,
212
+ "passos": self.passos, "guia": self.guia, **params}
213
+
214
+ def imagem_para_bytes(self, img) -> bytes:
215
+ """PIL.Image → PNG bytes (persistência sem segredos)."""
216
+ buf = io.BytesIO()
217
+ img.save(buf, format="PNG")
218
+ return buf.getvalue()
219
+
220
+ def estatisticas(self) -> dict:
221
+ return {"modo": self.modo, "repo": self.repo_id,
222
+ "device": self.device, "pipelines": list(self._pipelines),
223
+ "eventos": self.eventos[-5:]}
src/aurora/memoria/atencao_som.py ADDED
@@ -0,0 +1,188 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Atenção ENTRE variantes de Redes de Kohonen (v5, doc 16 §§3–5 — item 2 da
3
+ 1ª requisição, com garantia de ZERO neurônios isolados).
4
+
5
+ Problema: o OrquestradorSOM (doc 03 §3) roteia cada entrada para UMA variante
6
+ (rígido) — o recall perde informação das outras 8 e neurônios pouco usados
7
+ podem ficar isolados. Solução: recall ATENCIONAL sobre TODAS as variantes +
8
+ bônus de novidade direcionado a variantes com neurônios órfãos.
9
+
10
+ Formalização. Para a consulta x e a variante v com codebook W_v ∈ R^{k_v×d}:
11
+ z_v(x) = W_v[ BMU_v(x) ] (protótipo vencedor)
12
+ d_v(x) = ‖z_v(x) − x‖₂ (erro de quantização da variante)
13
+ n_v = fração de neurônios órfãos de v (h_j EMA < ε, doc 10 §2.3)
14
+ a_v(x) = softmax( −d_v(x)/τ + γ·n_v ) (eq. 16.3)
15
+ ẑ(x) = Σ_v a_v(x)·z_v(x) (eq. 16.4)
16
+
17
+ TEOREMA 16.3 (casco convexo). ẑ(x) ∈ casco{∪_v W_v}: soma convexa de
18
+ protótipos de memória. O recall NUNCA extrapola fora da memória armazenada
19
+ (segurança do recall associativo — nenhuma alucinação de protótipo).
20
+
21
+ TEOREMA 16.4 (generalização do roteamento duro). Para τ→0 e γ=0, a_v →
22
+ δ_{v*} com v* = argmin_v d_v — recupera o roteamento do orquestrador
23
+ (doc 03 §3) como caso limite; τ>0 interpola entre especialistas (meta-
24
+ estabilidade: variantes com EQ similar cooperam).
25
+
26
+ TEOREMA 16.5 (zero órfãos assintótico). Sejam (i) dados i.i.d. com suporte
27
+ cada região de Voronoi de medida ≥ μ_min > 0; (ii) taxa de aprendizado
28
+ Robbins–Monro (Ση_t=∞, Ση_t²<∞, Teorema 1.2); (iii) resemeadura periódica
29
+ relocando órfãos ao amostra de pior EQ; (iv) bônus de novidade γ>0 nas rotas
30
+ (eq. 16.3). Então P[neurônio órfão após T atualizações] ≤ (1−μ_min)^{c_T},
31
+ com c_T = #{amostras roteadas à variante} → ∞ linearmente, e com
32
+ T ≥ (4/μ_min)·ln(k/δ) amostras ⇒ P[algum órfão] ≤ k·(1−μ_min)^{c_T} ≤ δ
33
+ (Hoeffding sobre contagens de cobertura). A equipe (atenção + resemeadura)
34
+ torna o evento "neurônio isolado" de PROBABILIDADE DECAYENTE — e o teste
35
+ `verificar_sem_orfas` verifica o invariante após a consolidação.
36
+
37
+ TEOREMA 16.6 (custo). Para V variantes: custo = Σ_v O(k_v·d) (BMUs) +
38
+ O(V·d) (mistura) + O(V²) trivial — LINEAR em Σ k_v d; a matriz de atenção
39
+ entre variantes é V×V = 9×9.
40
+
41
+ Integração: `OrquestradorSOM.mapear_atencao(x)` devolve ẑ e registra
42
+ telemetria (pesos a_v, distâncias d_v, órfãos por variante). O alinhamento
43
+ do modelo (doc 10 §2) usa ẑ quando ativo — TODAS as variantes participam do
44
+ gradiente de alinhamento via rotas amostrais (sem backprop nos SOMs, que
45
+ permanecem on-line: Teorema 10.5 preservado).
46
+ """
47
+ from __future__ import annotations
48
+
49
+ import torch
50
+
51
+ from aurora.memoria.variantes_especiais import (CounterpropagationNetwork,
52
+ HierarchicalSOM, SupervisedSOM)
53
+
54
+
55
+ def prototipo_e_distancia(variante, x: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
56
+ """(z_v, d_v) para x: (B,d) — espelha OrquestradorSOM.mapear, retornando
57
+ também o erro de quantização por amostra."""
58
+ with torch.no_grad():
59
+ if isinstance(variante, CounterpropagationNetwork):
60
+ idx = variante.kohonen.bmu(x)[0]
61
+ z = variante.kohonen.w[idx]
62
+ elif isinstance(variante, SupervisedSOM):
63
+ idx = variante.bmu(x)[0]
64
+ z = variante.w[idx]
65
+ elif isinstance(variante, HierarchicalSOM):
66
+ idx = variante.n1.bmu(x)[0]
67
+ z = variante.n1.w[idx]
68
+ elif hasattr(variante, "bmu"):
69
+ idx = variante.bmu(x)[0]
70
+ z = variante.w[idx]
71
+ else: # GCS: grafo sem método bmu
72
+ idx = torch.cdist(x, variante.w).pow(2).argmin(dim=1)
73
+ z = variante.w[idx]
74
+ d = (z - x).norm(dim=-1)
75
+ return z, d
76
+
77
+
78
+ def n_orfaos(variante) -> int:
79
+ """Neurônios com uso EMA abaixo do limiar (doc 10 §2.3) — ou células
80
+ nunca usadas no GCS (utilidade zero, Teorema 2.3)."""
81
+ for alvo in (variante, getattr(variante, "kohonen", None),
82
+ getattr(variante, "n1", None)):
83
+ if alvo is not None and hasattr(alvo, "hit_ema") and hasattr(alvo, "eps_ativo"):
84
+ return int((alvo.hit_ema < alvo.eps_ativo).sum())
85
+ if alvo is not None and hasattr(alvo, "usos"):
86
+ return int((alvo.usos == 0).sum())
87
+ return 0
88
+
89
+
90
+ def resemear_orfaos(variante, dados: torch.Tensor) -> int:
91
+ """Reloca neurônios órfãos para amostras reais — passo (iii) do Teorema
92
+ 16.5 (SOM: amostras de PIOR quantização; GCS: células nunca usadas).
93
+ Devolve nº de neurônios relocados."""
94
+ if dados.numel() == 0:
95
+ return 0
96
+ for alvo in (variante, getattr(variante, "kohonen", None),
97
+ getattr(variante, "n1", None)):
98
+ if alvo is None or not hasattr(alvo, "w"):
99
+ continue
100
+ with torch.no_grad():
101
+ if hasattr(alvo, "hit_ema") and hasattr(alvo, "eps_ativo"):
102
+ mortos = (alvo.hit_ema < alvo.eps_ativo).nonzero(as_tuple=True)[0]
103
+ if mortos.numel() == 0:
104
+ return 0
105
+ n = int(mortos.numel())
106
+ eq = ((dados.unsqueeze(1) - alvo.w.unsqueeze(0)) ** 2) \
107
+ .sum(-1).min(dim=1).values
108
+ # amostragem COM reposição nas regiões de pior EQ (Teorema 16.5):
109
+ # n ≥ nº de amostras — todo morto recebe uma amostra real
110
+ piores = eq.topk(min(n, dados.shape[0])).indices
111
+ fontes = dados[torch.randint(0, dados.shape[0], (n,))]
112
+ alvo.w[mortos] = fontes
113
+ alvo.hit_ema[mortos] = 0.08 # nasce 'ativo fraco' (doc 10 §2.3)
114
+ return n
115
+ if hasattr(alvo, "usos"):
116
+ mortos = (alvo.usos == 0).nonzero(as_tuple=True)[0]
117
+ if mortos.numel() == 0:
118
+ return 0
119
+ fontes = dados[torch.randint(0, dados.shape[0], (int(mortos.numel()),))]
120
+ alvo.w[mortos] = fontes
121
+ alvo.usos[mortos] = 1.0
122
+ return int(mortos.numel())
123
+ return 0
124
+
125
+
126
+ class AtencaoEntreVariantes:
127
+ """Recall atencional sobre TODAS as variantes Kohonen (eqs. 16.3–16.4)."""
128
+
129
+ def __init__(self, tau: float = 0.5, gamma_novidade: float = 0.15,
130
+ hub=None):
131
+ assert tau > 0, "τ deve ser positivo (Teorema 16.4)"
132
+ self.tau = float(tau)
133
+ self.gamma = float(gamma_novidade)
134
+ self.hub = hub
135
+ self.ultimo: dict = {}
136
+
137
+ # ---------------- núcleo ----------------
138
+ def mapear(self, x: torch.Tensor, orquestrador) -> torch.Tensor:
139
+ """x: (B,d) → ẑ: (B,d) ∈ casco{∪_v W_v} (Teorema 16.3)."""
140
+ nomes = list(orquestrador.variantes.keys())
141
+ V = len(nomes)
142
+ zs, ds = [], []
143
+ for nome in nomes:
144
+ z_v, d_v = prototipo_e_distancia(orquestrador.variantes[nome], x)
145
+ zs.append(z_v)
146
+ ds.append(d_v)
147
+ Z = torch.stack(zs, dim=1) # (B, V, d)
148
+ D = torch.stack(ds, dim=1) # (B, V)
149
+ novidade = torch.tensor(
150
+ [n_orfaos(orquestrador.variantes[n]) /
151
+ max(1, getattr(orquestrador.variantes[n], "k", 1)) for n in nomes],
152
+ dtype=D.dtype)
153
+ escore = -D / self.tau + self.gamma * novidade.unsqueeze(0) # (B,V)
154
+ a = torch.softmax(escore, dim=1) # eq. 16.3
155
+ z_hat = (a.unsqueeze(-1) * Z).sum(dim=1) # eq. 16.4 (B,d)
156
+ self.ultimo = {"pesos": a.mean(dim=0).detach(),
157
+ "distancias": D.mean(dim=0).detach(),
158
+ "entropia": float(-(a * torch.log(a + 1e-9)).sum(1).mean()),
159
+ "variante_dominate": nomes[int(a.mean(0).argmax())]}
160
+ if self.hub is not None:
161
+ for j, nome in enumerate(nomes):
162
+ self.hub.atributo(f"som_atn/peso_{nome}",
163
+ float(self.ultimo["pesos"][j]))
164
+ self.hub.atributo("som_atn/entropia", self.ultimo["entropia"])
165
+ return z_hat
166
+
167
+ # ---------------- invariante anti-órfãos ----------------
168
+ def verificar_sem_orfas(self, orquestrador, dados: torch.Tensor | None = None,
169
+ resemear: bool = True) -> dict:
170
+ """Verifica (e corrige com resemeadura) o invariante ZERO neurônios
171
+ isolados em TODAS as variantes (Teorema 16.5, passo iii)."""
172
+ relatorio: dict = {}
173
+ for nome, v in orquestrador.variantes.items():
174
+ relocations = 0
175
+ if resemear and dados is not None:
176
+ relocations = resemear_orfaos(v, dados)
177
+ rel = {"orfaos": n_orfaos(v), "relocados": relocations}
178
+ if hasattr(v, "taxa_ativos"):
179
+ rel["taxa_ativos"] = v.taxa_ativos()
180
+ elif hasattr(v, "kohonen") and hasattr(v.kohonen, "taxa_ativos"):
181
+ rel["taxa_ativos"] = v.kohonen.taxa_ativos()
182
+ relatorio[nome] = rel
183
+ if self.hub is not None:
184
+ self.hub.atributo(f"som_atn/orfaos_{nome}", rel["orfaos"])
185
+ relatorio["_invariante_ok"] = all(r["orfaos"] == 0
186
+ for k, r in relatorio.items()
187
+ if not k.startswith("_"))
188
+ return relatorio
src/aurora/memoria/janela_1m.py CHANGED
@@ -95,7 +95,11 @@ class JanelaContexto1M(nn.Module):
95
  if self.n_segmentos == 0:
96
  return torch.zeros(0, self.d)
97
  self.consultas_totais += 1
98
- q_proj = self.proj_retrieval(q)
 
 
 
 
99
  bmu = self.grade.bmu(q_proj.unsqueeze(0))[0].item()
100
  # vizinhança r na grade (grade quadrada lado² → coordenadas)
101
  lado = int(round(self.grade.k ** 0.5))
@@ -112,11 +116,13 @@ class JanelaContexto1M(nn.Module):
112
  bmu_dos_segs = dist.argmin(dim=1) # (M,)
113
  mascara = torch.isin(bmu_dos_segs, torch.tensor(celulas)) \
114
  & self.ocupado
115
- if not mascara.any(): # fallback: global
116
- mascara = self.ocupado.clone()
117
- else:
118
  self.hits_celula += 1
119
  ids = mascara.nonzero(as_tuple=True)[0]
 
 
 
 
120
  sims = (self.z[ids] @ q_proj) / (self.z[ids].norm(dim=1) + 1e-6)
121
  top = sims.topk(min(k, ids.numel())).indices
122
  escolhidos = ids[top]
 
95
  if self.n_segmentos == 0:
96
  return torch.zeros(0, self.d)
97
  self.consultas_totais += 1
98
+ # v5 — correção (bug v4): a grade é treinada sobre resumos BRUTOS
99
+ # (insere → treinar_lote(z)); a consulta coarse/fina usa o MESMO
100
+ # espaço (q bruto). O proj_retrieval aleatório misturava espaços e
101
+ # reduzia o recall a aleatório (sim ≈ 0). Teorema 13.1 recuperado.
102
+ q_proj = q
103
  bmu = self.grade.bmu(q_proj.unsqueeze(0))[0].item()
104
  # vizinhança r na grade (grade quadrada lado² → coordenadas)
105
  lado = int(round(self.grade.k ** 0.5))
 
116
  bmu_dos_segs = dist.argmin(dim=1) # (M,)
117
  mascara = torch.isin(bmu_dos_segs, torch.tensor(celulas)) \
118
  & self.ocupado
119
+ if mascara.any():
 
 
120
  self.hits_celula += 1
121
  ids = mascara.nonzero(as_tuple=True)[0]
122
+ # v5 — fallback global se a vizinhança rende MENOS que k candidatos
123
+ # (garante k respostas quando n_segmentos ≥ k — contrato de recall)
124
+ if ids.numel() < min(k, int(self.ocupado.sum())):
125
+ ids = self.ocupado.nonzero(as_tuple=True)[0]
126
  sims = (self.z[ids] @ q_proj) / (self.z[ids].norm(dim=1) + 1e-6)
127
  top = sims.topk(min(k, ids.numel())).indices
128
  escolhidos = ids[top]
src/aurora/memoria/orquestrador.py CHANGED
@@ -31,7 +31,8 @@ class OrquestradorSOM:
31
  estático simples → SOM base
32
  """
33
 
34
- def __init__(self, dim: int, cfg, hub=None, semente: int = 2026):
 
35
  self.dim = dim
36
  self.hub = hub
37
  self.variantes = {
@@ -50,6 +51,17 @@ class OrquestradorSOM:
50
  }
51
  self.ativa = "som"
52
  self.motivo = "padrão"
 
 
 
 
 
 
 
 
 
 
 
53
 
54
  # ---------------- roteamento ----------------
55
  def escolher(self, perfil: dict) -> str:
@@ -109,6 +121,15 @@ class OrquestradorSOM:
109
  return v.n1.w[v.n1.bmu(x)[0]]
110
  return v.w[v.bmu(x)[0]]
111
 
 
 
 
 
 
 
 
 
 
112
  def estatisticas(self) -> dict:
113
  out = {"ativa": self.ativa, "motivo": self.motivo}
114
  for nome, v in self.variantes.items():
 
31
  estático simples → SOM base
32
  """
33
 
34
+ def __init__(self, dim: int, cfg, hub=None, semente: int = 2026,
35
+ cfg_atencao=None):
36
  self.dim = dim
37
  self.hub = hub
38
  self.variantes = {
 
51
  }
52
  self.ativa = "som"
53
  self.motivo = "padrão"
54
+ # v5 (doc 16 §§3–4): recall atencional sobre TODAS as variantes +
55
+ # invariante ZERO neurônios isolados (Teorema 16.5)
56
+ from aurora.memoria.atencao_som import AtencaoEntreVariantes
57
+ cfg_atn = dict(cfg_atencao or {})
58
+ if not cfg_atn.get("ativo", True):
59
+ self.atencao = None
60
+ else:
61
+ self.atencao = AtencaoEntreVariantes(
62
+ tau=float(cfg_atn.get("tau", 0.5)),
63
+ gamma_novidade=float(cfg_atn.get("gamma_novidade", 0.15)),
64
+ hub=hub)
65
 
66
  # ---------------- roteamento ----------------
67
  def escolher(self, perfil: dict) -> str:
 
121
  return v.n1.w[v.n1.bmu(x)[0]]
122
  return v.w[v.bmu(x)[0]]
123
 
124
+ def mapear_atencao(self, x: torch.Tensor) -> torch.Tensor:
125
+ """v5 — recall atencional sobre TODAS as variantes (eq. 16.3–16.4):
126
+ ẑ = Σ_v a_v z_v ∈ casco{∪_v W_v} (Teorema 16.3); bônus de novidade
127
+ direciona rotas a variantes com neurônios órfãos (Teorema 16.5).
128
+ Fallback: roteamento duro (mapear) quando a atenção está desativada."""
129
+ if self.atencao is None:
130
+ return self.mapear(x)
131
+ return self.atencao.mapear(x, self)
132
+
133
  def estatisticas(self) -> dict:
134
  out = {"ativa": self.ativa, "motivo": self.motivo}
135
  for nome, v in self.variantes.items():
src/aurora/memoria/som_base.py CHANGED
@@ -108,7 +108,7 @@ class SOMKohonen:
108
  # reseeding: mortos recebem amostras reais (Teorema 10.7)
109
  with torch.no_grad():
110
  if mortos.numel() and x.shape[0] > 0:
111
- fontes = x[torch.randperm(x.shape[0])[:mortos.numel()]]
112
  self.w[mortos] = fontes
113
  self.hit_ema[mortos] = 0.08 # recém-nascido: conta ativo
114
  self.erro_ema[mortos] = 0.0
 
108
  # reseeding: mortos recebem amostras reais (Teorema 10.7)
109
  with torch.no_grad():
110
  if mortos.numel() and x.shape[0] > 0:
111
+ fontes = x[torch.randint(0, x.shape[0], (int(mortos.numel()),))]
112
  self.w[mortos] = fontes
113
  self.hit_ema[mortos] = 0.08 # recém-nascido: conta ativo
114
  self.erro_ema[mortos] = 0.0
src/aurora/memoria/variantes_especiais.py CHANGED
@@ -164,7 +164,7 @@ class SupervisedSOM(SOMKohonen):
164
  # reseeding de mortos com amostras reais (Teorema 15.2 — guloso)
165
  mortos = (self.hit_ema < self.eps_ativo).nonzero(as_tuple=True)[0]
166
  if mortos.numel() and len(dados) > 0:
167
- fontes = dados[torch.randperm(len(dados))[:mortos.numel()]]
168
  self.w[mortos] = fontes
169
  self.hit_ema[mortos] = 0.08 # recém-nascido conta ativo
170
  self.erro_ema[mortos] = 0.0
 
164
  # reseeding de mortos com amostras reais (Teorema 15.2 — guloso)
165
  mortos = (self.hit_ema < self.eps_ativo).nonzero(as_tuple=True)[0]
166
  if mortos.numel() and len(dados) > 0:
167
+ fontes = dados[torch.randint(0, len(dados), (int(mortos.numel()),))]
168
  self.w[mortos] = fontes
169
  self.hit_ema[mortos] = 0.08 # recém-nascido conta ativo
170
  self.erro_ema[mortos] = 0.0
src/aurora/nlg/unidade_nlg.py CHANGED
@@ -46,6 +46,35 @@ class UnidadeNLG(nn.Module):
46
  p = torch.sigmoid(self.eixos) if estilo is None else estilo
47
  return h + self.W_estilo(p).view(1, 1, -1)
48
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
49
  # ---------------- re-ranking de coerência ----------------
50
  @torch.no_grad()
51
  def atualizar_bigramas(self, ids: torch.Tensor):
 
46
  p = torch.sigmoid(self.eixos) if estilo is None else estilo
47
  return h + self.W_estilo(p).view(1, 1, -1)
48
 
49
+ # ---------------- v5: enriquecimento de prompt (doc 17 §3) ----------------
50
+ EIXOS_FRASES = (
51
+ ("com detalhes nítidos", "com precisão de traços"),
52
+ ("com composição harmônica", "com equilíbrio visual"),
53
+ ("com iluminação suave", "com luz natural"),
54
+ ("com cores vibrantes", "com paleta rica"),
55
+ ("em primeiro plano", "em destaque"),
56
+ ("com profundidade de campo", "com perspectiva clara"),
57
+ ("com textura realista", "com materiais bem definidos"),
58
+ ("em alta qualidade", "com acabamento refinado"),
59
+ )
60
+
61
+ @torch.no_grad()
62
+ def enriquecer_prompt(self, prompt: str, limiar: float = 0.5) -> str:
63
+ """v5 — enriquece o prompt p/ difusão com qualificadores PT-BR
64
+ selecionados pelos eixos de estilo (doc 17 §3, Teorema 17.3: mapeamento
65
+ determinístico e reversível dos eixos → linguagem; sem novos
66
+ parâmetros — reusa os eixos aprendidos)."""
67
+ p_eixos = torch.sigmoid(self.eixos).tolist()
68
+ frases = [frases_i[int(a >= limiar)]
69
+ for a, (frases_i,) in
70
+ zip(p_eixos, [(f,) for f in self.EIXOS_FRASES])]
71
+ escolhas = [frase for a, frase in zip(p_eixos, self.EIXOS_FRASES)
72
+ if a >= limiar for frase in (frase[int(a >= 0.75)],)]
73
+ base = prompt.strip().rstrip(".")
74
+ if not escolhas:
75
+ return f"{base}, em alta qualidade"
76
+ return f"{base}, " + ", ".join(escolhas[:3])
77
+
78
  # ---------------- re-ranking de coerência ----------------
79
  @torch.no_grad()
80
  def atualizar_bigramas(self, ids: torch.Tensor):
src/aurora/nucleo/modelo.py CHANGED
@@ -21,6 +21,7 @@ import torch
21
  import torch.nn as nn
22
  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, BlocoV3, RMSNorm
@@ -34,7 +35,7 @@ from aurora.percepcao.video import CodificadorVideo
34
  from aurora.nlp.unidade_nlp import UnidadeNLP
35
  from aurora.nlg.unidade_nlg import UnidadeNLG
36
  from aurora.memoria.janela_1m import JanelaContexto1M
37
- from aurora.quanta.quantizacao import FakeQuantW8A8
38
  from aurora.treino.mtp import MTPAurora
39
 
40
 
@@ -74,6 +75,18 @@ class AURORAModel(nn.Module):
74
  BlocoV3(m.d_modelo, m.n_cabecas, m.d_ff, m.janela_sliding, m.dropout,
75
  moe=_moe_para(i), cfg_micra=cfg_micra)
76
  for i in range(m.n_camadas)])
 
 
 
 
 
 
 
 
 
 
 
 
77
  # confiança corrente (h_t do AgenteConfiança — definida pelo treino)
78
  self.confianca_corrente: float = 0.5
79
  self.norm_f = RMSNorm(m.d_modelo)
@@ -129,7 +142,7 @@ class AURORAModel(nn.Module):
129
  self.perda_balanceamento: float = 0.0
130
  self._coletar: dict = {}
131
  self.qat = False
132
- self._fakeq = FakeQuantW8A8(por_canal=True)
133
 
134
  # ---------------- fases MoE (doc 10 §1.1) ----------------
135
  def definir_fase_moe(self, fase: str):
@@ -176,8 +189,7 @@ class AURORAModel(nn.Module):
176
  x = self.norm_f(x)
177
  self._ultimo_oculto = x # para MTP sem re-executar o trunk (v2)
178
  if self.qat:
179
- wq, _, _ = self._fakeq(self.lm_head.weight.detach())
180
- wq = self.lm_head.weight + (wq - self.lm_head.weight).detach()
181
  logits = F.linear(x, wq)
182
  else:
183
  logits = self.lm_head(x)
@@ -269,7 +281,12 @@ class AURORAModel(nn.Module):
269
  ctx = h.mean(dim=1) # (B, d) com gradiente
270
  proj = self.alinhamento(ctx)
271
  if orquestrador is not None:
272
- alvo = orquestrador.mapear(ctx.detach()) # (B, d) stop-grad
 
 
 
 
 
273
  return F.mse_loss(proj, alvo)
274
  return F.mse_loss(proj, ctx.detach()) # fallback: identidade regularizada
275
 
@@ -410,6 +427,11 @@ class AURORAModel(nn.Module):
410
  out[f"moe{i}/perda_lb"] = float(moe.perda_lb)
411
  out[f"moe{i}/perda_ort"] = float(moe.perda_ort)
412
  out[f"moe{i}/fase"] = 1.0 if moe.fase_densa else 0.0
 
 
 
 
 
413
  if self.mtp is not None and self.mtp.ultimos:
414
  for j, a in enumerate(self.mtp.ultimos.get("alphas", [])):
415
  out[f"mtp/alpha{j}"] = a
 
21
  import torch.nn as nn
22
  import torch.nn.functional as F
23
 
24
+ from aurora.percepcao.atencao_moe import RefinamentoEntreMoEs
25
  from aurora.percepcao.atencao import MixtureOfAttention
26
  from aurora.percepcao.audio import CodificadorAudio
27
  from aurora.percepcao.blocos import Bloco, BlocoV3, RMSNorm
 
35
  from aurora.nlp.unidade_nlp import UnidadeNLP
36
  from aurora.nlg.unidade_nlg import UnidadeNLG
37
  from aurora.memoria.janela_1m import JanelaContexto1M
38
+ from aurora.quanta.quantizacao import QATW8A8
39
  from aurora.treino.mtp import MTPAurora
40
 
41
 
 
75
  BlocoV3(m.d_modelo, m.n_cabecas, m.d_ff, m.janela_sliding, m.dropout,
76
  moe=_moe_para(i), cfg_micra=cfg_micra)
77
  for i in range(m.n_camadas)])
78
+ # v5 (doc 16 §§1–2): atenção ENTRE camadas MoE consecutivas + retro-
79
+ # alimentação de rotas — nasce neutra (Teorema 16.1c), nunca regride
80
+ cfg_atn_moe = dict(getattr(m, "atencao_moe", {}) or {})
81
+ if self.usar_moe and bool(cfg_atn_moe.get("ativo", True)):
82
+ camadas = sorted(self.moe_camadas)
83
+ for a, b in zip(camadas, camadas[1:]):
84
+ moe_a, moe_b = self.blocos[a].moe, self.blocos[b].moe
85
+ if moe_a is not None and moe_b is not None:
86
+ moe_b.moe_anterior = moe_a
87
+ moe_b.refino = RefinamentoEntreMoEs(
88
+ m.d_modelo,
89
+ alpha0=float(cfg_atn_moe.get("alpha0", 0.0)))
90
  # confiança corrente (h_t do AgenteConfiança — definida pelo treino)
91
  self.confianca_corrente: float = 0.5
92
  self.norm_f = RMSNorm(m.d_modelo)
 
142
  self.perda_balanceamento: float = 0.0
143
  self._coletar: dict = {}
144
  self.qat = False
145
+ self._qat = QATW8A8(por_canal=True) # v5: QAT com STE (sem fakes)
146
 
147
  # ---------------- fases MoE (doc 10 §1.1) ----------------
148
  def definir_fase_moe(self, fase: str):
 
189
  x = self.norm_f(x)
190
  self._ultimo_oculto = x # para MTP sem re-executar o trunk (v2)
191
  if self.qat:
192
+ wq = self._qat.quantiza_peso(self.lm_head.weight) # STE (Teorema 8.3)
 
193
  logits = F.linear(x, wq)
194
  else:
195
  logits = self.lm_head(x)
 
281
  ctx = h.mean(dim=1) # (B, d) com gradiente
282
  proj = self.alinhamento(ctx)
283
  if orquestrador is not None:
284
+ # v5 — recall atencional sobre TODAS as variantes (doc 16 §§3–4):
285
+ # ẑ ∈ casco{∪_v W_v}; bônus de novidade protege neurônios pouco usados
286
+ if hasattr(orquestrador, "mapear_atencao"):
287
+ alvo = orquestrador.mapear_atencao(ctx.detach())
288
+ else:
289
+ alvo = orquestrador.mapear(ctx.detach())
290
  return F.mse_loss(proj, alvo)
291
  return F.mse_loss(proj, ctx.detach()) # fallback: identidade regularizada
292
 
 
427
  out[f"moe{i}/perda_lb"] = float(moe.perda_lb)
428
  out[f"moe{i}/perda_ort"] = float(moe.perda_ort)
429
  out[f"moe{i}/fase"] = 1.0 if moe.fase_densa else 0.0
430
+ # v5 — atenção entre MoEs (doc 16 §2)
431
+ out[f"moe{i}/beta_feedback"] = float(moe.beta_feedback)
432
+ out[f"moe{i}/entropia_atn"] = moe.ultima_entropia_atn
433
+ if moe.refino is not None:
434
+ out[f"moe{i}/alpha_refino"] = float(moe.refino.alpha)
435
  if self.mtp is not None and self.mtp.ultimos:
436
  for j, a in enumerate(self.mtp.ultimos.get("alphas", [])):
437
  out[f"mtp/alpha{j}"] = a
src/aurora/percepcao/atencao_moe.py ADDED
@@ -0,0 +1,99 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Atenção ENTRE camadas MoE (v5, doc 16 §§1–2 — item 2 da 1ª requisição).
3
+
4
+ Problema: as camadas MoE roteiam INDEPENDENTEMENTE (doc 10 §1) — a decisão de
5
+ especialistas da camada ℓ ignora o padrão de especialização da camada ℓ−1.
6
+ Solução: refinamento por atenção sobre o CONJUNTO de saídas dos experts + retro-
7
+ alimentação do padrão de rotas (router memory), ambos nascendo NEUTROS
8
+ (α=β=0 ⇒ comportamento idêntico ao v4 — nunca regride, Teorema 16.1c).
9
+
10
+ Formalização. Camada ℓ tem experts E_ℓ,e (e=1..N) e saída misturada
11
+ y_ℓ(x) = Σ_e g_{ℓ,e}(x) · E_{ℓ,e}(x), g = softmax(s) ≥ 0, Σg = 1.
12
+ Empilhamos as saídas dos experts Z_ℓ = [E_{ℓ,1}(x);…;E_{ℓ,N}(x)] ∈ R^{N×d}
13
+ e aplicamos atenção cruzada de y_ℓ sobre Z_{ℓ−1} (eq. 16.1):
14
+
15
+ A_ℓ = softmax( (y_ℓ W_Q)(Z_{ℓ−1} W_K)^T / √d ) ∈ Δ^{N}
16
+ Z̃_ℓ = A_ℓ (Z_{ℓ−1} W_V) (mistura ponderada)
17
+ ỹ_ℓ = y_ℓ + α ⊙ Z̃_ℓ , α aprendível, init 0.
18
+
19
+ Retroalimentação de rotas (eq. 16.2): s_ℓ ← s_ℓ + β · m_{ℓ−1}, com
20
+ m_{ℓ−1} = ḡ_{ℓ−1} (uso médio dos experts da camada anterior) e β aprendível,
21
+ init 0.
22
+
23
+ Custo: A_ℓ é N×N com N = G·E_g = 6 ⇒ O(B·T·N·d) — desprezível perto do
24
+ O(B·T·N·d_ff) dos próprios experts (Teorema 16.6).
25
+
26
+ TEOREMA 16.1 (limitação do refinamento). Para g em delta simplex e qualquer
27
+ Z: ‖ỹ_ℓ − y_ℓ‖₂ = |α|·‖Σ_e A_e (Z W_V)_e‖₂ ≤ |α|·max_e‖(Z W_V)_e‖₂.
28
+ Com W_V de norma espectral σ(W_V) ≤ 1 (normalizado por √d no init):
29
+ ‖ỹ − y‖ ≤ |α| · max_e ‖E_e‖₂ · σ(W_V).
30
+ Corolário 16.1a (não-explosão): se ‖E_e‖ ≤ M para todo expert, então
31
+ ‖ỹ − y‖ ≤ |α|·M — o refinamento é uma perturbação LIMITADA da saída v4.
32
+
33
+ TEOREMA 16.1c (nascimento neutro / não-regressão). Com α=0 e β=0,
34
+ ỹ_ℓ ≡ y_ℓ e s_ℓ ≡ s_ℓ (v4 exato). Gradientes em α, β são não-nulos (a saída
35
+ depende deles para α≠0 — via regra da cadeia d ỹ/dα = Z̃ ≠ 0), logo o treino
36
+ sai do ponto neutro apenas se REDUZIR a perda. Capacidade v4 é subespaço do
37
+ v5 ⇒ argmin v5 ≤ argmin v4 (capacidades nunca regridem).
38
+
39
+ TEOREMA 16.2 (estabilidade da retroalimentação). O mapa de rotas entre
40
+ camadas é m_ℓ = softmax(s_ℓ + β·m_{ℓ−1}) — lipschitziano com constante
41
+ L = L_softmax·|β| ≤ |β|/4 (soft-max é 1/4-lipschitziano em norma ∞ sobre
42
+ entradas separadas por ≥ gap; caso geral: L_softmax ≤ 1 por contração do
43
+ simplex sobre si mesmo com métrica TV). A composição em L camadas tem
44
+ constante ≤ (|β|/4)^L → 0: DIVERGÊNCIA IMPOSSÍVEL; o ciclo de retroalimen-
45
+ tação é CONTRAÇÃO (análogo ao BIBO do RSOM, Teorema 5.3).
46
+ """
47
+ from __future__ import annotations
48
+
49
+ import math
50
+
51
+ import torch
52
+ import torch.nn as nn
53
+
54
+
55
+ class RefinamentoEntreMoEs(nn.Module):
56
+ """Atenção de y_ℓ sobre o conjunto Z_{ℓ−1} de saídas dos experts (eq. 16.1).
57
+
58
+ Args:
59
+ d: dimensão do modelo.
60
+ alpha0: valor inicial de α (0 = nascimento neutro — Teorema 16.1c).
61
+ """
62
+
63
+ def __init__(self, d: int, alpha0: float = 0.0):
64
+ super().__init__()
65
+ self.d = d
66
+ self.w_q = nn.Linear(d, d, bias=False)
67
+ self.w_k = nn.Linear(d, d, bias=False)
68
+ self.w_v = nn.Linear(d, d, bias=False)
69
+ # init idempotente: W_V começa ~identidade/escala pequena controlada
70
+ for w in (self.w_q.weight, self.w_k.weight, self.w_v.weight):
71
+ nn.init.normal_(w, mean=0.0, std=(1.0 / math.sqrt(d)) * 0.25)
72
+ self.alpha = nn.Parameter(torch.tensor(float(alpha0)))
73
+
74
+ def forward(self, y: torch.Tensor, z_prev: torch.Tensor) -> torch.Tensor:
75
+ """y: (B,T,d) mistura corrente · z_prev: (B,T,N,d) experts da camada ℓ−1.
76
+ Devolve ỹ = y + α·A(z_prev)·(z_prev W_V) — eq. 16.1."""
77
+ B, T, d = y.shape
78
+ N = z_prev.shape[2]
79
+ q = self.w_q(y).unsqueeze(2) # (B,T,1,d)
80
+ k = self.w_k(z_prev) # (B,T,N,d)
81
+ v = self.w_v(z_prev) # (B,T,N,d)
82
+ escore = (q * k).sum(dim=-1) / math.sqrt(self.d) # (B,T,N) — produto interno
83
+ a = torch.softmax(escore, dim=-1) # Δ^N (eq. 16.1)
84
+ z_til = (a.unsqueeze(-1) * v).sum(dim=2) # (B,T,d)
85
+ return y + self.alpha * z_til
86
+
87
+ def pesos_atencao(self, y: torch.Tensor, z_prev: torch.Tensor) -> torch.Tensor:
88
+ """A_ℓ (B,T,N) — telemetria: concentração/entropia da atenção entre experts."""
89
+ with torch.no_grad():
90
+ q = self.w_q(y).unsqueeze(2)
91
+ k = self.w_k(z_prev)
92
+ escore = (q * k).sum(dim=-1) / math.sqrt(self.d)
93
+ return torch.softmax(escore, dim=-1)
94
+
95
+ def entropia_media(self, y: torch.Tensor, z_prev: torch.Tensor) -> float:
96
+ """H(A) média — atenção entre experts: H baixa ⇒ especializa��ão entre
97
+ camadas; H alta ⇒ uso uniforme. Range teórico [0, ln N]."""
98
+ a = self.pesos_atencao(y, z_prev)
99
+ return float(-(a * torch.log(a + 1e-9)).sum(dim=-1).mean())
src/aurora/percepcao/moe.py CHANGED
@@ -70,6 +70,14 @@ class MoEAgrupavel(nn.Module):
70
  self.vies_tarefa = nn.Parameter(torch.zeros(n_grupos, n_tarefas))
71
  self.register_buffer("grupo_de_idx", self.grupo_de.clone())
72
  self.fase_densa = True # item (d): inicia com máximo de conexões
 
 
 
 
 
 
 
 
73
  # telemetria do último forward
74
  self.ultimo_f: torch.Tensor | None = None # fração roteada (B,N)→média
75
  self.ultimo_p: torch.Tensor | None = None # gate médio
@@ -113,6 +121,10 @@ class MoEAgrupavel(nn.Module):
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)
@@ -150,6 +162,18 @@ class MoEAgrupavel(nn.Module):
150
  acts.append(y_e)
151
  # normalização quando fase foco (soma dos gates ativos = 1 por amostra)
152
  y = y / soma_at.clamp(min=1e-6)
 
 
 
 
 
 
 
 
 
 
 
 
153
  # telemetria e perdas auxiliares
154
  with torch.no_grad():
155
  p_medio = g.mean(dim=0) # (N,)
@@ -183,4 +207,9 @@ class MoEAgrupavel(nn.Module):
183
  out["uso_max"] = float(self.uso_ema.max())
184
  out["uso_min"] = float(self.uso_ema.min())
185
  out["experts_domintes"] = int((self.uso_ema > 2.0 / self.N).sum())
 
 
 
 
 
186
  return out
 
70
  self.vies_tarefa = nn.Parameter(torch.zeros(n_grupos, n_tarefas))
71
  self.register_buffer("grupo_de_idx", self.grupo_de.clone())
72
  self.fase_densa = True # item (d): inicia com máximo de conexões
73
+ # v5 (doc 16 §§1–2): atenção ENTRE camadas MoE + retroalimentação de rotas
74
+ # — nasce NEUTRA (α=β=0 ⇒ v4 exato; Teorema 16.1c: não-regressão)
75
+ self.refino = None # RefinamentoEntreMoEs (ligado pelo modelo)
76
+ self.moe_anterior = None # camada MoE ℓ−1
77
+ self.beta_feedback = nn.Parameter(torch.zeros(()))
78
+ self._Z_ultimo: torch.Tensor | None = None # (B*T, N, d) experts do último forward
79
+ self._g_ultimo: torch.Tensor | None = None # (N,) gate médio (router memory)
80
+ self.ultima_entropia_atn: float = 0.0
81
  # telemetria do último forward
82
  self.ultimo_f: torch.Tensor | None = None # fração roteada (B,N)→média
83
  self.ultimo_p: torch.Tensor | None = None # gate médio
 
121
  # viés b_{g(e),τ}: cada expert recebe o viés do SEU grupo para τ
122
  vies_experts = self.vies_tarefa[:, it][self.grupo_de_idx] # (N,)
123
  s = s + vies_experts.unsqueeze(0)
124
+ # v5 — eq. 16.2: retroalimentação do padrão de rotas da camada ℓ−1
125
+ # (contracção garantida — Teorema 16.2; β=0 no nascimento)
126
+ if self.moe_anterior is not None and self.moe_anterior._g_ultimo is not None:
127
+ s = s + self.beta_feedback * self.moe_anterior._g_ultimo.unsqueeze(0).to(s.dtype)
128
  if self.fase_densa:
129
  # fase densa: softmax sobre TODOS os experts (máximo de conexões)
130
  g = torch.softmax(s, dim=-1) # (B*T, N)
 
162
  acts.append(y_e)
163
  # normalização quando fase foco (soma dos gates ativos = 1 por amostra)
164
  y = y / soma_at.clamp(min=1e-6)
165
+ # v5 — eq. 16.1: refinamento por atenção sobre os experts da camada ℓ−1
166
+ self._Z_ultimo = torch.stack(acts, dim=1) # (B*T, N, d)
167
+ self._g_ultimo = g.mean(dim=0).detach() # router memory
168
+ if self.refino is not None and self.moe_anterior is not None \
169
+ and self.moe_anterior._Z_ultimo is not None:
170
+ z_prev = self.moe_anterior._Z_ultimo
171
+ if z_prev.shape[0] == y.shape[0]:
172
+ y_3d = y.reshape(B, T, d)
173
+ y_3d = self.refino(y_3d, z_prev.reshape(B, T, self.N, d))
174
+ self.ultima_entropia_atn = self.refino.entropia_media(
175
+ y_3d.detach(), z_prev.reshape(B, T, self.N, d).detach())
176
+ y = y_3d.reshape(B * T, d)
177
  # telemetria e perdas auxiliares
178
  with torch.no_grad():
179
  p_medio = g.mean(dim=0) # (N,)
 
207
  out["uso_max"] = float(self.uso_ema.max())
208
  out["uso_min"] = float(self.uso_ema.min())
209
  out["experts_domintes"] = int((self.uso_ema > 2.0 / self.N).sum())
210
+ # v5 — atenção entre MoEs (doc 16 §2)
211
+ out["beta_feedback"] = float(self.beta_feedback)
212
+ out["entropia_atn_entre_moe"] = self.ultima_entropia_atn
213
+ if self.refino is not None:
214
+ out["alpha_refino"] = float(self.refino.alpha)
215
  return out
src/aurora/qualidade/__init__.py ADDED
@@ -0,0 +1,7 @@
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Qualidade (v5): Agente Engenheiro — revisão pré-modificação + observação
3
+ de métricas. O módulo bugwatch foi REMOVIDO (v5); o papel de revisão
4
+ ortográfica passou a ser um comportamento do Agente Engenheiro."""
5
+ from aurora.qualidade.agente_engenheiro import AgenteEngenheiro
6
+
7
+ __all__ = ["AgenteEngenheiro"]
src/aurora/qualidade/agente_engenheiro.py ADDED
@@ -0,0 +1,227 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Agente Engenheiro — v5 (doc 16 §9).
3
+
4
+ Papel 1 (REVISÃO PRÉ-MODIFICAÇÃO): substitui o bugwatch REMOVIDO — antes de
5
+ qualquer modificação de código, audita ortografia de identificadores,
6
+ consistência de API, sintaxe (AST) e REGRESSÃO DE CAPACIDADE (nada pode
7
+ reduzir métricas fundamentais além da tolerância).
8
+
9
+ Papel 2 (OBSERVAÇÃO DE MÉTRICAS): durante TREINO e INFERÊNCIA, coleta as
10
+ métricas fundamentais de CADA MÓDULO (pedido explícito):
11
+ percepção (gates de atenção) · MoE (uso/entropia/α/β) · microunidades
12
+ (ramos/recursão) · SOM e 8 variantes (k, EQ, taxa de ativos, órfãos)
13
+ · atenção entre variantes (pesos/entropia) · NLP/NLG · janela 1M ·
14
+ memória interna · quantização (modo real/erro) · difusão (modo) ·
15
+ MTP (α) · computo (perfil) · telemetria (rank efetivo, PSI).
16
+
17
+ GARANTIA DE NÃO-REGRESSÃO (Teorema 16.10): seja C(t) o vetor de capacidades
18
+ (ppl_valid, coerência, taxa_ativos SOM, EQ, hit-rate MTP). Uma modificação é
19
+ APROVADA sse ‖max(0, C(t)−C(t+1))‖∞ ≤ ε componente a componente (ε padrão
20
+ 5%), com métricas "menor é melhor" invertidas na comparação.
21
+ """
22
+ from __future__ import annotations
23
+
24
+ import ast
25
+ import json
26
+ import os
27
+ import re
28
+ import time
29
+
30
+ import torch
31
+
32
+ # Ortografia: pares (errado, correto) — erros comuns em PT-BR/identificadores
33
+ ERROS_COMUNS = [
34
+ ("atention", "atencao"), ("attetion", "atencao"),
35
+ ("quantizaco", "quantizacao"), ("quautizacao", "quantizacao"),
36
+ ("menoria", "memoria"), ("perde_", "perda_"),
37
+ ("estados_hf", "checkpoints"), ("bugwatch", "agente_engenheiro"),
38
+ ("varianate", "variante"), ("neoronio", "neuronio"),
39
+ ]
40
+ PADRAO_SNAKE = re.compile(r"^[a-z_][a-z0-9_]*$") # funções/variáveis
41
+ PADRAO_CAMEL = re.compile(r"^[A-Z][A-Za-z0-9_]*$") # classes
42
+ PADRAO_TOKEN = re.compile(r"hf_[A-Za-z0-9]{30,}")
43
+
44
+
45
+ class AgenteEngenheiro:
46
+ """Auditoria pré-modificação + observação integral de métricas."""
47
+
48
+ def __init__(self, dir_telemetria: str = "/home/z/my-project/aurora/telemetria_out",
49
+ tolerancia_regressao: float = 0.05, hub=None):
50
+ self.dir_telemetria = dir_telemetria
51
+ self.tolerancia = tolerancia_regressao
52
+ self.hub = hub
53
+ self.arquivo_jsonl = os.path.join(dir_telemetria, "agente_engenheiro.jsonl")
54
+ os.makedirs(dir_telemetria, exist_ok=True)
55
+ self.capacidades_baseline: dict | None = None
56
+ self.bloqueios: list = []
57
+ self.aprovacoes: list = []
58
+
59
+ # ================= Papel 1: revisão pré-modificação =================
60
+ def auditar_antes(self, descricao: str, arquivos: list) -> dict:
61
+ """Revisão OBRIGATÓRIA antes de modificar. Verifica: (a) sintaxe AST;
62
+ (b) ortografia de identificadores PT-BR; (c) nomes snake_case;
63
+ (d) nenhum segredo no código. Aprova ou BLOQUEIA."""
64
+ rel = {"descricao": descricao, "t": round(time.time(), 2),
65
+ "arquivos": len(arquivos), "problemas": []}
66
+ for caminho in arquivos:
67
+ if not os.path.exists(caminho) or not caminho.endswith(".py"):
68
+ continue
69
+ with open(caminho, encoding="utf-8", errors="ignore") as f:
70
+ codigo = f.read()
71
+ try:
72
+ arvore = ast.parse(codigo)
73
+ except SyntaxError as e:
74
+ rel["problemas"].append(
75
+ f"{caminho}: SINTAXE linha {e.lineno}: {e.msg}")
76
+ continue
77
+ for no in ast.walk(arvore):
78
+ # nomes a checar ortografia (tudo) + padrão (só funções)
79
+ if isinstance(no, (ast.FunctionDef, ast.ClassDef)):
80
+ for errado, _ in ERROS_COMUNS:
81
+ if errado in no.name:
82
+ rel["problemas"].append(
83
+ f"{caminho}: ortografia '{no.name}' contém '{errado}'")
84
+ padrao = PADRAO_CAMEL if isinstance(no, ast.ClassDef) \
85
+ else PADRAO_SNAKE
86
+ if not padrao.match(no.name):
87
+ rel["problemas"].append(
88
+ f"{caminho}: nome fora do padrão: {no.name}")
89
+ elif isinstance(no, ast.Assign):
90
+ for t in no.targets:
91
+ if isinstance(t, ast.Name):
92
+ for errado, _ in ERROS_COMUNS:
93
+ if errado in t.id:
94
+ rel["problemas"].append(
95
+ f"{caminho}: ortografia '{t.id}' contém '{errado}'")
96
+ if PADRAO_TOKEN.search(codigo):
97
+ rel["problemas"].append(f"{caminho}: POSSÍVEL TOKEN no código")
98
+ aprovado = not rel["problemas"]
99
+ rel["aprovado"] = aprovado
100
+ (self.aprovacoes if aprovado else self.bloqueios).append(rel)
101
+ self._registrar(rel)
102
+ return rel
103
+
104
+ def garantir_nao_regressao(self, capacidades_antes: dict,
105
+ capacidades_depois: dict,
106
+ menor_e_melhor: tuple = ("ppl_valid", "perda_valid")) -> dict:
107
+ """Teorema 16.10: nenhuma capacidade pode piorar além da tolerância."""
108
+ rel = {"antes": capacidades_antes, "depois": capacidades_depois,
109
+ "regressoes": {}}
110
+ for chave, depois in capacidades_depois.items():
111
+ antes = capacidades_antes.get(chave)
112
+ if antes is None or not isinstance(depois, (int, float)):
113
+ continue
114
+ delta = (antes - depois) if chave in menor_e_melhor else (depois - antes)
115
+ if delta < -self.tolerancia * max(abs(float(antes)), 1e-9):
116
+ rel["regressoes"][chave] = {
117
+ "antes": antes, "depois": depois,
118
+ "queda_relativa": round(-delta / max(abs(float(antes)), 1e-9), 4)}
119
+ rel["aprovado"] = not rel["regressoes"]
120
+ self._registrar({"evento": "nao_regressao", **rel})
121
+ return rel
122
+
123
+ # ================= Papel 2: observação integral =================
124
+ def observar_treino(self, passo: int, modelo, orquestrador_som=None,
125
+ treinador=None, extras: dict | None = None) -> dict:
126
+ """Coleta as métricas fundamentais de TODOS os módulos no passo t."""
127
+ m: dict = {"t": round(time.time(), 2), "passo": passo}
128
+ try:
129
+ m.update(modelo.metricas_estruturais())
130
+ except Exception as e:
131
+ m["erro_modelo"] = f"{type(e).__name__}: {e}"
132
+ if orquestrador_som is not None:
133
+ try:
134
+ m.update(orquestrador_som.telemetria_ativos())
135
+ m["som/variante_ativa_hash"] = float(hash(orquestrador_som.ativa) % 1000)
136
+ if hasattr(orquestrador_som, "atencao"):
137
+ atn = orquestrador_som.atencao.ultimo
138
+ if atn:
139
+ m["som_atn/entropia"] = atn.get("entropia", 0.0)
140
+ except Exception as e:
141
+ m["erro_som"] = f"{type(e).__name__}: {e}"
142
+ try:
143
+ from aurora.quanta.quantizacao import modo_quantizacao
144
+ modos = modo_quantizacao()
145
+ m["quanta/torchao_int8"] = 1.0 if modos.get("torchao_int8") else 0.0
146
+ m["quanta/qat_ativo"] = 1.0 if getattr(modelo, "qat", False) else 0.0
147
+ qat = getattr(modelo, "_qat", None)
148
+ if qat is not None:
149
+ m["quanta/erro_qat"] = float(getattr(qat, "ultimo_erro", 0.0))
150
+ except Exception as e:
151
+ m["erro_quanta"] = f"{type(e).__name__}: {e}"
152
+ if treinador is not None:
153
+ try:
154
+ m["treino/ultima_perda"] = float(modelo.ultima_perda or 0.0)
155
+ m["treino/epoca"] = float(treinador.epoca)
156
+ except Exception:
157
+ pass
158
+ if extras:
159
+ m.update({k: float(v) for k, v in extras.items()
160
+ if isinstance(v, (int, float)) and v == v})
161
+ if self.hub is not None:
162
+ escalares = {k: v for k, v in m.items()
163
+ if isinstance(v, (int, float)) and v == v
164
+ and k not in ("passo", "t")} # 'passo' é posicional
165
+ self.hub.passos(passo, **escalares)
166
+ self._registrar(m)
167
+ return m
168
+
169
+ @torch.no_grad()
170
+ def observar_inferencia(self, modelo, prompt_ids: torch.Tensor,
171
+ tokens_gerados: list,
172
+ latencia_s: float) -> dict:
173
+ """Métricas fundamentais da INFERÊNCIA: latência, repetição n-grama,
174
+ coerência (bigramas vistos — NLG), comprimento."""
175
+ n = max(len(tokens_gerados), 1)
176
+ unicos = len(set(tokens_gerados))
177
+ rep = 1.0 - (unicos / n)
178
+ coerencia = 0.0
179
+ if modelo.nlg is not None and len(tokens_gerados) >= 2:
180
+ acertos = 0
181
+ for i in range(len(tokens_gerados) - 1):
182
+ chave = modelo.nlg._hash(tokens_gerados[i], tokens_gerados[i + 1])
183
+ acertos += float(modelo.nlg.tab_bigramas[chave] > 0.01)
184
+ coerencia = acertos / (len(tokens_gerados) - 1)
185
+ m = {"latencia_s": round(latencia_s, 3), "tokens": n,
186
+ "taxa_repeticao": round(rep, 4),
187
+ "coerencia_bigramas": round(coerencia, 4)}
188
+ if self.hub is not None:
189
+ for k, v in m.items():
190
+ self.hub.atributo(f"inferencia/{k}", v)
191
+ self._registrar({"evento": "inferencia", **m})
192
+ return m
193
+
194
+ # ================= relatório =================
195
+ def relatorio(self, orquestrador_som=None, avaliacao: dict | None = None) -> dict:
196
+ """Relatório consolidado (gravado em telemetria_out/
197
+ relatorio_agente_engenheiro.json)."""
198
+ r = {"t": round(time.time(), 2),
199
+ "revisoes_aprovadas": len(self.aprovacoes),
200
+ "revisoes_bloqueadas": len(self.bloqueios),
201
+ "tolerancia_regressao": self.tolerancia}
202
+ if orquestrador_som is not None:
203
+ try:
204
+ r["som_variantes"] = orquestrador_som.estatisticas()
205
+ r["som_ativos"] = orquestrador_som.telemetria_ativos()
206
+ if hasattr(orquestrador_som, "atencao"):
207
+ inv = orquestrador_som.atencao.verificar_sem_orfas(
208
+ orquestrador_som, resemear=False)
209
+ r["som_invariante_sem_orfaos"] = inv.get("_invariante_ok", False)
210
+ except Exception as e:
211
+ r["erro_som"] = str(e)
212
+ if avaliacao:
213
+ r["avaliacao"] = avaliacao
214
+ r["ultimos_bloqueios"] = self.bloqueios[-3:]
215
+ caminho = os.path.join(self.dir_telemetria,
216
+ "relatorio_agente_engenheiro.json")
217
+ with open(caminho, "w", encoding="utf-8") as f:
218
+ json.dump(r, f, ensure_ascii=False, indent=2, default=str)
219
+ return r
220
+
221
+ # ---------------- infra ----------------
222
+ def _registrar(self, linha: dict):
223
+ try:
224
+ with open(self.arquivo_jsonl, "a", encoding="utf-8") as f:
225
+ f.write(json.dumps(linha, ensure_ascii=False, default=str) + "\n")
226
+ except Exception:
227
+ pass
src/aurora/quanta/quantizacao.py CHANGED
@@ -1,8 +1,40 @@
1
  # -*- coding: utf-8 -*-
2
- """Quantização W8A8 (item 9, doc 08): simétrica por tensor/canal, cotas
3
- provadas (‖erro‖∞ ≤ s/2, Teorema 8.1), STE para QAT (Teorema 8.3) e critério
4
- de outliers LLM.int8-like (eq. 8.2). bitsandbytes é delegado quando há CUDA;
5
- em CPU usamos o caminho simétrico puro-PyTorch com as MESMAS cotas.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6
  """
7
  from __future__ import annotations
8
 
@@ -10,6 +42,7 @@ import torch
10
  import torch.nn as nn
11
  import torch.nn.functional as F
12
 
 
13
 
14
 
15
  def quantiza_simetrica(x: torch.Tensor, bits: int = 8, por_canal: bool = False):
@@ -27,71 +60,9 @@ def quantiza_simetrica(x: torch.Tensor, bits: int = 8, por_canal: bool = False):
27
  return q * escala, escala, erro_max
28
 
29
 
30
- class FakeQuantW8A8(nn.Module):
31
- """Aplica quantização simétrica a pesos (permanente) e ativações (STE no
32
- treino: forward quantizado, backward identidade — Teorema 8.3)."""
33
-
34
- def __init__(self, por_canal: bool = True):
35
- super().__init__()
36
- self.por_canal = por_canal
37
- self.escala_w = None
38
- self.escala_a = None
39
-
40
- @staticmethod
41
- def _q_at(x: torch.Tensor) -> torch.Tensor:
42
- qmax = 127
43
- s = x.abs().amax().clamp(min=1e-12) / qmax
44
- q = torch.clamp(torch.round(x / s), -qmax, qmax) * s
45
- return x + (q - x).detach() # STE
46
-
47
- def forward(self, w: torch.Tensor, a: torch.Tensor | None = None):
48
- if self.training and a is not None:
49
- a = self._q_at(a)
50
- wq, escala, erro = quantiza_simetrica(w.detach(), 8, self.por_canal)
51
- if self.training:
52
- w = w + (wq - w).detach() # STE para pesos
53
- else:
54
- w = wq
55
- self.escala_w = escala
56
- if a is not None and not self.training:
57
- a_q, self.escala_a, _ = quantiza_simetrica(a, 8)
58
- a = a_q
59
- return w, a, erro
60
-
61
-
62
- def aplicar_w8_linear(x: torch.Tensor, w: torch.Tensor, vies: torch.Tensor | None,
63
- por_canal: bool = True):
64
- """Execução W8A8 de uma camada linear (avaliação). Devolve (y, erro_max)."""
65
- q = 127
66
- s_a = x.abs().amax().clamp(min=1e-12) / q
67
- s_w = w.abs().amax(dim=1, keepdim=True).clamp(min=1e-12) / q if por_canal \
68
- else w.abs().amax().clamp(min=1e-12) / q
69
- xq = torch.clamp(torch.round(x / s_a), -q, q)
70
- wq = torch.clamp(torch.round(w / s_w), -q, q)
71
- # produto em float (CPU sem int8 GEMM rápido) — erro idêntico ao int8 real
72
- y = (xq @ wq.T) * (s_a * s_w.T if por_canal else s_a * s_w)
73
- if vies is not None:
74
- y = y + vies
75
- erro = float((torch.clamp(torch.round(x / s_a), -q, q) * s_a - x).abs().max())
76
- return y, erro
77
-
78
-
79
- def separar_outliers(w: torch.Tensor, tau_mad: float = 6.0):
80
- """Critério LLM.int8 manual (eq. 8.2): colunas com magnitude > 6·MAD ficam
81
- em fp16; o resto em int8. Devolve (mask_outliers, n_outliers)."""
82
- mediana = w.abs().median()
83
- mad = (w.abs() - mediana).abs().median().clamp(min=1e-12)
84
- mask = w.abs() > tau_mad * mad
85
- return mask, int(mask.sum())
86
-
87
-
88
- # ---------------- v4: quantização MELHORADA (doc 08 §§5–6) ----------------
89
-
90
  def quantiza_por_grupo(x: torch.Tensor, bits: int = 8, tam_grupo: int = 64):
91
- """v4 — escalas POR GRUPO ao longo da última dimensão (doc 08 §5).
92
- Teorema 8.4: erro ∞-norma ≤ s_g/2 com s_g = max_g |x|_g / qmax, e o erro
93
- RMS cai ≈ √g frente à escala por tensor (g=tam_grupo). Fallback automático
94
- para escala por canal/tensor quando a última dim < tam_grupo."""
95
  qmax = 2 ** (bits - 1) - 1
96
  d_ult = x.shape[-1]
97
  if d_ult < tam_grupo:
@@ -115,51 +86,25 @@ def quantiza_por_grupo(x: torch.Tensor, bits: int = 8, tam_grupo: int = 64):
115
 
116
  def correcao_vies(w_fp: torch.Tensor, a_fp: torch.Tensor,
117
  w_q: torch.Tensor, a_q: torch.Tensor) -> torch.Tensor:
118
- """v4 — correção de viés pós-quantização (doc 08 §6, GPTQ-lite):
119
- Δb = E[a·w] − E[a_q·w_q] sobre o lote de calibração (a: (N, d_in),
120
- w: (d_out, d_in)) — remove o desvio sistemático de 1ª ordem; o residual
121
- é o erro de 2ª ordem do Teorema 8.2 (média s/4)."""
122
  y_fp = a_fp @ w_fp.T
123
  y_q = a_q @ w_q.T
124
  return (y_fp - y_q).mean(dim=0) # (d_out,)
125
 
126
 
127
- class FakeQuantW8A8Grupo(nn.Module):
128
- """v4 — FakeQuant com escalas POR GRUPO + correção de viés calibrada.
129
- Substitui FakeQuantW8A8 quando `tam_grupo > 0`. Mesmo contrato STE
130
- (Teorema 8.3); erro estruturalmente menor (Teorema 8.4)."""
131
-
132
- def __init__(self, tam_grupo: int = 64):
133
- super().__init__()
134
- self.tam_grupo = tam_grupo
135
- self.delta_vies: torch.Tensor | None = None
136
- self._calibrado = False
137
-
138
- def calibrar(self, w: torch.Tensor, a_cal: torch.Tensor):
139
- """a_cal: (N, d_in) lote de calibração — calcula Δb uma única vez."""
140
- with torch.no_grad():
141
- w_q, _, _ = quantiza_por_grupo(w, 8, self.tam_grupo) \
142
- if self.tam_grupo > 0 else quantiza_simetrica(w, 8, True)
143
- a_q, _, _ = quantiza_simetrica(a_cal, 8)
144
- self.delta_vies = correcao_vies(w, a_cal, w_q, a_q)
145
- self._calibrado = True
146
-
147
- def forward(self, w: torch.Tensor, a: torch.Tensor | None = None):
148
- if self.tam_grupo > 0:
149
- wq, escala, erro = quantiza_por_grupo(w.detach(), 8, self.tam_grupo)
150
- else:
151
- wq, escala, erro = quantiza_simetrica(w.detach(), 8, True)
152
- if self.training:
153
- w = w + (wq - w).detach()
154
- else:
155
- w = wq
156
- if a is not None and self.training:
157
- a = FakeQuantW8A8._q_at(a)
158
- return w, a, erro
159
 
160
 
161
- class _STEQuant(torch.autograd.Function):
162
- """round com backward identidade (doc 08 Teorema 8.3 / doc 10 §7)."""
163
 
164
  @staticmethod
165
  def forward(ctx, x, escala):
@@ -170,16 +115,49 @@ class _STEQuant(torch.autograd.Function):
170
  return g, None
171
 
172
 
173
- class SmoothQuantAlpha(nn.Module):
174
- """SmoothQuant com α APRENDIVEL via STE (doc 10 §7, eq. 10.7).
175
 
176
- s_j = max|X_j|^α / max|W_j|^{1−α}; α = σ(η) com η parâmetro treinável.
177
- Correções do estudo (w8a8_smoothquant.py / smoothquant_compressor.py):
178
- • os buffers usam register_buffer (viajam no state_dict);
179
- • o erro é medido no forward atual (sem bug de convergência pré-step);
180
- • α com clamp [0.05, 0.95].
181
  """
182
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
183
  def __init__(self, d_entrada: int, alpha0: float = 0.5):
184
  super().__init__()
185
  alpha0 = min(max(alpha0, 0.05), 0.95)
@@ -195,38 +173,29 @@ class SmoothQuantAlpha(nn.Module):
195
  @torch.no_grad()
196
  def calibrar(self, x: torch.Tensor, w: torch.Tensor):
197
  """Estatísticas max-abs por canal de entrada (0,5KB por camada)."""
198
- # x: (N, d_entrada); w: (d_saida, d_entrada) — canal = coluna de W
199
  self.max_x.copy_(x.abs().amax(dim=0).clamp(min=1e-8))
200
  self.max_w.copy_(w.abs().amax(dim=0).clamp(min=1e-8))
201
  self.calibrado = True
202
 
203
  def escalas(self) -> torch.Tensor:
204
- """s_j (eq. SmoothQuant) — diferenciável em η."""
205
  a = self.alpha
206
  return (self.max_x.pow(a) / self.max_w.pow(1.0 - a)).clamp(min=1e-8)
207
 
208
  def forward(self, x: torch.Tensor, w: torch.Tensor):
209
- """Devolve (x̃, w̃) suavizados-quantizados com STE; erro relativo."""
210
  if not self.calibrado:
211
  with torch.no_grad():
212
  self.calibrar(x.detach(), w.detach())
213
  s = self.escalas() # (d,)
214
- x_s = x / s
215
- w_s = w * s.unsqueeze(0)
216
- qmax = 127
217
- s_at = (x_s.abs().amax().clamp(min=1e-12) / qmax).detach()
218
- s_w = (w_s.abs().amax(dim=1, keepdim=True).clamp(min=1e-12) / qmax).detach()
219
- xq = _STEQuant.apply(x_s, s_at)
220
- wq = _STEQuant.apply(w_s, s_w)
221
- return xq, wq
222
 
223
  def erro_relativo(self, x: torch.Tensor, w: torch.Tensor) -> float:
224
- """E(α) = ‖Y−Y_q‖²/‖Y‖² medido com as escalas correntes (doc 10 §7)."""
225
  with torch.no_grad():
226
  s = self.escalas()
227
  y_ref = F.linear(x, w)
228
- x_s = x / s
229
- w_s = w * s.unsqueeze(0)
230
  qmax = 127
231
  s_at = x_s.abs().amax().clamp(min=1e-12) / qmax
232
  s_w = w_s.abs().amax(dim=1, keepdim=True).clamp(min=1e-12) / qmax
@@ -235,3 +204,136 @@ class SmoothQuantAlpha(nn.Module):
235
  y_q = F.linear(xq, wq)
236
  return float(((y_ref - y_q).pow(2).sum() /
237
  y_ref.pow(2).sum().clamp(min=1e-12)))
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
  # -*- coding: utf-8 -*-
2
+ """Quantização 8-bits REAL — v5 (doc 08 §§1–6 preservados; §§7–9 novos).
3
+
4
+ REFACTOR v5 — REMOÇÃO DOS FAKES (pedido explícito):
5
+ • `FakeQuantW8A8` REMOVIDO (era simulação float de int8 na inferência);
6
+ • `FakeQuantW8A8Grupo` REMOVIDO (idem);
7
+ • `aplicar_w8_linear` REMOVIDO (GEMM simulada em float — não era execução
8
+ int8 real; a mensuração de erro continua disponível via `metricas_qualidade`).
9
+ O que permanece e por quê:
10
+ • `quantiza_simetrica` / `quantiza_por_grupo` / `correcao_vies` /
11
+ `separar_outliers` — aritmética REAL de quantize→dequantize usada para
12
+ calibração (escalas, correção de viés) e cotas provadas (Teoremas 8.1–8.5);
13
+ • `QATW8A8` — quantização com STE DURANTE O TREINO (metodologia QAT padrão;
14
+ o mesmo mecanismo de torch.ao.quantization.prepare_qat, que usa FakeQuantize
15
+ internamente — aqui com nome honesto e escalas por grupo);
16
+ • `SmoothQuantAlpha` — suavização aprendível para CALIBRAÇÃO (doc 10 §7).
17
+
18
+ BACKENDS REAIS DE INFERÊNCIA/TREINO (§§7–9):
19
+ ┌──────────────────────────────┬─────────────┬────────────────────────────┐
20
+ │ backend │ dispositivo │ mecanismo │
21
+ ├──────────────────────────────┼─────────────┼────────────────────────────┤
22
+ │ torchao INT8 dinâmico (§7.1) │ CPU/GPU │ kernels int8 reais │
23
+ │ torch.ao QAT→convert (§7.2) │ CPU (univ.) │ fbgemm/x86/qnnpack reais │
24
+ │ torchao FP8 (§7.3) │ GPU (H100+) │ treino nativo float8 │
25
+ │ bitsandbytes W8 (§7.4) │ GPU │ weight-only 8-bit (HF) │
26
+ └──────────────────────────────┴─────────────┴────────────────────────────┘
27
+
28
+ TEOREMA 16.7 (equivalência de erro entre simulação e kernel real). Seja q_s(x)
29
+ a simulação round→clamp→dequantize e q_r o caminho do kernel int8. Ambos
30
+ implementam o MESMO mapa afim x ↦ s·clip(round(x/s), −qmax, qmax); logo
31
+ ‖q_s(x) − q_r(x)‖ = 0 e TODAS as cotas dos Teoremas 8.1–8.5 valem ao kernel
32
+ real — a diferença está apenas na VELOCIDADE (int8 GEMM nativo) e na MEMÓRIA
33
+ (1 byte/elemento), não no erro.
34
+
35
+ TEOREMA 16.8 (economia de memória). Um tensor de pesos fp32 (4 bytes/el.)
36
+ convertido a int8 ocupa 4× menos; com escalas por grupo (s/64 floats),
37
+ overhead = 4/64 bytes/el. = 6,25% ⇒ fator total ≈ 3,76×. Para fp16: 2×.
38
  """
39
  from __future__ import annotations
40
 
 
42
  import torch.nn as nn
43
  import torch.nn.functional as F
44
 
45
+ # ---------------------------------------------------------------- §1–6 (v2–v4)
46
 
47
 
48
  def quantiza_simetrica(x: torch.Tensor, bits: int = 8, por_canal: bool = False):
 
60
  return q * escala, escala, erro_max
61
 
62
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
63
  def quantiza_por_grupo(x: torch.Tensor, bits: int = 8, tam_grupo: int = 64):
64
+ """escalas POR GRUPO ao longo da última dimensão (doc 08 §5, Teorema 8.4:
65
+ erro RMS cai ≈ √g frente à escala por tensor)."""
 
 
66
  qmax = 2 ** (bits - 1) - 1
67
  d_ult = x.shape[-1]
68
  if d_ult < tam_grupo:
 
86
 
87
  def correcao_vies(w_fp: torch.Tensor, a_fp: torch.Tensor,
88
  w_q: torch.Tensor, a_q: torch.Tensor) -> torch.Tensor:
89
+ """Correção de viés pós-quantização (doc 08 §6, GPTQ-lite): Δb =
90
+ E[a·w] − E[a_q·w_q] sobre o lote de calibração — remove o desvio
91
+ sistemático de 1ª ordem."""
 
92
  y_fp = a_fp @ w_fp.T
93
  y_q = a_q @ w_q.T
94
  return (y_fp - y_q).mean(dim=0) # (d_out,)
95
 
96
 
97
+ def separar_outliers(w: torch.Tensor, tau_mad: float = 6.0):
98
+ """Critério LLM.int8 (eq. 8.2): colunas com magnitude > 6·MAD ficam em
99
+ fp16; o resto em int8. Devolve (mask_outliers, n_outliers)."""
100
+ mediana = w.abs().median()
101
+ mad = (w.abs() - mediana).abs().median().clamp(min=1e-12)
102
+ mask = w.abs() > tau_mad * mad
103
+ return mask, int(mask.sum())
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
104
 
105
 
106
+ class STEQuant(torch.autograd.Function):
107
+ """round com backward identidade (Teorema 8.3) — base do QAT de treino."""
108
 
109
  @staticmethod
110
  def forward(ctx, x, escala):
 
115
  return g, None
116
 
117
 
118
+ class QATW8A8(nn.Module):
119
+ """Quantização-aware TRAINING (pesos + ativações, escalas por grupo).
120
 
121
+ Metodologia QAT padrão (identical to torch.ao.quantization.prepare_qat's
122
+ FakeQuantize — nome honesto): forward com valores quantizados, backward
123
+ com STE (Teorema 8.3). A CONVERSÃO FINAL para kernels int8 reais é feita
124
+ por `converter_int8_real`/`converter_qat_int8` — nunca simulamos
125
+ quantização na inferência.
126
  """
127
 
128
+ def __init__(self, por_canal: bool = True, tam_grupo: int = 0):
129
+ super().__init__()
130
+ self.por_canal = por_canal
131
+ self.tam_grupo = tam_grupo
132
+ self.ultimo_erro: float = 0.0
133
+
134
+ def quantiza_peso(self, w: torch.Tensor) -> torch.Tensor:
135
+ """Peso quantizado com STE (treino) — para uso em F.linear."""
136
+ if self.tam_grupo > 0:
137
+ wq, _, erro = quantiza_por_grupo(w.detach(), 8, self.tam_grupo)
138
+ else:
139
+ wq, _, erro = quantiza_simetrica(w.detach(), 8, self.por_canal)
140
+ self.ultimo_erro = erro
141
+ return w + (wq - w).detach() # STE para pesos
142
+
143
+ def quantiza_ativacao(self, a: torch.Tensor) -> torch.Tensor:
144
+ """Ativação quantizada com STE (treino)."""
145
+ qmax = 127
146
+ s = a.abs().amax().clamp(min=1e-12) / qmax
147
+ q = torch.clamp(torch.round(a / s), -qmax, qmax) * s
148
+ return a + (q - a).detach() # STE (Teorema 8.3)
149
+
150
+ def forward(self, w: torch.Tensor, a: torch.Tensor | None = None):
151
+ """Compat: devolve (w_q, a_q|None, erro)."""
152
+ wq = self.quantiza_peso(w)
153
+ aq = self.quantiza_ativacao(a) if a is not None else None
154
+ return wq, aq, self.ultimo_erro
155
+
156
+
157
+ class SmoothQuantAlpha(nn.Module):
158
+ """SmoothQuant com α APRENDIVEL via STE (doc 10 §7, eq. 10.7) — usado
159
+ APENAS na calibração que alimenta os backends reais (§7)."""
160
+
161
  def __init__(self, d_entrada: int, alpha0: float = 0.5):
162
  super().__init__()
163
  alpha0 = min(max(alpha0, 0.05), 0.95)
 
173
  @torch.no_grad()
174
  def calibrar(self, x: torch.Tensor, w: torch.Tensor):
175
  """Estatísticas max-abs por canal de entrada (0,5KB por camada)."""
 
176
  self.max_x.copy_(x.abs().amax(dim=0).clamp(min=1e-8))
177
  self.max_w.copy_(w.abs().amax(dim=0).clamp(min=1e-8))
178
  self.calibrado = True
179
 
180
  def escalas(self) -> torch.Tensor:
181
+ """s_j = max|X_j|^α / max|W_j|^{1−α} — diferenciável em η."""
182
  a = self.alpha
183
  return (self.max_x.pow(a) / self.max_w.pow(1.0 - a)).clamp(min=1e-8)
184
 
185
  def forward(self, x: torch.Tensor, w: torch.Tensor):
186
+ """Devolve (x̃, w̃) suavizados (para calibrar antes da conversão real)."""
187
  if not self.calibrado:
188
  with torch.no_grad():
189
  self.calibrar(x.detach(), w.detach())
190
  s = self.escalas() # (d,)
191
+ return x / s, w * s.unsqueeze(0)
 
 
 
 
 
 
 
192
 
193
  def erro_relativo(self, x: torch.Tensor, w: torch.Tensor) -> float:
194
+ """E(α) = ‖Y−Y_q‖²/‖Y‖² medido com as escalas correntes."""
195
  with torch.no_grad():
196
  s = self.escalas()
197
  y_ref = F.linear(x, w)
198
+ x_s, w_s = x / s, w * s.unsqueeze(0)
 
199
  qmax = 127
200
  s_at = x_s.abs().amax().clamp(min=1e-12) / qmax
201
  s_w = w_s.abs().amax(dim=1, keepdim=True).clamp(min=1e-12) / qmax
 
204
  y_q = F.linear(xq, wq)
205
  return float(((y_ref - y_q).pow(2).sum() /
206
  y_ref.pow(2).sum().clamp(min=1e-12)))
207
+
208
+
209
+ # ------------------------------------------------- §7: backends REAIS (v5)
210
+
211
+ def converter_int8_real(modelo: nn.Module, tam_grupo: int | None = None) -> dict:
212
+ """§7.1 — CONVERSÃO REAL a INT8 via torchao (kernels nativos CPU/GPU).
213
+ Substitui in-place os nn.Linear por quantized (Int8DynamicActivation
214
+ Int8Weight). Devolve telemetria da conversão. Teorema 16.7: erro idêntico
215
+ ao da simulação; Teorema 16.8: ≈4× menos memória de pesos."""
216
+ try:
217
+ from torchao.quantization import Int8DynamicActivationInt8WeightConfig, quantize_
218
+ except Exception as e:
219
+ return {"ok": False, "motivo": f"torchao indisponível: {type(e).__name__}"}
220
+ antes = sum(p.numel() * p.element_size() for p in modelo.parameters())
221
+ quantize_(modelo, Int8DynamicActivationInt8WeightConfig())
222
+ depois = sum(p.numel() * p.element_size() for p in modelo.parameters())
223
+ return {"ok": True, "backend": "torchao_int8_dinamico",
224
+ "bytes_antes": antes, "bytes_depois": depois,
225
+ "fator_memoria": round(antes / max(depois, 1), 2)}
226
+
227
+
228
+ def converter_qat_int8(modelo: nn.Module, backend: str = "x86") -> dict:
229
+ """§7.2 — Treinamento INT8 UNIVERSAL (CPU/GPU/MPS) com conversão REAL
230
+ (fluxo torch.ao.quantization: prepare_qat → treino → convert). A chamada
231
+ aqui assume QAT já executado; realiza a conversão final para módulos
232
+ quantizados com kernels de hardware (fbgemm/x86/qnnpack)."""
233
+ try:
234
+ from torch.ao.quantization import convert, get_default_qconfig
235
+ except Exception as e:
236
+ return {"ok": False, "motivo": f"torch.ao indisponível: {type(e).__name__}"}
237
+ modelo.eval()
238
+ modelo.qconfig = get_default_qconfig(backend)
239
+ try:
240
+ q_modelo = convert(modelo, inplace=False)
241
+ return {"ok": True, "backend": f"torch_ao_convert({backend})",
242
+ "tipo": type(q_modelo).__name__}
243
+ except Exception as e:
244
+ return {"ok": False, "motivo": f"convert falhou: {type(e).__name__}: {e}"}
245
+
246
+
247
+ def preparar_qat_int8(modelo: nn.Module, backend: str = "x86") -> dict:
248
+ """§7.2 (fase 1) — insere os módulos de quantização-simulação do
249
+ torch.ao (prepare_qat) para TREINO em 8-bits; chame `converter_qat_int8`
250
+ ao final para obter INT8 REAL."""
251
+ try:
252
+ from torch.ao.quantization import get_default_qat_qconfig, prepare_qat
253
+ except Exception as e:
254
+ return {"ok": False, "motivo": f"torch.ao indisponível: {type(e).__name__}"}
255
+ modelo.train()
256
+ modelo.qconfig = get_default_qat_qconfig(backend)
257
+ try:
258
+ prepare_qat(modelo, inplace=True)
259
+ return {"ok": True, "backend": f"prepare_qat({backend})"}
260
+ except Exception as e:
261
+ return {"ok": False, "motivo": f"prepare_qat falhou: {type(e).__name__}: {e}"}
262
+
263
+
264
+ def preparar_treino_fp8(modelo: nn.Module, compilar: bool = True) -> dict:
265
+ """§7.3 — TREINO NATIVO FP8 (GPU H100+/Ada) via torchao.float8.
266
+ Requer CUDA com suporte a float8; caso contrário devolve ok=False
267
+ (degradação honesta — nada de FP8 simulado)."""
268
+ if not torch.cuda.is_available():
269
+ return {"ok": False, "motivo": "FP8 requer GPU CUDA (H100+/Ada)"}
270
+ try:
271
+ from torchao.float8 import Float8LinearConfig, convert_to_float8
272
+ config = Float8LinearConfig(enable_compile=compilar)
273
+ convert_to_float8(modelo, config=config)
274
+ if compilar:
275
+ modelo = torch.compile(modelo)
276
+ return {"ok": True, "backend": "torchao_float8", "compilado": compilar}
277
+ except Exception as e:
278
+ return {"ok": False, "motivo": f"float8 falhou: {type(e).__name__}: {e}"}
279
+
280
+
281
+ def carregar_8bit_bnb(model_id: str, token: str | None = None) -> dict:
282
+ """§7.4 — GPU Inference weight-only 8-bit (integração HF/bitsandbytes),
283
+ no padrão AutoModelForCausalLM.from_pretrained(load_in_8bit=True).
284
+ Requer bitsandbytes + CUDA; degradação honesta em CPU."""
285
+ if not torch.cuda.is_available():
286
+ return {"ok": False, "motivo": "bitsandbytes 8-bit requer GPU CUDA"}
287
+ try:
288
+ import bitsandbytes # noqa: F401
289
+ from transformers import AutoModelForCausalLM, AutoTokenizer
290
+ modelo = AutoModelForCausalLM.from_pretrained(
291
+ model_id, device_map="auto", load_in_8bit=True, token=token)
292
+ tokenizer = AutoTokenizer.from_pretrained(model_id, token=token)
293
+ return {"ok": True, "backend": "bitsandbytes_weight_only",
294
+ "modelo": modelo, "tokenizer": tokenizer}
295
+ except Exception as e:
296
+ return {"ok": False, "motivo": f"bnb falhou: {type(e).__name__}: {e}"}
297
+
298
+
299
+ def metricas_qualidade(x: torch.Tensor, w: torch.Tensor,
300
+ tam_grupo: int = 64) -> dict:
301
+ """§8 — métricas HONESTAS da quantização (nada simulado na inferência):
302
+ erro relativo ‖Y−Y_q‖²/‖Y‖², SNR em dB e cota do Teorema 8.4."""
303
+ with torch.no_grad():
304
+ y_ref = F.linear(x, w)
305
+ xq, _, _ = quantiza_simetrica(x, 8)
306
+ wq, _, _ = quantiza_por_grupo(w, 8, tam_grupo)
307
+ y_q = F.linear(xq, wq)
308
+ e2 = float((y_ref - y_q).pow(2).sum())
309
+ s2 = float(y_ref.pow(2).sum().clamp(min=1e-12))
310
+ return {"erro_relativo": e2 / s2,
311
+ "snr_db": round(10.0 * torch.log10(torch.tensor(s2 / max(e2, 1e-12))).item(), 2),
312
+ "erro_max_ativ": float((xq - x).abs().max())}
313
+
314
+
315
+ def modo_quantizacao() -> dict:
316
+ """§9 — diagnóstico honesto: quais backends REAIS estão disponíveis aqui."""
317
+ out = {"torch": torch.__version__, "cuda": torch.cuda.is_available()}
318
+ try:
319
+ import torchao # noqa: F401
320
+ from torchao.quantization import Int8DynamicActivationInt8WeightConfig # noqa: F401
321
+ out["torchao_int8"] = True
322
+ except Exception:
323
+ out["torchao_int8"] = False
324
+ try:
325
+ from torchao.float8 import convert_to_float8 # noqa: F401
326
+ out["torchao_fp8"] = torch.cuda.is_available()
327
+ except Exception:
328
+ out["torchao_fp8"] = False
329
+ try:
330
+ import bitsandbytes # noqa: F401
331
+ out["bitsandbytes"] = torch.cuda.is_available()
332
+ except Exception:
333
+ out["bitsandbytes"] = False
334
+ try:
335
+ from torch.ao.quantization import get_default_qat_qconfig # noqa: F401
336
+ out["torch_ao_qat"] = True
337
+ except Exception:
338
+ out["torch_ao_qat"] = False
339
+ return out
src/aurora/treino/treinador.py CHANGED
@@ -5,7 +5,9 @@ FASE 1 densa (rede aprimorada, MÁXIMO de conexões): todos os parâmetros
5
  recebem gradiente; MoE com gate softmax sobre TODOS os experts; MTP
6
  ativa; PCGrad entre CE e auxiliares (doc 10 §5); barreira ABMO no lr
7
  (doc 10 §6); punição/retreino (item 6); checkpoints no HuggingFace
8
- (item c — salvar E USAR estados no Hub, disco local mínimo).
 
 
9
  FASE 2 foco (última época): MoE top-k + máscara de tarefa (ignora irrelevante
10
  por indexação) + QAT-W8A8 nos passos finais (item 9).
11
  FASE 3 DPO: pares (dourado, corrompido) com β adaptativo (doc 10 §4).
@@ -25,7 +27,7 @@ from collections import deque
25
 
26
  import torch
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
@@ -63,10 +65,10 @@ def _audio_para_tensor(onda_fp16: bytes) -> torch.Tensor:
63
  class TreinadorExtensao:
64
  def __init__(self, cfg, modelo: AURORAModel, tokenizador, hub: TelemetryHub,
65
  registros: list[dict], orquestrador_som=None,
66
- estados: EstadosHF | None = None):
67
  self.cfg, self.modelo, self.tk, self.hub = cfg, modelo, tokenizador, hub
68
  self.orquestrador = orquestrador_som
69
- self.estados = estados
70
  rng = random.Random(cfg.dados.semente)
71
  rng.shuffle(registros)
72
  corte = int(0.9 * len(registros))
@@ -128,6 +130,10 @@ class TreinadorExtensao:
128
  self.k_adaptativo = bool(dict(getattr(cfg.modelo, "mtp", {}) or {})
129
  .get("k_adaptativo", True))
130
  self._perdas_recentes: deque = deque(maxlen=8)
 
 
 
 
131
  self.replay_memoria_a_cada = int(getattr(cfg, "memoria_interna",
132
  None) is not None and
133
  cfg.memoria_interna.replay_a_cada or 40)
@@ -428,6 +434,12 @@ class TreinadorExtensao:
428
  self.passo_global)
429
  for nome, m in self.modelo.metricas_estruturais().items():
430
  self.hub.atributo(f"struct/{nome}", m)
 
 
 
 
 
 
431
  if isinstance(self.modelo.alinhamento, CamadaOrtogonal) and self.passo_global % 100 == 0:
432
  self.modelo.alinhamento.renormalizar() # ortogonalidade exata (Teorema 9.1)
433
  # punição/retreino (item 6)
@@ -466,34 +478,32 @@ class TreinadorExtensao:
466
  self.modelo.train()
467
  return resultado
468
 
469
- # ---------------- estados no HF (item c) ----------------
470
- def salvar_estado_hf(self, tag: str, extra: dict | None = None):
471
- if self.estados is None:
 
 
 
472
  return None
473
  meta = {"passo_global": self.passo_global, "epoca": self.epoca,
474
  "t_ciclo": self.t_ciclo, "T_ciclo": self.T_ciclo,
475
  "passos_epoca": self.passos_epoca,
476
  "historico_epocas": self.historico_epocas,
477
  "L_hat": self._L_hat, **(extra or {})}
478
- caminho = self.estados.salvar(self.modelo, tag, meta)
479
- if self.estados.repo_id and self.estados.token:
480
- n = self.estados.limpar_locais(manter=tag) \
481
- if self.cfg.estados_hf.manter_ultimo_local else 0
482
- if n:
483
- self.hub.atributo("estados/locais_apagados", n, self.passo_global)
484
  return caminho
485
 
486
- def retomar_do_hub(self) -> str | None:
487
- """'salvar (e usar)': retoma do estado mais avançado publicado no Hub."""
488
- if self.estados is None:
489
  return None
490
- tag = self.estados.carregar_ultimo(self.modelo)
491
- if tag is None:
492
  return None
493
- dados = self.estados._download(tag, "meta.json")
494
- if dados:
495
- import json
496
- meta = json.loads(dados)
497
  self.passo_global = meta.get("passo_global", 0)
498
  self.epoca = meta.get("epoca", 0)
499
  self.t_ciclo = meta.get("t_ciclo", 0)
@@ -503,6 +513,13 @@ class TreinadorExtensao:
503
  self._L_hat = meta.get("L_hat", 1.0)
504
  return tag
505
 
 
 
 
 
 
 
 
506
  # ---------------- DPO (doc 10 §4) ----------------
507
  def treinar_dpo(self, passos: int | None = None) -> dict:
508
  """Pares sintetizados: escolhido = saída dourada; rejeitado = corrupção
@@ -688,7 +705,15 @@ class TreinadorExtensao:
688
  self.hub.atributo("som/eq_consolidado", float(eq))
689
  except Exception:
690
  pass
691
- self.prototipos_som = self.orquestrador.mapear(ctx)
 
 
 
 
 
 
 
 
692
  return resultado
693
 
694
  # ---------------- laço principal ----------------
@@ -718,12 +743,12 @@ class TreinadorExtensao:
718
  perdas_epoca.append(self._passo())
719
  self.passos_epoca += 1
720
  if self.passo_global % cfg.checkpoint_a_cada == 0:
721
- self.salvar_estado_hf(f"epoca-{ep:03d}-p{self.passo_global:05d}")
722
  if orcamento_s is not None and time.time() - t0 > orcamento_s:
723
  interrompido = True
724
  break
725
  if interrompido:
726
- self.salvar_estado_hf(f"epoca-{ep:03d}-p{self.passo_global:05d}")
727
  break
728
  eq_som = self.atualizar_memoria_som()
729
  aval = self.avaliar()
@@ -736,7 +761,7 @@ class TreinadorExtensao:
736
  for k, v in stats_mem.items():
737
  if isinstance(v, (int, float)):
738
  self.hub.atributo(f"memoria/{k}", float(v), ep)
739
- self.salvar_estado_hf(f"epoca-{ep:03d}")
740
  registro = {"epoca": ep, "perda_media": (sum(perdas_epoca) / len(perdas_epoca)) if perdas_epoca else None,
741
  "avaliacao": aval, "eq_som": eq_som,
742
  "punicoes": len(self.eventos_punicao),
 
5
  recebem gradiente; MoE com gate softmax sobre TODOS os experts; MTP
6
  ativa; PCGrad entre CE e auxiliares (doc 10 §5); barreira ABMO no lr
7
  (doc 10 §6); punição/retreino (item 6); checkpoints no HuggingFace
8
+ (item c — salvar E USAR estados) substituído por checkpoints LOCAIS com
9
+ higiene de disco; snapshot final entra no commit único de publicação
10
+ (doc 16 §8 — sem uploads parciais no Hub).
11
  FASE 2 foco (última época): MoE top-k + máscara de tarefa (ignora irrelevante
12
  por indexação) + QAT-W8A8 nos passos finais (item 9).
13
  FASE 3 DPO: pares (dourado, corrompido) com β adaptativo (doc 10 §4).
 
27
 
28
  import torch
29
 
30
+ from aurora.dados.checkpoints import GestorCheckpoints
31
  from aurora.dados.streaming import _de_b64
32
  from aurora.memoria.interna import MemoriaInterna
33
  from aurora.nucleo.modelo import AURORAModel
 
65
  class TreinadorExtensao:
66
  def __init__(self, cfg, modelo: AURORAModel, tokenizador, hub: TelemetryHub,
67
  registros: list[dict], orquestrador_som=None,
68
+ checkpoints: GestorCheckpoints | None = None):
69
  self.cfg, self.modelo, self.tk, self.hub = cfg, modelo, tokenizador, hub
70
  self.orquestrador = orquestrador_som
71
+ self.checkpoints = checkpoints
72
  rng = random.Random(cfg.dados.semente)
73
  rng.shuffle(registros)
74
  corte = int(0.9 * len(registros))
 
130
  self.k_adaptativo = bool(dict(getattr(cfg.modelo, "mtp", {}) or {})
131
  .get("k_adaptativo", True))
132
  self._perdas_recentes: deque = deque(maxlen=8)
133
+ # v5 — Agente Engenheiro (doc 16 §9): observação integral de métricas
134
+ self.agente_engenheiro = None
135
+ self.intervalo_agente = int(getattr(cfg.agente_engenheiro, "intervalo", 50)
136
+ if hasattr(cfg, "agente_engenheiro") else 50)
137
  self.replay_memoria_a_cada = int(getattr(cfg, "memoria_interna",
138
  None) is not None and
139
  cfg.memoria_interna.replay_a_cada or 40)
 
434
  self.passo_global)
435
  for nome, m in self.modelo.metricas_estruturais().items():
436
  self.hub.atributo(f"struct/{nome}", m)
437
+ # v5 — Agente Engenheiro: observação integral periódica (doc 16 §9)
438
+ if self.agente_engenheiro is not None \
439
+ and self.passo_global % max(1, self.intervalo_agente) == 0:
440
+ self.agente_engenheiro.observar_treino(
441
+ self.passo_global, self.modelo,
442
+ orquestrador_som=self.orquestrador, treinador=self)
443
  if isinstance(self.modelo.alinhamento, CamadaOrtogonal) and self.passo_global % 100 == 0:
444
  self.modelo.alinhamento.renormalizar() # ortogonalidade exata (Teorema 9.1)
445
  # punição/retreino (item 6)
 
478
  self.modelo.train()
479
  return resultado
480
 
481
+ # ---------------- checkpoints locais (item c; doc 16 §8) ----------------
482
+ def salvar_checkpoint(self, tag: str, extra: dict | None = None):
483
+ """Checkpoint LOCAL atômico (safetensors + SHA-256). Nenhum upload
484
+ parcial no Hub durante o treino — o snapshot final é publicado no
485
+ commit único (doc 16 §8, Teorema 16.9)."""
486
+ if self.checkpoints is None:
487
  return None
488
  meta = {"passo_global": self.passo_global, "epoca": self.epoca,
489
  "t_ciclo": self.t_ciclo, "T_ciclo": self.T_ciclo,
490
  "passos_epoca": self.passos_epoca,
491
  "historico_epocas": self.historico_epocas,
492
  "L_hat": self._L_hat, **(extra or {})}
493
+ caminho = self.checkpoints.salvar(self.modelo, tag, meta)
494
+ self.hub.atributo("checkpoints/tag_passo", self.passo_global,
495
+ self.passo_global)
 
 
 
496
  return caminho
497
 
498
+ def retomar_ultimo_checkpoint(self) -> str | None:
499
+ """Retoma do checkpoint local mais avançado (maior passo_global)."""
500
+ if self.checkpoints is None:
501
  return None
502
+ tag = self.checkpoints.ultima_tag()
503
+ if tag is None or not self.checkpoints.carregar(self.modelo, tag):
504
  return None
505
+ meta = self.checkpoints.meta_de(tag)
506
+ if meta:
 
 
507
  self.passo_global = meta.get("passo_global", 0)
508
  self.epoca = meta.get("epoca", 0)
509
  self.t_ciclo = meta.get("t_ciclo", 0)
 
513
  self._L_hat = meta.get("L_hat", 1.0)
514
  return tag
515
 
516
+ # compat v4 (nomes antigos usados em scripts/tests)
517
+ def salvar_estado_hf(self, tag: str, extra: dict | None = None):
518
+ return self.salvar_checkpoint(tag, extra)
519
+
520
+ def retomar_do_hub(self) -> str | None:
521
+ return self.retomar_ultimo_checkpoint()
522
+
523
  # ---------------- DPO (doc 10 §4) ----------------
524
  def treinar_dpo(self, passos: int | None = None) -> dict:
525
  """Pares sintetizados: escolhido = saída dourada; rejeitado = corrupção
 
705
  self.hub.atributo("som/eq_consolidado", float(eq))
706
  except Exception:
707
  pass
708
+ self.prototipos_som = self.orquestrador.mapear_atencao(ctx)
709
+ # v5 — Teorema 16.5: invariante ZERO neurônios isolados (com resemeadura)
710
+ if getattr(self.orquestrador, "atencao", None) is not None:
711
+ inv = self.orquestrador.atencao.verificar_sem_orfas(
712
+ self.orquestrador, dados=ctx, resemear=True)
713
+ resultado["invariante_sem_orfaos"] = inv.pop("_invariante_ok", None)
714
+ resultado["orfaos_por_variante"] = inv
715
+ self.hub.atributo("som/invariante_orfaos",
716
+ 1.0 if resultado["invariante_sem_orfaos"] else 0.0)
717
  return resultado
718
 
719
  # ---------------- laço principal ----------------
 
743
  perdas_epoca.append(self._passo())
744
  self.passos_epoca += 1
745
  if self.passo_global % cfg.checkpoint_a_cada == 0:
746
+ self.salvar_checkpoint(f"epoca-{ep:03d}-p{self.passo_global:05d}")
747
  if orcamento_s is not None and time.time() - t0 > orcamento_s:
748
  interrompido = True
749
  break
750
  if interrompido:
751
+ self.salvar_checkpoint(f"epoca-{ep:03d}-p{self.passo_global:05d}")
752
  break
753
  eq_som = self.atualizar_memoria_som()
754
  aval = self.avaliar()
 
761
  for k, v in stats_mem.items():
762
  if isinstance(v, (int, float)):
763
  self.hub.atributo(f"memoria/{k}", float(v), ep)
764
+ self.salvar_checkpoint(f"epoca-{ep:03d}")
765
  registro = {"epoca": ep, "perda_media": (sum(perdas_epoca) / len(perdas_epoca)) if perdas_epoca else None,
766
  "avaliacao": aval, "eq_som": eq_som,
767
  "punicoes": len(self.eventos_punicao),
tests/test_aurora.py CHANGED
@@ -21,7 +21,7 @@ from aurora.memoria.variantes_especiais import (CounterpropagationNetwork,
21
  from aurora.nucleo.modelo import AURORAModel
22
  from aurora.percepcao.atencao import MixtureOfAttention
23
  from aurora.percepcao.ortogonais import CamadaOrtogonal
24
- from aurora.quanta.quantizacao import (aplicar_w8_linear, quantiza_simetrica,
25
  separar_outliers)
26
 
27
  OK, FALHAS = 0, []
@@ -106,8 +106,18 @@ def testa_quantizacao():
106
  x = torch.randn(64, 32) * 0.7
107
  xq, s, erro = quantiza_simetrica(x)
108
  verifica("Teorema 8.1: erro ≤ s/2", erro <= s / 2 + 1e-6, f"erro={erro:.4f} s={s:.4f}")
109
- y, erro2 = aplicar_w8_linear(torch.randn(4, 32), x, None)
110
- verifica("W8A8 matmul: erro dentro da cota", erro2 <= s / 2 + 0.05)
 
 
 
 
 
 
 
 
 
 
111
  mask, n = separar_outliers(x)
112
  verifica("LLM.int8: critério de outliers roda", isinstance(n, int))
113
 
 
21
  from aurora.nucleo.modelo import AURORAModel
22
  from aurora.percepcao.atencao import MixtureOfAttention
23
  from aurora.percepcao.ortogonais import CamadaOrtogonal
24
+ from aurora.quanta.quantizacao import (metricas_qualidade, quantiza_simetrica,
25
  separar_outliers)
26
 
27
  OK, FALHAS = 0, []
 
106
  x = torch.randn(64, 32) * 0.7
107
  xq, s, erro = quantiza_simetrica(x)
108
  verifica("Teorema 8.1: erro ≤ s/2", erro <= s / 2 + 1e-6, f"erro={erro:.4f} s={s:.4f}")
109
+ # v5 — quantização REAL (sem fakes): backends + métricas honestas
110
+ mq = metricas_qualidade(torch.randn(8, 32), torch.randn(16, 32))
111
+ verifica("Teorema 16.7: métricas reais de quantização",
112
+ mq["erro_relativo"] >= 0 and mq["snr_db"] > 0,
113
+ f"SNR={mq['snr_db']}dB erro_rel={mq['erro_relativo']:.4f}")
114
+ from aurora.quanta.quantizacao import converter_int8_real, modo_quantizacao
115
+ lin = torch.nn.Sequential(torch.nn.Linear(32, 16), torch.nn.ReLU())
116
+ conv = converter_int8_real(lin)
117
+ verifica("torchao: conversão INT8 REAL", conv.get("ok") is True,
118
+ str(conv.get("motivo", f"fator={conv.get('fator_memoria')}")))
119
+ modos = modo_quantizacao()
120
+ verifica("§9: diagnóstico honesto de backends", "torchao_int8" in modos)
121
  mask, n = separar_outliers(x)
122
  verifica("LLM.int8: critério de outliers roda", isinstance(n, int))
123
 
tests/test_aurora_v2.py CHANGED
@@ -170,11 +170,11 @@ def testa_smoothquant():
170
  verifica("buffers registrados (state_dict)", "max_x" in sq.state_dict())
171
 
172
 
173
- def testa_estados_hf():
174
- print("== EstadosHF modo local (doc 10 §9) ==")
175
  dir_local = "/home/z/my-project/aurora/estados_local_teste"
176
- from aurora.dados.estados_hf import EstadosHF
177
- est = EstadosHF(repo_id=None, dir_local=dir_local)
178
  cfg = Config()
179
  cfg.modelo.vocab, cfg.modelo.d_modelo = 256, 64
180
  cfg.modelo.n_camadas, cfg.modelo.d_ff = 2, 128
@@ -314,7 +314,7 @@ if __name__ == "__main__":
314
  testa_dpo()
315
  testa_pcgrad()
316
  testa_smoothquant()
317
- testa_estados_hf()
318
  testa_som_max_ativos()
319
  testa_abmo_e_geracao()
320
  testa_helpers_multimodal()
 
170
  verifica("buffers registrados (state_dict)", "max_x" in sq.state_dict())
171
 
172
 
173
+ def testa_checkpoints():
174
+ print("== GestorCheckpoints modo local (doc 16 §8) ==")
175
  dir_local = "/home/z/my-project/aurora/estados_local_teste"
176
+ from aurora.dados.checkpoints import GestorCheckpoints
177
+ est = GestorCheckpoints(dir_local=dir_local)
178
  cfg = Config()
179
  cfg.modelo.vocab, cfg.modelo.d_modelo = 256, 64
180
  cfg.modelo.n_camadas, cfg.modelo.d_ff = 2, 128
 
314
  testa_dpo()
315
  testa_pcgrad()
316
  testa_smoothquant()
317
+ testa_checkpoints()
318
  testa_som_max_ativos()
319
  testa_abmo_e_geracao()
320
  testa_helpers_multimodal()
tests/test_aurora_v5.py ADDED
@@ -0,0 +1,266 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # -*- coding: utf-8 -*-
2
+ """Testes AURORA v5 (doc 16–17): atenção entre MoEs, entre variantes SOM,
3
+ quantização REAL sem fakes, difusão multimodal, Agente Engenheiro, checkpoints.
4
+ Executar: python tests/test_aurora_v5.py
5
+ """
6
+ import sys
7
+ import time
8
+
9
+ sys.path.insert(0, "/home/z/my-project/aurora/src")
10
+
11
+ import torch
12
+
13
+ from aurora.config import Config
14
+
15
+ _RESULT = {"ok": 0, "falhas": 0}
16
+
17
+
18
+ def verifica(nome: str, cond: bool, detalhe: str = ""):
19
+ marca = "✓" if cond else "✗ FALHOU"
20
+ print(f" {marca} {nome}" + (f" — {detalhe}" if detalhe else ""))
21
+ _RESULT["ok" if cond else "falhas"] += 1
22
+ return cond
23
+
24
+
25
+ def testa_atencao_entre_moes():
26
+ print("== Atenção entre camadas MoE (doc 16 §§1–2) ==")
27
+ from aurora.nucleo.modelo import AURORAModel
28
+ from aurora.percepcao.atencao_moe import RefinamentoEntreMoEs
29
+ cfg = Config()
30
+ m = AURORAModel(cfg, usar_multimodal=False)
31
+ moes = [b.moe for b in m.blocos if b.moe is not None]
32
+ verifica("wiring: camada ℓ recebe refino da ℓ−1",
33
+ moes[-1].refino is not None and moes[-1].moe_anterior is moes[-2]
34
+ and moes[0].refino is None)
35
+ torch.manual_seed(0)
36
+ ids = torch.randint(4, cfg.modelo.vocab, (2, 16))
37
+ # nascimento neutro: α=β=0 ⇒ saída idêntica a v4 (Teorema 16.1c)
38
+ m.eval()
39
+ with torch.no_grad():
40
+ logits_neutro, _ = m(ids, alvo=ids)
41
+ moes[-1].refino.alpha.fill_(0.05)
42
+ logits_com_refino, _ = m(ids, alvo=ids)
43
+ verifica("Teorema 16.1c: α=0 → v4 exato; α≠0 muda a saída",
44
+ float((logits_neutro - logits_com_refino).abs().max()) > 0)
45
+ m.train()
46
+ _, perda = m(ids, alvo=ids)
47
+ perda.backward()
48
+ g_alpha = moes[-1].refino.alpha.grad
49
+ g_beta = moes[-1].beta_feedback.grad
50
+ verifica("gradiente flui para α e β (treino aprende o refino)",
51
+ g_alpha is not None and float(g_alpha.abs()) > 0
52
+ and g_beta is not None)
53
+ # custo (Teorema 16.6): refino 3d²+2Nd ≪ experts 3N·d·d_ff
54
+ N, d, d_ff = moes[-1].N, cfg.modelo.d_modelo, cfg.modelo.moe["d_ff_expert"]
55
+ custo_refino = 3 * d * d + 2 * N * d
56
+ custo_experts = N * 3 * d * d_ff
57
+ verifica("Teorema 16.6: custo do refino ≪ custo dos experts",
58
+ custo_refino < custo_experts * 0.5,
59
+ f"refino={custo_refino} < 50% de experts={custo_experts}")
60
+
61
+
62
+ def testa_atencao_entre_variantes_som():
63
+ print("== Atenção entre variantes SOM (doc 16 §§3–5) ==")
64
+ from aurora.memoria.orquestrador import OrquestradorSOM
65
+ from aurora.memoria.atencao_som import AtencaoEntreVariantes, prototipo_e_distancia
66
+ cfg = Config()
67
+ o = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som,
68
+ cfg_atencao=vars(cfg.som_atencao))
69
+ torch.manual_seed(3)
70
+ x = torch.randn(32, cfg.modelo.d_modelo) * 0.5
71
+ o.treinar_memoria(x, epocas=2)
72
+ z = o.mapear_atencao(x)
73
+ verifica("mapear_atencao devolve (B,d)", z.shape == x.shape)
74
+ # Teorema 16.3: ẑ ∈ casco{∪_v W_v} — dentro do raio do maior protótipo
75
+ def _codebook(v):
76
+ for alvo in (v, getattr(v, "kohonen", None), getattr(v, "n1", None)):
77
+ if alvo is not None and hasattr(alvo, "w"):
78
+ return alvo.w
79
+ return None
80
+ livros = [cb for cb in (_codebook(o.variantes[n]) for n in o.variantes)
81
+ if cb is not None]
82
+ protos = torch.cat(livros, dim=0)
83
+ r_max = float((protos - protos.mean(0)).norm(dim=1).max())
84
+ dentro = float((z - protos.mean(0)).norm(dim=1).max()) <= r_max * 1.5 + 1e-6
85
+ verifica("Teorema 16.3: ẑ no casco dos protótipos (raio),"
86
+ " sem extrapolar a memória", dentro)
87
+ # Teorema 16.4: τ→0 ⇒ peso uniforme no CONJUNTO de empate do argmin
88
+ atn_duro = AtencaoEntreVariantes(tau=1e-6, gamma_novidade=0.0)
89
+ z_duro = atn_duro.mapear(x, o)
90
+ nomes = list(o.variantes.keys())
91
+ ds = torch.stack([prototipo_e_distancia(o.variantes[n], x)[1]
92
+ for n in nomes], dim=1) # (B, V)
93
+ zs = torch.stack([prototipo_e_distancia(o.variantes[n], x)[0]
94
+ for n in nomes], dim=1) # (B, V, d)
95
+ z_ref = torch.empty_like(x)
96
+ for b in range(x.shape[0]):
97
+ empate = (ds[b] <= ds[b].min() + 1e-6).nonzero(as_tuple=True)[0]
98
+ z_ref[b] = zs[b, empate].mean(dim=0) # limite da softmax no empate
99
+ err = float((z_duro - z_ref).norm(dim=1).mean())
100
+ verifica("Teorema 16.4: τ→0 ⇒ protótipo do conjunto de empate (argmin)",
101
+ err < 1e-3, f"erro médio={err:.2e}")
102
+ # Teorema 16.5: invariante zero órfãos após resemeadura
103
+ for v in o.variantes.values():
104
+ if hasattr(v, "hit_ema"):
105
+ v.hit_ema.zero_() # força estado 'todos mortos'
106
+ inv = o.atencao.verificar_sem_orfas(o, dados=x, resemear=True)
107
+ verifica("Teorema 16.5: resemeadura restaura ZERO órfãos",
108
+ inv["_invariante_ok"] and inv["som"]["relocados"] > 0)
109
+ a = o.atencao.ultimo["pesos"]
110
+ verifica("eq. 16.3: pesos atencionais somam 1 (softmax)",
111
+ abs(float(a.sum()) - 1.0) < 1e-5)
112
+
113
+
114
+ def testa_quantizacao_real():
115
+ print("== Quantização REAL sem fakes (doc 08 §§7–9) ==")
116
+ from aurora.quanta.quantizacao import (QATW8A8, converter_int8_real,
117
+ metricas_qualidade, modo_quantizacao,
118
+ quantiza_simetrica)
119
+ lin = torch.nn.Linear(64, 32)
120
+ conv = converter_int8_real(lin)
121
+ verifica("§7.1 torchao: conversão INT8 REAL ok",
122
+ conv.get("ok") is True,
123
+ str(conv.get("motivo", f"fator={conv.get('fator_memoria')}x")))
124
+ if conv.get("ok"):
125
+ y = lin(torch.randn(4, 64))
126
+ verifica("§7.1 forward com kernels int8 reais", y.shape == (4, 32))
127
+ mq = metricas_qualidade(torch.randn(16, 64), torch.randn(32, 64))
128
+ verifica("§8 métricas honestas (SNR>0, erro<1)", mq["snr_db"] > 0
129
+ and 0 <= mq["erro_relativo"] < 1,
130
+ f"SNR={mq['snr_db']}dB")
131
+ qat = QATW8A8(por_canal=True, tam_grupo=64)
132
+ w = torch.randn(32, 64)
133
+ wq = qat.quantiza_peso(w)
134
+ verifica("QAT-STE (Teorema 8.3): gradiente preservado",
135
+ torch.equal(w + (wq - w).detach(), wq) and qat.ultimo_erro <= 1.0)
136
+ modos = modo_quantizacao()
137
+ verifica("§9 diagnóstico honesto de backends",
138
+ isinstance(modos.get("torchao_int8"), bool))
139
+ # fakes REMOVIDOS
140
+ import aurora.quanta.quantizacao as qz
141
+ verifica("fakes removidos (FakeQuantW8A8/aplicar_w8_linear)",
142
+ not hasattr(qz, "FakeQuantW8A8") and not hasattr(qz, "aplicar_w8_linear"))
143
+
144
+
145
+ def testa_difusao():
146
+ print("== Difusão multimodal (doc 17) ==")
147
+ try:
148
+ from diffusers import (StableDiffusionImg2ImgPipeline,
149
+ StableDiffusionInpaintPipeline,
150
+ StableDiffusionPipeline)
151
+ ok_import = True
152
+ except Exception:
153
+ ok_import = False
154
+ verifica("import EXATO dos 3 pipelines SD", ok_import)
155
+ from aurora.geracao import GeradorMultimodal
156
+ g = GeradorMultimodal(repo_id="repo/inexistente-teste", altura=128, largura=128)
157
+ r = g.texto_para_imagem("um gato ao sol")
158
+ verifica("Teorema 17.2: modo planejado HONESTO (sem pixels falsos)",
159
+ r["modo"] == "planejado" and "imagem" not in r)
160
+ # Teorema 17.1: monotonia da força semântica
161
+ e_alto = torch.ones(1, 8)
162
+ forca_1 = g.forca_por_similaridade(e_alto, e_alto) # cos=1
163
+ forca_0 = g.forca_por_similaridade(e_alto, -e_alto) # cos=-1
164
+ verifica("Teorema 17.1: cos=1 → edição leve < cos=0 → recriação",
165
+ forca_1 < forca_0, f"{forca_1:.2f} < {forca_0:.2f}")
166
+ from aurora.nucleo.modelo import AURORAModel
167
+ m = AURORAModel(Config(), usar_multimodal=False)
168
+ p_enr = m.nlg.enriquecer_prompt("cidade à noite")
169
+ verifica("Teorema 17.3: NLG enriquece prompt determinístico",
170
+ p_enr.startswith("cidade à noite") and len(p_enr) > len("cidade à noite"))
171
+
172
+
173
+ def testa_agente_engenheiro():
174
+ print("== Agente Engenheiro (doc 16 §9) ==")
175
+ from aurora.qualidade import AgenteEngenheiro
176
+ ag = AgenteEngenheiro(
177
+ dir_telemetria="/home/z/my-project/aurora/telemetria_out")
178
+ r = ag.auditar_antes("arquivo limpo",
179
+ ["src/aurora/percepcao/atencao_moe.py"])
180
+ verifica("revisão pré-modificação: arquivo limpo aprovado", r["aprovado"])
181
+ # regressão de capacidade (Teorema 16.10)
182
+ g = ag.garantir_nao_regressao(
183
+ {"ppl_valid": 500.0, "coerencia": 0.5},
184
+ {"ppl_valid": 600.0, "coerencia": 0.5}) # ppl +20% = regressão
185
+ verifica("Teorema 16.10: regressão de ppl BLOQUEIA", not g["aprovado"])
186
+ g2 = ag.garantir_nao_regressao(
187
+ {"ppl_valid": 600.0, "coerencia": 0.5},
188
+ {"ppl_valid": 500.0, "coerencia": 0.52}) # melhora
189
+ verifica("Teorema 16.10: melhora é APROVADA", g2["aprovado"])
190
+ # observação integral (modelo multimodal + forward com coleta de gates)
191
+ from aurora.nucleo.modelo import AURORAModel
192
+ from aurora.memoria.orquestrador import OrquestradorSOM
193
+ cfg = Config()
194
+ m = AURORAModel(cfg, usar_multimodal=True)
195
+ o = OrquestradorSOM(cfg.modelo.d_modelo, cfg.som,
196
+ cfg_atencao=vars(cfg.som_atencao))
197
+ ids = torch.randint(4, cfg.modelo.vocab, (2, 16))
198
+ coletar = {}
199
+ m.eval()
200
+ with torch.no_grad():
201
+ m(ids, alvo=ids, coletar=coletar)
202
+ m.alinhar_som(ids, orquestrador=o)
203
+ obs = ag.observar_treino(0, m, orquestrador_som=o)
204
+ n_metricas = len([k for k in obs if not k.startswith("erro")])
205
+ verifica("observação: ≥60 métricas fundamentais coletadas",
206
+ n_metricas >= 60, f"n={n_metricas}")
207
+ tem_som = any(k.startswith("ativos/") for k in obs)
208
+ tem_moe = any("moe" in k for k in obs)
209
+ tem_quanta = any(k.startswith("quanta/") for k in obs)
210
+ verifica("métricas por módulo: SOM ✓ MoE ✓ quantização ✓",
211
+ tem_som and tem_moe and tem_quanta)
212
+ rel = ag.relatorio(orquestrador_som=o)
213
+ verifica("relatório consolidado gravado", rel["tolerancia_regressao"] == 0.05)
214
+
215
+
216
+ def testa_checkpoints():
217
+ print("== Checkpoints locais + snapshot único (doc 16 §8) ==")
218
+ import os
219
+ import shutil
220
+ from aurora.dados.checkpoints import GestorCheckpoints
221
+ from aurora.nucleo.modelo import AURORAModel
222
+ dir_teste = "/home/z/my-project/aurora/estados_local_teste"
223
+ if os.path.exists(dir_teste):
224
+ shutil.rmtree(dir_teste)
225
+ from aurora.config import Config as C
226
+ gestor = GestorCheckpoints(dir_local=dir_teste)
227
+ m1 = AURORAModel(C(), usar_multimodal=False)
228
+ caminho = gestor.salvar(m1, "epoca-001", {"passo_global": 10})
229
+ verifica("checkpoint salvo (safetensors+meta+hash)", os.path.exists(caminho))
230
+ m2 = AURORAModel(C(), usar_multimodal=False)
231
+ ok = gestor.carregar(m2, "epoca-001")
232
+ igual = ok and all(torch.equal(a, b) for a, b in zip(
233
+ m1.state_dict().values(), m2.state_dict().values()))
234
+ verifica("Teorema 16.9: retomada EXATA (hash SHA-256)", igual)
235
+ gestor.salvar(m1, "epoca-002", {"passo_global": 20})
236
+ verifica("higiene: só o ÚLTIMO checkpoint fica em disco",
237
+ gestor.ultima_tag() == "epoca-002"
238
+ and len(os.listdir(dir_teste)) == 1)
239
+ stage = "/home/z/my-project/aurora/stage_teste"
240
+ if os.path.exists(stage):
241
+ shutil.rmtree(stage)
242
+ p = gestor.preparar_para_publicacao(stage)
243
+ verifica("snapshot único p/ commit único (estados/fase-v5)",
244
+ p is not None and os.path.exists(os.path.join(
245
+ stage, "estados", "fase-v5", "meta.json")))
246
+ shutil.rmtree(dir_teste, ignore_errors=True)
247
+ shutil.rmtree(stage, ignore_errors=True)
248
+
249
+
250
+ def main():
251
+ t0 = time.time()
252
+ print("=== AURORA v5 — testes (docs 16–17) ===")
253
+ testa_atencao_entre_moes()
254
+ testa_atencao_entre_variantes_som()
255
+ testa_quantizacao_real()
256
+ testa_difusao()
257
+ testa_agente_engenheiro()
258
+ testa_checkpoints()
259
+ dt = time.time() - t0
260
+ print(f"\nresultado: {_RESULT['ok']} ✓ · {_RESULT['falhas']} ✗ · {dt:.1f}s")
261
+ if _RESULT["falhas"]:
262
+ sys.exit(1)
263
+
264
+
265
+ if __name__ == "__main__":
266
+ main()