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 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.
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).
| 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.
| 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.
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.
crates/germen-core a biblioteca: config, model, tokenizer, bpe, data, train, gradients,
generate, checkpoint, bench
crates/germen-cli a linha de comando `germen` (clap)
flex do Burn: Rust puro, produtos de matrizes pelo crate gemm, kernels SIMD
(AVX2/AVX-512/SSE, NEON) escolhidos em tempo de execução, multithreading com rayon. Um
executável x86-64 genérico usa, portanto, AVX2 numa CPU que o tenha.1/√(2·camadas)). O treino usa uma atenção causal em blocos que nunca calcula a parte acima
da diagonal (passos inteiros 8 a 28 % mais rápidos em dois núcleos, conforme o tamanho do modelo;
mesmos valores e mesmos gradientes); a avaliação usa o kernel fundido do Burn, e a geração um
cache de chave/valor.Event) para que uma
interface gráfica possa reutilizar o mesmo laço.mini, até + 25 % para o
nano, em dois núcleos). Repartir micro-lotes entre várias threads que conduzem o Burn ao mesmo
tempo foi tentado e descartado; veja docs/PLAN.md.config.json, weights.bpk (o formato burnpack do Burn, f32),
optimizer.bpk (os momentos do AdamW), tokenizer.json e meta.json. Os checkpoints escritos
pela versão 0.1 continuam carregando.demo é sintético e minúsculo: prova que a cadeia aprende, nada mais.Veja CHANGELOG.md e docs/PLAN.md. Contribuições são bem-vindas (CONTRIBUTING.md).
MIT — veja LICENSE. Copyright © 2026 Alexandru-Ionuț Chiuță (Alexio).