Smells Like Prompt Spirit: Evaluating Energy Efficiency and Performance of Local LLM Inference on CPU vs GPU

Imagine um mundo onde o software que rege nossas vidas modernas é escrito não apenas por mãos humanas, mas por inteligência artificial. Esses assistentes digitais, conhecidos como modelos de linguagem de grande escala, tornaram-se tão proficientes na escrita de código que agora fazem parte do fluxo de trabalho diário de milhões de desenvolvedores. Eles podem completar uma frase de programação, depurar uma função quebrada ou construir um pequeno programa a partir de uma descrição simples. No entanto, essa conveniência vem com um custo oculto. Cada vez que esses modelos pensam, eles consomem quantidades vastas de eletricidade, contribuindo para uma pegada de carbono crescente que ameaça o próprio meio ambiente que esperamos proteger. À medida que a demanda por essas ferramentas cresce, cientistas estão fazendo uma pergunta crítica: como podemos torná-las mais rápidas e baratas sem incendiar o planeta?

Para responder a isso, pesquisadores recentemente se propuseram a testar como essas mentes artificiais se comportam quando movidas de um tipo de hardware de computador para outro. Por anos, os desenvolvedores sabem que rodar esses modelos em chips gráficos especializados, originalmente projetados para videogames, é muito mais rápido do que rodar em processadores de computador padrão. Mas velocidade é apenas metade da história. A equipe queria saber se essa mudança para um hardware mais rápido também economizava energia e, mais importante, se alterava a qualidade do código que os modelos produziam. Eles também estavam curiosos sobre um truque sutil usado na elaboração de comandos (prompting): dar ao modelo alguns exemplos da tarefa antes de pedir que ele trabalhe. Mostrar ao modelo uma amostra do trabalho ajuda a economizar energia, ou apenas torna o processo mais longo?

Os pesquisadores pegaram cinco modelos de codificação de código aberto diferentes e os submeteram a um teste rigoroso. Eles executaram o mesmo conjunto de desafios de programação em duas máquinas muito diferentes: um processador de computador padrão e um poderoso cluster de placas de vídeo. Eles mediram exatamente quanta energia cada execução consumiu, quanto tempo levou e se o código gerado realmente funcionou. Eles também compararam duas formas de pedir ajuda aos modelos. No primeiro método, deram ao modelo uma tarefa sem exemplos, uma abordagem "zero-shot". No segundo, forneceram três exemplos de tarefas similares primeiro, uma abordagem "three-shot", para guiar o pensamento do modelo.

Os resultados foram impressionantes e revelaram um claro equilíbrio entre velocidade e estabilidade. Quando os modelos foram movidos para o poderoso hardware gráfico, a diferença na velocidade foi quase inimaginável. O tempo para gerar código caiu mais de 99 por cento, transformando processos que levavam segundos em frações de segundo. Esse aumento massivo de velocidade também levou a uma queda significativa no uso de energia, com algumas tarefas consumindo quase 90 por cento menos potência do que consumiam no processador padrão. Foi uma vitória clara para a eficiência. No entanto, a história tornou-se mais complicada quando os pesquisadores observaram a qualidade do código.

Quando os modelos foram solicitados a trabalhar sem nenhum exemplo, a mudança para o hardware mais rápido fez com que eles se comportassem de forma imprevisível. Como os chips gráficos processam informações de uma maneira diferente dos processadores padrão, os modelos às vezes produziam códigos que eram estruturalmente diferentes ou simplesmente falhavam em funcionar, mesmo que as configurações fossem idênticas. Era como se a mesma pessoa, ao ser solicitada a escrever uma história em dois quartos diferentes, viesse a criar finais completamente distintos. Essa inconsistência foi mais severa quando os modelos foram deixados para descobrir as coisas por conta própria.

A solução para essa instabilidade revelou-se surpreendentemente simples. Quando os pesquisadores forneceram três exemplos antes de pedir ao modelo para escrever o código, o comportamento mudou dramaticamente. Os modelos tornaram-se muito mais consistentes, produzindo resultados confiáveis independentemente de qual computador estivessem rodando. Além disso, esse método de mostrar exemplos também economizou energia. Ao dar ao modelo um caminho claro a seguir, ele evitou gerar conversas desnecessárias ou explicações longas que frequentemente poluem a saída quando nenhum exemplo é fornecido. Essa abordagem "three-shot" eliminou o excesso do processo, reduzindo o consumo de energia em mais de 60 por cento em alguns testes e tornando a geração de código mais rápida e precisa.

O estudo sugere, em última análise, que simplesmente comprar hardware mais rápido não é suficiente para resolver os problemas de energia e qualidade na inteligência artificial. Embora a mudança para placas de vídeo poderosas torne o processo incrivelmente eficiente, isso não garante melhores resultados por si só. Na verdade, sem a orientação adequada, a velocidade pode vir ao custo da confiabilidade. A estratégia mais eficaz encontrada foi uma combinação das duas: usar o hardware poderoso para velocidade, mas combiná-lo com um estilo de comando que fornece ao modelo alguns exemplos para seguir. Essa abordagem não apenas manteve o uso de energia baixo, mas também garantiu que o código produzido fosse estável e correto.

No fim, a pesquisa destaca que o futuro da inteligência artificial verde depende de como fazemos perguntas, não apenas de quais máquinas usamos. Ao projetar cuidadosamente como interagimos com esses modelos, podemos aproveitar sua velocidade sem sacrificar a qualidade de seu trabalho ou a saúde do nosso planeta. O caminho a seguir não é apenas construir computadores maiores e mais rápidos, mas encontrar o equilíbrio certo entre as ferramentas que usamos e as instruções que damos a elas.