Hugging Face's logo

PowerMachine
/
CNN-BiGRU

Model card Files
xet
 Community
CNN-BiGRU / cnn_bigru /README.md
PowerMachine's picture
PowerMachine
v3.0: reorganiza arquivos sob cnn_bigru/ (preserva árvore de pastas)
49b8205 verified
preview code
|
Raw History Blame Contribute Delete
12.3 kB

CNN-BiGRU — Modelo Multimodal Cooperativo Autoaprendível (v2.0)

Implementação completa de um LLM multimodal com arquitetura CNN-BiGRU cooperativa, inspirada nos projetos de referência:

  • PowerMachine/gru-ring-v13-9-2/xavante_work/
  • PowerMachine/BiGRU_T_version/src/bigru_t/
  • dados.txt (pseudocódigo matemático completo)

O projeto é diferente dos anteriores: agrupa todos os componentes multimodais (texto + imagem + áudio) num único pipeline cooperativo, com divisão por competências.

Novidades v2.0

Esta versão adiciona os módulos faltantes identificados na análise matemática (docs/MATH_ANALYSIS.md):

Novos Módulos

Módulo Função Arquivo
EWC (Elastic Weight Consolidation) Aprendizado contínuo sem catastrophic forgetting via matriz de Fisher utils/ewc.py
Context Window Janela deslizante com cache KV para sequências longas (Sink+Sliding / StreamingLLM) models/context_window.py
RoPE (Rotary Position Embeddings) Codificação posicional rotacional (atenção relativa) models/rope.py
TransformerBlock CausalSelfAttention + FFN com Pre-LN (decoder-only, estilo GPT) models/transformer_block.py

Bug Fixes Críticos

  • cooperative_bigru.py: SelfAttentionSummary agora é uma self-attention TRUE (CLS-token + multi-head + learned Q/K/V), não mais mean-pool.
  • hypothesis_controller.py: gate logic corrigido — x_proj agora é uma projeção LINEAR REAL do input (não mais combined, o que tornava o gate inefetivo).
  • generator_verifier.py: enc_out agora usa a sequência temporal REAL do encoder (não mais fused.unsqueeze(1).expand(...) que repetia o mesmo vetor).
  • trainer.py: verificador REALMENTE chamado (não proxy); saída da hipótese REALMENTE usada (não só flag); EWC integrado à perda total.
  • losses.py: todos os torch.tensor(0.0) agora usam device= correto.
  • auto_learner.py: _spec_u registrado como buffer (migra com .to(device)); l2_reg adicionado ao AutoLearnConfig; estimate_curvature agora usa try/finally.
  • inference.py: geração autoregressiva REAL via GeneratorCNNBiGRU (não single-step).
  • streaming_dataset.py: synthetic fallback agora é ALCANÇÁVEL quando HF falha silenciosamente; token HF é limpo após uso.
  • multimodal_model.py: attn_mask_a/attn_mask_b agora são usados; weight tying opcional.

Características Principais

1. Arquitetura Cooperativa de 3 Níveis (do dados.txt)

Nível Mecanismo Descrição
1 Cross-Attention Global Ponte de cooperação pós-CNN entre redes A e B, com máscaras de padding
2 Célula GRU Cooperativa Passo-a-Passo CellStepCooperativaComAtenuacao com porta Gated (alfa ∈ [0,1])
3 Self-Attention Final + Fusão Self-attention TRUE (CLS-token) + concatenação (128+128=256)

2. Multimodal (Texto + Imagem + Áudio)

  • Texto: Dual-stream CNN-BiGRU cooperativo (streams A e B)
  • Imagem: ImageEncoder (CNN 2D → flatten → projeção)
  • Áudio: AudioEncoder (CNN 1D sobre espectrograma)
  • Fusão: MultimodalFusion com gated fusion por modalidade

3. Autoaprendizado (parâmetros matematicamente ajustados)

Conforme dados.txt seções 9-10:

  • Ajuste Dinâmico de LR:
    • fator_G = exp(-κ * ||grad_G||) * (1 + v_media) / 2
    • fator_V = exp(-κ * ||grad_V||) / (1 + L_V_media)
  • Controle de Gradiente: clipping L2 + spectral normalization (power iteration, buffer registrado)
  • Inicialização Ortogonal: matrizes recorrentes e convolucionais (com log de fallback)
  • Estimativa de Curvatura: aproximação por diferenças finas (com try/finally)

4. EWC (Elastic Weight Consolidation) — NOVO v2.0

  • Cálculo da diagonal da Matriz de Fisher (empirical Fisher)
  • Online EWC: $F^{\text{agg}} = \gamma F^{\text{prev}} + (1-\gamma) F^{\text{new}}$
  • Penalidade diferenciável: $L_{\text{EWC}} = \sum_i \frac{\lambda}{2} F_i (\theta_i - \theta_i^*)^2$
  • Integração à perda total: $L_{\text{total}} = \alpha L_G + \beta L_V + \gamma L_{AH} + \delta L_{\text{reg}} + L_{\text{EWC}}$

5. Context Window — NOVO v2.0

  • Cache KV para CausalSelfAttention (speedup ~T× em inferência)
  • Sliding Window + Sink (StreamingLLM): mantém $k$ tokens iniciais + últimos $L_{\max}-k$
  • Estratégias: sliding, sink_sliding (default), recompute
  • Integração com inferência: generate_with_sampling(context_window=cw)

6. RoPE (Rotary Position Embeddings) — NOVO v2.0

  • Codificação posicional rotacional: $\theta_i = 10000^{-2i/d}$
  • Propriedade relacional: $\langle \text{RoPE}(q, m), \text{RoPE}(k, n) \rangle = \langle \text{RoPE}(q, m-n), k \rangle$
  • Cache de frequências como buffer (migra com .to(device))
  • Extensão dinâmica para sequências longas

7. TransformerBlock (Decoder-Only) — NOVO v2.0

  • CausalSelfAttention: multi-head, máscara triangular inferior, QKV unificada
  • TransformerBlock: Pre-LN + residual + FFN (Linear → GELU → Linear)
  • TransformerDecoderStack: N camadas + LayerNorm final + LM head
  • Weight tying opcional (compartilha embedding ↔ lm_head)
  • Suporte a cache KV multicamada para geração autoregressiva

8. Mecanismo de Hipóteses (ativado em punições)

Quando o verificador pune um passo (v < threshold), ativa:

  • N hipóteses paralelas com transforms lineares diferentes
  • Seleção via Gumbel-Softmax (diferenciável)
  • Porta de ativação baseada em v — CORRIGIDA v2.0: agora a saída das hipóteses é REALMENTE usada (interpolação gate * combined + (1-gate) * x_proj)

9. Synergy Search (N tentativas de acerto)

No início de cada época, busca N combinações de hiperparâmetros (pesos das perdas) e seleciona a configuração de menor perda.

10. Múltiplas Funções de Perda

Conforme dados.txt seção 8:

L_total = α * L_G_total + β * L_V + γ * L_AH + δ * L_reg + L_EWC
L_G_total = L_G + λ * L_penal_linear + μ * L_penal_exp
L_penal_linear = Σ (1 - v_t)                              (todos os passos)
L_penal_exp = Σ_{v_t < threshold} exp(γ * (1 - v_t))      (apenas graves)
L_V = BCE(v_t, rotulo_real)
L_AH = Σ (1 - τ_t)                    (anti-alucinação fuzzy)
L_reg = L2 + curvatura
L_EWC = Σ (λ/2) * F * (θ - θ*)²       [NOVO v2.0]

11. Camada Anti-Alucinação (Lógica Fuzzy de Łukasiewicz) 

NOT(x)  = 1 - sigmoid(x)
AND(x,y) = relu(sigmoid(x) + sigmoid(y) - 1)
OR(x,y)  = min(1, sigmoid(x) + sigmoid(y))
IMP(x,y) = min(1, 1 - sigmoid(x) + sigmoid(y))

12. Inferência Avançada

  • Temperatura, Top-K, Top-P (Nucleus Sampling)
  • Presence Penalty, Frequency Penalty
  • Geração autoregressiva REAL via GeneratorCNNBiGRU (v2.0)
  • Cache KV opcional via ContextWindowManager (v2.0)
  • Avaliação de Perplexidade (PPL) com generator real

Estrutura por Competências 

cnn_bigru/
├── tokenizer/              # Competência: tokenização
│   └── bbpe_tokenizer.py   # BBPE byte-level tokenizer
├── utils/                  # Competência: utilitários
│   ├── xeon_runtime.py     # Ativação Intel Xeon (AVX512+AMX+IPEX)
│   ├── memory_optimizer.py # Otimização de memória (AMP, GC, offload)
│   ├── semantic_embeddings.py  # Embeddings semânticos (Sinkhorn OT + IB)
│   └── ewc.py              # NOVO v2.0: Elastic Weight Consolidation
├── data/                   # Competência: carregamento de dados
│   └── streaming_dataset.py # Dataset streaming multimodal (com fallback)
├── models/                 # Competência: modelos neurais
│   ├── cooperative_bigru.py    # Núcleo CNN-BiGRU cooperativo (self-attn TRUE)
│   ├── multimodal_encoders.py  # Encoders de imagem/áudio + fusão
│   ├── multimodal_model.py     # Modelo multimodal completo (weight tying opc.)
│   ├── generator_verifier.py   # Gerador + Verificador + Anti-alucinação
│   ├── rope.py                 # NOVO v2.0: Rotary Position Embeddings
│   ├── transformer_block.py    # NOVO v2.0: CausalSelfAttention + TransformerBlock
│   └── context_window.py       # NOVO v2.0: Sliding window + KV cache
├── losses/                 # Competência: funções de perda
│   └── losses.py           # Multi-loss + EWC penalty (device-safe)
├── training/               # Competência: treinamento
│   ├── auto_learner.py         # Ajuste dinâmico LR + spectral norm (buffer)
│   ├── hypothesis_controller.py # Hipóteses + synergy search (gate fix)
│   └── trainer.py              # Loop cooperativo + EWC + verificador real
├── inference/              # Competência: inferência
│   └── inference.py        # Sampling + PPL + generator real + context window
├── tests/                  # Competência: testes
│   └── test_50_samples.py  # Teste de 50 amostras (com novos módulos v2.0)
├── scripts/                # Competência: scripts auxiliares
│   └── push_to_hf.py       # Upload ao HF (upload_folder + retry)
├── docs/                   # Competência: documentação
│   └── MATH_ANALYSIS.md    # NOVO v2.0: análise matemática de EWC + Context Window
└── requirements.txt

Como Executar

Requisitos 

pip install torch tokenizers huggingface_hub datasets psutil tqdm numpy

Teste de 50 Amostras (com novos módulos v2.0) 

python -m cnn_bigru.tests.test_50_samples

O teste executa:

  1. Ativação do runtime Xeon
  2. Treino do BBPE tokenizer
  3. Criação do dataset streaming (50 amostras)
  4. Instanciação dos modelos
  5. Teste isolado dos novos módulos v2.0:
    • EWC (Fisher, consolidate, penalty)
    • Context Window (cache KV, eviction)
    • RoPE (preservação de norma)
    • TransformerBlock (forward, cache, weight tying) 5'. Treinamento cooperativo com EWC + synergy + hipóteses + auto-learn
  6. Inferência com generator + context window
  7. Avaliação de perplexidade com generator
  8. Relatório de erros lógicos ou falhas

Resultado Esperado 

✓ NENHUM ERRO CRÍTICO encontrado
Amostras processadas: 50
Synergy attempts: 3
Hypothesis activations: variável
EWC active: True
Context Window active: True
Used generator for inference: True
STATUS: SUCESSO

Análise Matemática

A inclusão de EWC e Context Window foi analisada matematicamente em docs/MATH_ANALYSIS.md, cobrendo:

  1. EWC: formulação da Fisher Information, integração na perda, garantia de Laplace
  2. Context Window: complexidade computacional, políticas de evicção (sliding, sink+sliding, recompute)
  3. Demais elementos faltantes: RoPE, CausalSelfAttention, Self-Attention final, etc.

Referências

  • dados.txt (arquivo de entrada com pseudocódigo completo)
  • huggingface.co/PowerMachine/gru-ring-v13-9-2/tree/main/xavante_work/
  • huggingface.co/PowerMachine/BiGRU_T_version/blob/main/src/bigru_t/tokenizer/bbpe_tokenizer.py
  • huggingface.co/PowerMachine/gru-ring-v13-9-2/blob/main/xavante_work/xavante/utils/semantic_embeddings.py
  • huggingface.co/PowerMachine/gru-ring-v13-9-2/blob/main/xavante_work/xavante/utils/memory_optimizer.py
  • huggingface.co/PowerMachine/gru-ring-v13-9-2/tree/main/xavante_work/xavante/training
  • huggingface.co/PowerMachine/BiGRU_T_version/blob/main/src/bigru_t/utils/xeon_runtime.py
  • huggingface.co/PowerMachine/gru-ring-v13-9-2/blob/main/xavante_work/flexnet/streaming_datasets_v13_9.py

Notas de Segurança

  • HF_TOKEN: usado apenas para push inicial ao repositório. Após o push, o token é removido do ambiente e dos scripts. Os scripts publicados não contêm nenhum token embutido.
  • Exceções: todos os módulos usam try/except com logging adequado para garantir robustez. O treinamento continua mesmo se alguns batches falharem.
  • Curvatura: estimate_curvature agora usa try/finally para garantir restauração dos parâmetros mesmo em caso de exceção.

Licença

MIT