Google Gemma 4 31B foi reduzido para 18,3 GB e rodou no Kaggle gratuito

O Gemma 4 de 31 bilhões de parâmetros do Google foi comprimido com sucesso de 62 GB para 18,3 GB e executado através do Kaggle gratuito, apesar do limite de disco ser menor que o tamanho original do modelo. Para conseguir isso, o autor montou um pipeline bastante rigoroso, mas funcional: quantização em tempo real, exclusão de cache durante a execução e upload direto do modelo para Hugging Face Hub.

Atingindo os Limites

O Gemma 4 31B original em formato float16 ocupa cerca de 62 GB, e o disco disponível no Kaggle gratuito é limitado a 57,6 GB. O problema não é apenas baixar o modelo. Você ainda precisa requantizá-lo para 4 bits, obter um novo conjunto de pesos em torno de 18 GB e depois enviá-lo.

Se fizermos as contas simplesmente, em uma etapa você precisa manter tanto o original quanto o resultado, o que já são cerca de 80 GB. Em outras palavras, o cenário padrão falha mesmo antes do primeiro upload bem-sucedido. Esse é o ponto deste caso: não se trata de um bonito MLOps em hardware caro, mas de tentar executar um modelo pesado de código aberto sob condições onde cada gigabyte precisa ser conquistado.

Em vez de A100, foram usados dois T4 gratuitos, então a tarefa se resumiu a duas limitações ao mesmo tempo — disco e memória de vídeo. Como resultado, todo o pipeline precisou ser construído não em torno da conveniência, mas em torno da sobrevivência: o que armazenar, quando excluir e em que momento enviar o artefato para fora.

Como o Pipeline Foi Construído

A primeira técnica chave é a quantização não após a preparação completa, mas logo durante o processo de carregamento. Para isso, foram usados bitsandbytes e formato NF4, e o parâmetro device_map="auto" permitiu a distribuição automática do modelo entre dois T4s com 15 GB de memória cada. A ideia é não esperar que todos os pesos se acomodem tranquilamente no disco e só depois começar o processamento. Quanto mais cedo a compressão começa, menor a chance de que arquivos temporários e estados intermediários consumam completamente o espaço disponível.

• O modelo carrega e quantiza quase simultaneamente, sem uma longa pausa entre etapas
• O parâmetro device_map="auto" distribui pesos fragmentados entre dois T4s
• Após carregamento em VRAM, o cache do Hugging Face é excluído para liberar espaço para o novo artefato
• Em vez de salvar em disco, o modelo é enviado diretamente para Hugging Face Hub

O passo mais radical foi excluir a pasta de cache do Hugging Face depois que o modelo já estava carregado na memória de vídeo. Tecnicamente, o truque se baseia no comportamento do Linux: mesmo que um arquivo seja excluído do sistema de arquivos, o processo pode continuar mantendo-o aberto, e o espaço fica disponível para novas escritas. Por causa disso, os 62 GB originais param de interferir na criação de fragmentos quantizados. O estágio final também evitou cópias desnecessárias: em vez de salvar normalmente e fazer upload separado, o resultado foi enviado diretamente para Hugging Face Hub via push_to_hub.

"Não esperamos o fim do upload, começamos a comprimir os pesos imediatamente."

O Que Resultou

O resultado foi um artefato de 18,3 GB — não mais um monstro amarrado ao hardware do servidor, mas um modelo com o qual você pode trabalhar em configurações muito mais ordinárias. O autor enfatiza especificamente que se trata do Gemma 4 de 31 bilhões de parâmetros, orientado entre outras coisas para tarefas envolvendo código complexo. O resultado em si foi postado no Hugging Face, então isso não é apenas uma receita teórica, mas um experimento reproduzível com um resultado concreto e construção pronta.

É importante notar que isso não é uma instrução universal para produção e não é um exemplo de infraestrutura bem organizada. Pela descrição do método, fica claro que a abordagem é frágil: está vinculada ao comportamento do Linux, ao momento exato da exclusão do cache, e à esperança de que nenhum erro ocorra durante a execução que o forçasse a começar quase do zero. Mas é exatamente isso que torna este caso interessante. Mostra que a acessibilidade de grandes modelos é determinada não apenas pelo orçamento, mas pela engenhosidade engenharia — especialmente onde a infraestrutura é limitada e você quer experimentar um novo modelo agora mesmo.

O Que Significa

Grandes modelos de código aberto como Google Gemma 4 podem ser adaptados até mesmo para infraestruturas muito modestas, se você reconstruir todo o processo em torno das limitações em vez de um pipeline conveniente. Para desenvolvedores, este é um bom sinal: a barreira de entrada para experimentos com grandes LLMs é reduzida, mas o preço dessa acessibilidade são cenários MLOps mais frágeis e manuais.