GERMEN

Treine do zero um pequeno modelo de linguagem, em Rust puro, numa CPU comum.

Sem Python, sem CUDA, sem toolchain de C ou C++, sem conta, sem acesso à rede, sem telemetria. Um único executável, um arquivo de texto, um comando. Construído sobre o Burn 0.22 com o seu backend de CPU flex, escrito inteiramente em Rust.

Idiomas: English · Română · Français · Italiano · Español · Português · Deutsch · Magyar

O que é — e o que não é

O GERMEN treina uma rede do tipo GPT (RMSNorm, posições rotativas, camada feed-forward com ReLU ao quadrado, sem vieses) sobre tokens. Por padrão, um token é um byte: o vocabulário são os 256 valores de um byte, de modo que qualquer texto — inclusive com os diacríticos romenos — funciona sem preparar nada. Com --tokenizer bpe, o GERMEN aprende primeiro, a partir do seu próprio texto, um vocabulário BPE em nível de byte (até 65.536 tokens); a mesma janela de contexto passa a conter várias vezes mais texto (tipicamente de 3 a 4 vezes em prosa comum). O tokenizador é salvo junto com o modelo.

É uma oficina para aprender e experimentar, e uma base para pesquisa: em poucos minutos dá para ver uma rede passar do ruído aleatório à ortografia, à pontuação e ao estilo do seu texto. Não é uma fábrica de chatbots. Um modelo de 1 a 25 milhões de parâmetros, treinado com algumas centenas de megabytes, aprende a forma de um texto (palavras, fragmentos de gramática, diagramação), não conhecimento do mundo nem conversação. Assistentes úteis exigem ordens de grandeza mais computação do que uma CPU de mesa oferece.

Início rápido

Você precisa do Rust 1.95 ou mais recente (rustup.rs; no Windows a instalação também pede as Visual Studio Build Tools). Depois:

cargo build --release
./target/release/germen bench                      # qual é a velocidade DESTE computador?
./target/release/germen bench --scaling            # ...e como ela cresce com o número de threads?
./target/release/germen train --demo --preset micro --steps 300
./target/release/germen generate                   # texto do modelo recém-treinado

No Windows, use target\release\germen.exe. Os executáveis já compilados são anexados às versões (releases).

Treine com o seu próprio texto — qualquer arquivo, em qualquer idioma:

germen train --data meu-corpus.txt --preset mini --tokenizer bpe --vocab 4096 --steps 5000 --out meu-modelo
germen generate --model meu-modelo --prompt "Era odată " --max-new 400

Pressione Ctrl-C durante o treino: ele termina o passo atual, salva e sai. Retome mais tarde com o mesmo comando mais --resume: os pesos, o contador de passos e o estado do AdamW são restaurados, de modo que o treino segue sem o salto da perda de uma reinicialização a frio (as janelas de texto são sorteadas de novo).

Comandos

comando o que faz
germen info processadores e nível SIMD detectados, tamanhos de modelo e memória dos pesos
germen bench cronometra passos de treino reais para cada tamanho e extrapola o tempo para 100 M e 1 bilhão de tokens; --scaling repete a medição com 1, 2, 4, … threads e mostra a curva de aceleração; --json ARQUIVO salva os números
germen demo-corpus escreve um corpus romeno sintético gerado a partir de uma gramática pequena (--size-mb)
germen train treina do zero (--data ARQUIVO ou --demo), ou continua com --resume
germen generate gera texto a partir de um modelo treinado, com um cache de chave/valor (--temperature, --top-k, --prompt)

Opções de treino que vale conhecer: --tokenizer byte|bpe e --vocab N (o tamanho do BPE); --batch e --accum (acúmulo de gradientes: o lote efetivo é o produto dos dois, a memória é a de --batch sozinho); --grad-clip (norma global do gradiente, 1 por padrão); --lr, --warmup, --weight-decay. germen train --help lista todas. Acrescente --threads N a qualquer comando para limitar o número de threads de trabalho (o padrão é todos os processadores lógicos). As mensagens da linha de comando estão, por enquanto, apenas em romeno.

Tamanhos de modelo

nome parâmetros camadas × cabeças × largura pesos (f32)
nano 0,85 M 4 × 4 × 128 3 MiB
micro 2,76 M 6 × 6 × 192 11 MiB
mini 10,82 M 6 × 6 × 384 41 MiB
small 25,44 M 8 × 8 × 512 97 MiB
base 85,35 M 12 × 12 × 768 326 MiB

Os tamanhos valem para o vocabulário de 256 bytes; um vocabulário BPE de V tokens acrescenta 2·(V − 256)·largura parâmetros (embedding e cabeça de saída). O treino também guarda as duas estimativas de momento do AdamW (≈ 4× os pesos) e as ativações, que crescem com --batch e --seq.

Quanto tempo leva?

O custo do treino é de cerca de 6 × parâmetros × tokens operações em ponto flutuante (com bytes, 1 MB de texto = 1 milhão de tokens). Divida pelo que a sua CPU realmente entrega e você tem o tempo. O germen bench mede exatamente isso na sua máquina.

Medição de referência — uma pequena máquina virtual Linux com 2 núcleos (AVX-512), lote 16 × 256, vocabulário de bytes (uma única execução numa máquina virtual ruidosa, portanto ± 5 %):

nome tokens/s GFLOPS efetivos 100 M tokens 1 bi de tokens
nano 8.261 54 3,4 h 1,4 dia
micro 3.180 63 8,7 h 3,6 dias
mini 1.260 90 22,0 h 9,2 dias
small 545 90 2,1 dias 21 dias

Passar de 1 para 2 threads deixou o mini 1,51× mais rápido aqui (825 → 1.247 tokens/s); portanto não espere que 20 núcleos deem 20×. Os produtos de matrizes escalam bem (≈ 1,8× com duas threads); a atenção menos (≈ 1,2×), e o RMSNorm, os embeddings rotativos e a atualização do AdamW quase nada, de modo que, numa máquina com muitos núcleos, eles viram o gargalo (lei de Amdahl). É para isso que existe o germen bench --scaling: ele mostra a curva inteira e o número de threads a partir do qual nada mais se ganha. Rode germen bench --scaling --json bench.json na sua máquina — é a única forma de saber. Uma regra empírica para o treino ótimo em computação é de cerca de 20 tokens por parâmetro; os modelos pequenos costumam ser treinados com bem mais.

A geração usa um cache de chave/valor: 400 tokens com o mini levam cerca de 1 segundo em vez de 15 nos mesmos dois núcleos.

Como é construído

crates/germen-core   a biblioteca: config, model, tokenizer, bpe, data, train, gradients,
                     generate, checkpoint, bench
crates/germen-cli    a linha de comando `germen` (clap)

Limites (versão 0.2)

Veja CHANGELOG.md e docs/PLAN.md. Contribuições são bem-vindas (CONTRIBUTING.md).

Licença

MIT — veja LICENSE. Copyright © 2026 Alexandru-Ionuț Chiuță (Alexio).