No cenário digital moderno, sistemas de inteligência artificial poderosos conhecidos como grandes modelos de linguagem transformaram a forma como os computadores entendem e geram a linguagem humana. Esses sistemas são construídos sobre vastas coleções de pontos de dados chamados parâmetros, que atuam como a base de conhecimento interna do modelo. Um modelo típico pode conter bilhões desses parâmetros, exigindo uma quantidade significativa de memória de computador para armazená-los. Durante anos, rodar esses sistemas complexos foi o domínio de enormes centros de dados equipados com processadores gráficos especializados e de alta velocidade. No entanto, um movimento crescente busca levar essa inteligência para mais perto de onde as pessoas realmente vivem e trabalham, colocando-a em computadores locais menores conhecidos como nós de borda (edge nodes). Esses dispositivos são frequentemente encontrados em escritórios, residências ou locais remotos onde as conexões de internet são instáveis ou onde preocupações com a privacidade impedem que os dados saiam do edifício. O desafio para os engenheiros é que esses dispositivos locais geralmente carecem dos poderosos processadores gráficos encontrados em centros de dados, dependendo, em vez disso, de unidades centrais de processamento padrão, os cérebros de uso geral da maioria dos computadores. A questão crítica tem sido se essas máquinas modestas e cotidianas podem realmente suportar o trabalho pesado de rodar modelos de linguagem avançados e, se sim, quanta memória elas precisam e quão rápido podem trabalhar.

Uma equipe de pesquisadores partiu para responder a essas perguntas testando os limites de um único computador de borda representativo. Eles não construíram um novo software nem inventaram um chip mais rápido; em vez disso, atuaram como observadores cuidadosos, medindo exatamente o que acontece quando um computador padrão tenta rodar três tamanhos diferentes de modelos de linguagem. Eles testaram modelos variando de uma versão compacta com 1,1 bilhão de parâmetros até uma versão mais robusta com 7 bilhões de parâmetros. Para cada modelo, rodaram o sistema em três níveis diferentes de precisão, que podem ser pensados como a quantidade de detalhe que o computador usa para armazenar seus números internos. Os pesquisadores queriam ver se a prática comum de reduzir esse detalhe, conhecida como quantização, ajudaria essas máquinas locais a rodar mais rápido e usar menos memória, assim como ocorre em centros de dados poderosos.

Os resultados que eles descobriram revelaram uma realidade surpreendente que contradiz o que é amplamente acreditado sobre esses sistemas. Nos centros de dados de alta potência do mundo, reduzir a precisão de um modelo é uma estratégia comprovada que corta o uso de memória pela metade ou mais e acelera o desempenho. No computador local, apenas com CPU, testado neste estudo, ocorreu exatamente o oprico. Quando os pesquisadores reduziram a precisão para economizar espaço, o computador na verdade precisou de significativamente mais memória para rodar o modelo. Para o maior modelo testado, que teoricamente deveria ter exigido cerca de 14 gigabytes de memória, o sistema demandou quase 20 gigabytes quando a precisão foi reduzida. Esse aumento de aproximadamente 48 por cento aconteceu porque o processador padrão do computador não conseguia entender nativamente os números comprimidos e de baixa precisão. Em vez de processá-los diretamente, o sistema teve que manter os pesos comprimidos na memória enquanto simultaneamente os convertia de volta para um formato padrão para cada cálculo realizado. Isso criou um fardo duplo onde o computador mantinha tanto os pesos comprimidos quanto os buffers de conversão, enquanto as ativações e o cache de atenção permaneciam no formato padrão durante todo o processo, efetivamente aumentando a carga de memória em vez de aliviá-la.

Além do problema de memória, o estudo identificou exatamente o que estava atrasando o computador. Os pesquisadores descobriram que o processador estava trabalhando a quase 100 por cento de sua capacidade, mas estava produzindo muito poucos resultados. Isso indicou que a máquina não estava lutando com a matemática em si, mas sim esperando que os dados chegassem de sua memória. O gargalo era a velocidade com que a informação podia viajar dos chips de memória para o processador, um limite conhecido como largura de banda de memória. Como o computador estava constantemente esperando por dados, ele só conseguia lidar com uma solicitação de cada vez. Se um usuário tentasse fazer duas perguntas simultaneamente, o sistema não seria capaz de dividir o trabalho entre duas threads; ele simplesmente ficaria sobrecarregado. A solicitação única saturava a máquina, o que significa que, para atender múltiplos usuários, uma rede precisaria adicionar mais computadores físicos em vez de tentar espremer mais trabalho de um único computador.

A queda de desempenho foi ainda mais dramática quando os pesquisadores observaram a velocidade. O modelo mais capaz, rodando em sua precisão padrão, conseguia gerar cerca de 3,76 palavras por segundo, o que é lento, mas utilizável para uma conversa. No entanto, quando os pesquisadores aplicaram as técnicas de compressão destinadas a tornar as coisas mais rápidas, a velocidade despencou. O sistema desacelerou para menos de uma palavra por segundo, fazendo a interação parecer dolorosamente lenta. No caso mais extremo de compressão, o sistema produzia uma nova palavra apenas uma vez a cada dezesseis segundos, tornando-o inútil para conversação em tempo real. Isso confirmou que as técnicas projetadas para placas gráficas poderosas não eram apenas ineficazes nessas máquinas locais; elas eram ativamente prejudiciais, trocando velocidade por uma penalidade de memória que a máquina não podia suportar.

Para ajudar engenheiros a planejar essas realidades, os pesquisadores desenvolveram uma regra simples para estimar quanta memória um computador local realmente precisaria. Eles descobriram que a quantidade de memória necessária não é apenas uma questão do tamanho dos parâmetros do modelo. Em vez disso, o uso total de memória depende fortemente do nível de precisão escolhido. Para um modelo padrão, não comprimido, a memória necessária é aproximadamente igual ao tamanho dos pesos do modelo. Mas para modelos comprimidos, os pesquisadores descobriram que o requisito de memória salta para cerca de três vezes o tamanho do peso para um nível de compressão e quase seis vezes para o nível mais profundo. Isso significa que um engenheiro planejando rodar um modelo grande em um dispositivo local deve provisionar uma máquina com significativamente mais memória do que o tamanho do arquivo do modelo sugere. Um computador com 32 gigabytes de memória pode ser capaz de rodar um modelo grande, mas teria muito pouco espaço restante para o sistema operacional ou outras tarefas, e certamente não poderia rodar dois modelos desses ao mesmo tempo.

O estudo conclui que, embora rodar modelos de linguagem avançados em dispositivos locais, apenas com CPU, seja possível, isso exige um reposicionamento completo de como esses sistemas são implantados. As estratégias que funcionam na nuvem não se traduzem para a borda (edge). Engenheiros não podem simplesmente pegar um modelo otimizado para um centro de dados e esperar que ele rode eficientemente em um laptop ou servidor local. Eles devem levar em conta o fato de que essas máquinas são limitadas pela rapidez com que podem mover dados, não pela rapidez com que podem calcular. Eles também devem aceitar que comprimir o modelo para economizar espaço provavelmente o tornará mais lento e exigirá mais memória, não menos. Para aqueles que precisam implantar esses sistemas em locais com preocupações de privacidade ou internet precária, o caminho a seguir envolve escolher o tamanho de modelo certo para a memória disponível e aceitar que um único computador local pode atender apenas uma pessoa de cada vez. A era da inteligência de borda chegou, mas ela exige um conjunto de regras diferente dos centros de dados que vieram antes dela.