Investigação
Helix, parte 1: treinar um modelo de linguagem europeu
Estamos a treinar o nosso próprio modelo de linguagem. É pequeno – 320 milhões de parâmetros –, mas lê as 24 línguas oficiais da União Europeia e treina em placas gráficas feitas para jogos. Esta primeira parte conta como chegámos aqui; a segunda chega quando o treino terminar.
Porque é que um estúdio de jogos treina um modelo de linguagem
A NETBYTE cria jogos, aplicações e sites. Cada vez mais, estes produtos trazem modelos de linguagem lá dentro: personagens que respondem, ajuda que percebe uma pergunta, ferramentas que fazem alguma coisa. A maioria dos modelos abertos pensa primeiro em inglês; o estónio, o irlandês ou o maltês vêm depois. Queríamos perceber toda a cadeia por nós próprios – dados, tokenizador, arquitetura, treino – e descobrir para onde vai realmente o dinheiro.
- parâmetros
- 320 M
- línguas oficiais da UE
- 24
- tokens de treino
- 6,5 mil M
- pelas GPU alugadas
- ≈ 12 US$
O Helix nasceu como protótipo de investigação. Tudo o que se segue é uma decisão que o moldou, cada uma apoiada numa medição – e os erros que mais tempo nos custaram.
Quatro ideias, uma sobrevivente
O protótipo atacava quatro fraquezas conhecidas dos geradores de texto atuais. Escreve em blocos de 16 tokens em vez de um token de cada vez, pode percorrer várias vezes um núcleo partilhado de camadas, prevê um «plano» compacto para cada bloco e combina atenção local barata com atenção linear para longas distâncias.
A escrita por blocos funcionou à primeira: um pequeno modelo de teste escreveu 64 tokens em 13 passagens pela rede, quando um modelo convencional precisa de uma passagem por token – cerca de um quinto do trabalho. As outras três ideias falharam um teste mais duro. Construímos tarefas em que a resposta está muito para lá da janela local, de modo que o modelo tem de olhar para trás em todo o texto.
Mostrar os dados
| Variante | Certas |
|---|---|
| Só janela local | 23,1% |
| + atenção linear, plano e ciclos | 23,1% |
| + 2 cabeças globais exatas | 49,4% |
| Atenção completa (controlo) | 49,0% |
| Acaso (25 %) | 25,0% |
Só a atenção exata em toda a distância as resolveu. Atenção linear, plano e ciclos ficaram ao nível do acaso; o otimizador chegou a reduzir a memória linear a uma meia-vida inferior a um token. Duas cabeças globais exatas bastaram para igualar a atenção completa.
Por isso, o modelo final mantém em cada camada oito cabeças locais com uma janela de 256 tokens e acrescenta duas cabeças globais exatas em cada segunda camada; as camadas intermédias mantêm duas cabeças de atenção linear com porta. Plano e ciclos estão desligados. Continuam no código e estão testados, mas em texto real não compensaram o custo.
- Local, janela de 256 tokens
- Atenção global exata
- Atenção linear com porta
Mostrar os dados
| Tipo de cabeça | Camadas | Cabeças por camada |
|---|---|---|
| Local, janela de 256 tokens | 1–12 | 8 |
| Atenção global exata | 1, 3, 5, 7, 9, 11 | 2 |
| Atenção linear com porta | 2, 4, 6, 8, 10, 12 | 2 |
Medir, não supor
Testámos cada truque de treino num modelo de 94 milhões de parâmetros com o mesmo orçamento por execução: 29,5 milhões de tokens, a mesma semente, a mesma ordem dos dados. Duas execuções da mesma configuração diferem em ±0,03, por isso tudo o que for menor é ruído.
Mostrar os dados
| Alteração | Δ perda (nats) |
|---|---|
| Muon + calendário WSD | -0,587 |
| Otimizador Muon | -0,347 |
| Rede mais profunda e estreita | -0,099 |
| Calendário WSD | -0,080 |
| Residual de valores | -0,007 |
| z-loss | +0,029 |
| Atenção com consultas agrupadas | +0,088 |
O otimizador Muon foi a única grande alavanca, e combina-se com um calendário de taxa de aprendizagem warmup-stable-decay. Devolver o embedding e a camada de saída ao AdamW, como recomendam os autores do Muon, trouxe mais 0,12 e tornou o treino 5 % mais rápido. As combinações não se somam simplesmente: uma rede mais profunda e estreita ajudava com AdamW e prejudicava com Muon. Por isso, cada combinação promissora teve a sua própria execução.
24 línguas, 6,5 mil milhões de tokens
O Helix lê texto da web do FineWeb-Edu para o inglês e do FineWeb-2 para as outras 23 línguas – nas maiores, da sua décima parte superior filtrada por qualidade. Código, matemática e um pequeno fluxo de chat sintético completam a mistura. O inglês recebe um terço. As outras línguas são ponderadas pela quantidade de texto que existe, suavizada para que o irlandês e o maltês não fiquem afogados, e nenhuma fonte se repete mais de quatro vezes – até aí, repetir vale quase tanto como dados novos.
Mostrar os dados
| Fonte | Percentagem |
|---|---|
| Outras 23 línguas da UE | 51,6% |
| Inglês | 33,0% |
| Código e marcação | 10,0% |
| Matemática | 3,0% |
| Chat e ferramentas sintéticos | 2,4% |
O fluxo de chat é extrativo: as respostas são copiadas de parágrafos reais e os resultados das ferramentas são calculados em vez de inventados. Ensina formato, não conhecimento. O tokenizador é um BPE ao nível do byte com 64 000 entradas; coloca entre 3,3 e 4 bytes de texto num token em todas as línguas de escrita latina.
Três erros que vale a pena contar
- O modelo que lia a resposta. Num caminho do código, as cabeças globais ignoravam a máscara causal e conseguiam ver tokens futuros. A perda caiu de 6,85 para 1,71 em 75 passos, e uma execução de 16 horas ficou sem valor. Uma perda suspeitamente boa é um relatório de erro; agora um teste de regressão vigia exatamente isto.
- Caracteres não são bytes. A compressão era contada em caracteres em vez de bytes UTF-8. Isso inventava uma «fraqueza» no chinês e fazia o grego e o búlgaro parecerem quase duas vezes piores do que são.
- Documentos partidos em cada linha vazia. O codificador separava os documentos em cada linha vazia – e há linhas vazias a meio de quase todos os ficheiros de código. Perdeu-se até 35 % do texto de código e de matemática. Corrigimos o separador e reconstruímos todo o corpus a 31 de outubro; demorou 2 horas e 12 minutos.
Da secretária para uma máquina alugada
Os primeiros 1,66 mil milhões de tokens correram numa única AMD Radeon RX 7800 XT. Duas coisas tornaram isso viável: uma opção do kernel de atenção que vem desligada – sem ela, a atenção era 12 vezes mais lenta – e compilar cada camada com torch.compile. Com uma mediana de 11 800 tokens por segundo, o resto teria demorado quase mais cinco dias.
Por isso escrevemos um piloto automático. Aluga GPU no Vast.ai, envia código, corpus e checkpoint, treina, traz um checkpoint para casa a cada três horas e para antes de o saldo acabar. A 2 de novembro passou por três máquinas que os fornecedores nunca chegaram a arrancar e depois ficou com duas RTX 4070 Ti Super na Alemanha por 0,363 US$ à hora. O envio de 15,4 GiB demorou 40 minutos.
Mostrar os dados
| Configuração | Tokens/s |
|---|---|
| Local, antes da otimização | 8319 |
| Local, compilado | 11 830 |
| Alugado, 2 GPU | 41 367 |
41 400 tokens por segundo são 3,5 vezes a secretária. A parte alugada – 4,8 mil milhões de tokens em cerca de 33 horas – custa à volta de 12 US$.
Onde está o Helix hoje
- Reservado
- Treino
Perda (nats por token)
Mil milhões de tokens lidos
Mostrar os dados
| Mil milhões de tokens lidos | Reservado | Treino |
|---|---|---|
| 0,06 | 4,571 | 4,261 |
| 0,55 | 3,776 | 3,574 |
| 1,04 | 3,694 | 3,469 |
| 1,54 | 3,596 | 3,421 |
| 2,03 | 3,426 | 3,238 |
| 2,52 | 3,329 | 3,143 |
| 3,01 | 3,291 | 3,113 |
| 3,50 | 3,263 | 3,076 |
| 3,99 | 3,225 | 3,079 |
| 4,49 | 3,244 | 3,076 |
| 4,98 | 3,218 | 3,036 |
| 5,35 | 3,123 | 2,884 |
A 3 de novembro de 2026, o Helix já leu 5,35 dos seus 6,5 mil milhões de tokens. Desde os 5,2 mil milhões está na fase de arrefecimento: a taxa de aprendizagem desce e a mistura desloca-se para matemática, código e chat. Em texto reservado de todos os fluxos, está em 3,12 nats por token.
Mostrar os dados
| Língua | Bits por byte |
|---|---|
| grego | 0,721 |
| búlgaro | 0,844 |
| francês | 1,065 |
| inglês | 1,086 |
| espanhol | 1,135 |
| português | 1,219 |
| alemão | 1,257 |
| neerlandês | 1,268 |
| italiano | 1,277 |
| polaco | 1,355 |
| dinamarquês | 1,364 |
| húngaro | 1,407 |
| eslovaco | 1,412 |
| maltês | 1,415 |
| romeno | 1,416 |
| sueco | 1,418 |
| irlandês | 1,422 |
| esloveno | 1,431 |
| checo | 1,444 |
| lituano | 1,450 |
| letão | 1,451 |
| croata | 1,507 |
| finlandês | 1,508 |
| estónio | 1,727 |
O que isso significa na prática vê-se melhor numa amostra não editada de um checkpoint com cerca de 4,9 mil milhões de tokens. O início é nosso, o resto é do Helix:
Início: The history of the printing press begins in the fifteenth century, when Johannes Gutenberg introduced movable type to Europe. Before that, books
Resposta do modelo: for printing were usually in the form of texts, usually in the format of illustrations. In its introduction to the printing press, Gutenberg uses one line-of-action model to illustrate a series of printed pieces of a book.
A gramática, a escolha das palavras e o tema aguentam-se; os factos, não. É mais ou menos o que se pode esperar de 320 milhões de parâmetros e 6,5 mil milhões de tokens: um modelo fluente que inventa coisas.
O que vem a seguir
O pré-treino termina dentro de poucas horas. Seguem-se uma fase de contexto longo com livros do Project Gutenberg e textos jurídicos europeus do EUR-Lex, um ajuste fino para conversação e uso de ferramentas, e um pequeno modelo de rascunho que acelera a geração.