mente

Sistema experimental de modelamento de linguagem baseado em camadas hierárquicas com memória, simplificação por repouso e crescimento dinâmico.

A especificação teórica completa está em SISTEMA.md.

Conceitos

O sistema funciona como um "bebê" que aprende do zero. Começa sem nenhum conhecimento e constrói sua compreensão a partir de cada frase que recebe.

Camadas

A informação é organizada em camadas hierárquicas. A camada 0 é a mais profunda e abstrata — guarda um único valor de "verdade". As camadas acima são progressivamente mais detalhadas:

[3] superfície   8 params, até 9 ideias    ← input entra aqui
[2]              4 params, até 4 ideias
[1]              2 params, até 1 ideia
[0] profunda     1 param,  até 1 ideia     ← "verdade" do sistema

Cada camada tem 2^n parâmetros reais e armazena no máximo max(1, n²) ideias.

Ideias

Uma ideia é uma sequência de tokens (caracteres) armazenada numa camada, com valores associados nos parâmetros dessa camada. Ideias podem ser:

• naturais: vêm diretamente do input do usuário
• artificiais: criadas pelo sistema durante o repouso ao fundir ideias similares

Processamento

Quando você digita uma frase:

1. A frase é tokenizada (cada caractere = 1 token)
2. Armazenada na camada da superfície
3. Se ativar ideias suficientes na camada abaixo, propaga para baixo
4. Repete recursivamente até a camada mais profunda que ativar
5. A resposta é gerada por uma rede neural de previsão de tokens

Repouso

Quando o sistema fica ocioso (~3s sem input), entra em repouso:

• Simplifica cada camada fundindo ideias próximas em tokens artificiais
• Retreina o predictor de tokens com os inputs recentes, priorizando padrões das camadas mais profundas

Loucura

O parâmetro loucura (0.0 a 1.0) controla o quão rápido o sistema cresce:

• alta (ex: 0.8): cresce rápido, aceita ideias com pouca fundamentação (criativo/instável)
• baixa (ex: 0.2): cresce devagar, só quando ideias estão muito consolidadas (rígido/estável)

Quando a camada 0 atinge o threshold 1 - loucura, uma nova camada superficial é adicionada automaticamente.

Implementação

Estrutura

src/
├── main.rs         entrada, App state, event loop (crossterm)
├── system.rs       System, Layer, Idea, lógica de processamento/repouso
├── predictor.rs    rede neural FC 2-camadas (ReLU → softmax)
└── ui.rs           TUI com ratatui

Predictor

Rede neural feedforward simples:

• Input: bag-of-characters (512) + estado de ativação das camadas (8×3)
• Hidden: 64 neurônios, ReLU
• Output: distribuição sobre vocabulário (softmax)
• Treino: SGD com cross-entropy, peso proporcional à profundidade das camadas ativadas

Ativação

A ativação de uma ideia por uma frase é a proporção de tokens em comum:

ativação = |tokens_frase ∩ tokens_ideia| / |tokens_ideia|

Uma ideia é ativada se o valor ultrapassar 0.5. A frase desce para a próxima camada se mais de 30% das ideias dessa camada forem ativadas.

Memória

• Superfície: evição LRU (a ideia acessada há mais tempo é removida)
• Camadas profundas: precisam "pensar" (simplificar via clustering) antes de liberar espaço
• Camada 0: nunca substitui — acumula tokens e incrementa o valor de verdade

Uso

Requisitos

• Rust 1.70+
• Terminal com suporte a cores (qualquer terminal moderno)

Compilar e rodar

cargo run                # loucura padrão: 0.5
cargo run -- 0.3         # loucura baixa (conservador)
cargo run -- 0.8         # loucura alta (criativo)

Para build otimizado:

cargo build --release
./target/release/mente 0.5

Interface

┌── Conversação ──────────┬── Camadas ──────────────┐
│                         │ [2] sup. (3/4) p=4      │
│ > oi, tudo bem?         │   [oi, tudo bem?] (0.5) │
│ < asdf...               │ [1] (1/1) p=2           │
│ > como vai?             │   [oi tudo bem como vai] │
│ < jklf...               │ [0] prof. (1/1) p=1     │
│                         │   [oi tudbemcva] (0.15)  │
│                         ├── Info ─────────────────┤
│                         │ loucura:      0.50      │
│                         │ camadas:      3         │
│                         │ vocabulário:  15        │
│                         │ repouso:      não       │
├─────────────────────────┴─────────────────────────┤
│ > _                                               │
└───────────────────────────────────────────────────┘

• Esquerda: histórico de conversação (input > e output <)
• Direita superior: visualização das camadas com ideias e parâmetros
• Direita inferior: informações do sistema em tempo real
• Inferior: campo de entrada

Controles

Tecla	Ação
Enter	Enviar input
Backspace	Apagar caractere
Esc	Sair
Ctrl+C	Sair

Comportamento esperado

O sistema começa sem nenhum conhecimento. As primeiras respostas serão gibberish (texto sem sentido) porque o predictor neural está com pesos aleatórios. Conforme você interage:

1. O vocabulário cresce (novos caracteres são aprendidos)
2. Ideias se acumulam nas camadas
3. Novas camadas são criadas quando a verdade atinge o threshold
4. O predictor é retreinado durante o repouso
5. As respostas gradualmente refletem padrões do input recebido

Esse é um proof of concept — o aprendizado é lento e limitado pelo tokenizador de caracteres e pela rede neural pequena. O objetivo é demonstrar a arquitetura, não competir com LLMs.