DeepSeek e Gemma: Como um Experimento de LLM Híbrido no Kaggle Quebrou a Biblioteca Transformers

Entusiastas montaram um LLM híbrido quase contra as regras: pegaram quatro camadas do modelo Gemma 31B e as incorporaram em uma arquitetura MoE vazia do DeepSeek-V4 sem treinamento adicional. Isso não produziu um concorrente funcional do ChatGPT, mas o processo em si mostrou como você pode quebrar profundamente PyTorch e Transformers em busca de testar uma ideia extrema.

Por que é necessário um híbrido

A ideia nasceu de restrições extremamente rigorosas: dois T4 gratuitos no Kaggle, cerca de 30 GB de RAM e nenhum orçamento para fine-tuning em escala completa. Em vez de treinar, os autores decidiram testar um cenário mais bruto — enxertia estrutural de modelos. Gemma-4-31B serviu como doador, comprimido para formato 4-bit NF4, enquanto um DeepSeek-V4 vazio com seu roteador Mixture-of-Experts serviu como o "esqueleto". A tarefa soava quase como um meme: transplantar pesos de uma arquitetura para outra e ver se a quimera podia ser trazida à vida.

Do ponto de vista de engenharia, o projeto era interessante não pela qualidade das respostas, mas pelo mero fato da compatibilidade. Gemma e DeepSeek têm dimensionalidades diferentes, sua própria lógica de normalização, blocos de atenção diferentes e suas próprias regras para roteamento de tokens entre especialistas. Nos livros didáticos, tais transferências geralmente são classificadas como impossíveis sem projeções intermediárias e treinamento adicional. Os autores conscientemente foram contra essa regra e montaram um experimento para testar a resiliência da biblioteca: o que quebraria primeiro — o modelo, a memória do Kaggle ou a própria pilha do Hugging Face.

Onde tudo quebrou

A primeira falha começou no estágio de carregamento. Transformers se recusou a reconhecer adequadamente o tipo customizado `gemma4`, e depois travou com um erro `dict.to_dict()` porque um dos módulos internos serializou a configuração em um dicionário comum e imediatamente tentou acessá-lo como um objeto. Para prosseguir, os autores registraram manualmente o tipo em `CONFIG_MAPPING` e adicionaram um monkey patch para `GenerationConfig`, que envolve o dicionário em um objeto proxy na hora. Caso contrário, toda a operação teria terminado antes mesmo da quimera ser criada.

Em seguida, a biblioteca tentou inicializar seções vazias do DeepSeek com ruído aleatório chamando `normal_`. Naquele ponto, PyTorch lançou `NotImplementedError`: os pesos doadores foram carregados via bitsandbytes em formato 4-bit e armazenados como `uint8`, enquanto o gerador de distribuição normal funciona com tensores float. O problema foi resolvido da forma mais direta — eles interceptaram `TORCH_INIT_FUNCTIONS["normal_"]` e impediram que a função tocasse em tensores de byte. Não é um conserto bonito, mas um desvio cirúrgico, e sem ele o transplante nem começaria.

A parte mais desagradável foi os especialistas do DeepSeek e a memória. Os blocos MoE foram escondidos não em um `ModuleList` comum, mas dentro de uma classe customizada que não podia ser iterada simplesmente. Além disso, descompactar a camada 31B do Gemma na RAM do Kaggle quase instantaneamente levava a OOM. Para contornar isso, os autores escreveram um "sonar" recursivo que procura as subcamadas necessárias pelos atributos `gate_proj`, `up_proj` e `down_proj`, e transferiram pesos em micro-lotes através da CPU, espalhando os modelos entre duas GPUs e constantemente chamando o coletor de lixo.

"Em aprendizado de máquina, não há muros arquitetônicos impenetráveis."

Como eles costuraram o modelo

O script final reduziu toda a operação a uma sequência de patches duros e cópia de pesos. Para cada uma das quatro camadas, ele selecionava matrizes para se adequar ao tamanho da camada alvo, preenchendo-as com zeros quando necessário, transplantava separadamente as projeções de atenção e separadamente os componentes MLP para cada especialista encontrado. A memória era limpa imediatamente após cada operação de cópia importante. Mesmo após o transplante, os autores tiveram que reescrever o roteador MoE para que durante a inferência o modelo não travasse em conflitos de dimensão e pudesse gerar pelo menos algum texto.

Os principais passos técnicos foram os seguintes:

• Registro de configuração customizada do Gemma no registro global do Transformers
• Monkey patch para `GenerationConfig` que sobrevive ao erro `dict.to_dict()`
• Bloqueio de `normal_` para pesos `uint8` de 4-bit
• Busca recursiva de especialistas e transferência de matrizes em micro-lotes através da CPU

Testar a quimera resultante mostrou o resultado esperado: o modelo realmente iniciou, mas gerou texto incoerente, uma mistura de tokens aleatórios e fragmentos de frases. Para os autores, isso ainda era considerado um sucesso porque o objetivo não era a qualidade das respostas, mas a demonstração do princípio. Eles não alinharam vocabulários, não treinaram projeções de transição e não fizeram fine-tuning após o transplante, então o fluxo caótico de tokens na saída era quase inevitável. No entanto, o experimento provou que as restrições arquitetônicas muitas vezes se mostram não como uma parede, mas como uma longa lista de problemas de baixo nível que podem ser contornados com código.

O que isso significa

Tais experimentos não criam um produto acabado, mas fazem um bom trabalho mostrando os limites dos LLMs open-source modernos. Se pesos, quantização, roteamento e hidden states podem ser pelo menos parcialmente alinhados sem treinamento adicional, então o espaço se abre para híbridos mais práticos — já com projeções normais, adaptação de vocabulário e ajuste subsequente. Para desenvolvedores, este é um sinal: a pilha ao redor dos modelos ainda é frágil, o que significa que o espaço para montagens não padrão está apenas crescendo.