💻 computer science

GPU-Accelerated Genetic Programming for Symbolic Regression with Beagle Framework

Este artigo apresenta o Beagle, um novo framework de Programação Genética acelerado por GPU para regressão simbólica, demonstrando através de benchmarks no conjunto de dados de Feynman que ele supera significativamente em desempenho os principais sistemas baseados em CPU, como o StackGP e o PySR.

Autores originais: Nathan Haut, Ilya Basin, Marzieh Kianinejad, Ruchika Gupta, Elijah Smith, Zachary Perrico, Wolfgang Banzhaf

Publicado 2026-03-16

📖 4 min de leitura☕ Leitura rápida

CC BY 4.0

Autores originais: Nathan Haut, Ilya Basin, Marzieh Kianinejad, Ruchika Gupta, Elijah Smith, Zachary Perrico, Wolfgang Banzhaf

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você precisa encontrar a receita secreta perfeita para um bolo, mas não sabe quais ingredientes usar, nem as quantidades. Você tem uma lista de bolos que já saíram bem (os dados) e precisa descobrir a fórmula exata que os criou.

No mundo da ciência de dados, isso se chama Regressão Simbólica. É como tentar adivinhar a equação matemática por trás de um fenômeno do mundo real.

O problema? Tentar adivinhar essa fórmula manualmente é impossível. Existem bilhões de combinações possíveis. É como tentar encontrar uma agulha em um palheiro, mas o palheiro é do tamanho de um planeta.

Aqui é onde entra o Beagle, o "herói" desta história.

O Que é o Beagle?

O Beagle é um novo programa (um "framework") que usa uma técnica chamada Programação Genética. Pense nele como um chef de cozinha evolutivo:

Ele cria milhares de receitas aleatórias (fórmulas matemáticas).
Ele as testa para ver quais ficam mais parecidas com a receita original.
Ele pega as melhores receitas, mistura-as (cruzamento) e faz pequenas alterações (mutação) para criar uma nova geração de receitas ainda melhores.
Ele repete esse processo milhões de vezes até encontrar a receita perfeita.

O problema é que fazer isso em computadores normais (que usam apenas o processador principal, o CPU) é como tentar cozinhar esse bolo em uma panela de barro: lento e trabalhoso.

A Revolução da GPU: O "Exército de Cozinheiros"

O grande trunfo do Beagle é que ele foi desenhado para usar GPUs (as placas de vídeo de computadores gamers e estações de trabalho).

CPU (Processador Normal): Imagine um cozinheiro genial, mas que só pode fazer uma coisa de cada vez. Ele corta a cebola, depois pica o tomate, depois batede o ovo. É inteligente, mas lento para tarefas massivas.
GPU (Placa de Vídeo): Imagine um exército de 10.000 cozinheiros estagiários, todos trabalhando ao mesmo tempo. Enquanto o cozinheiro genial corta uma cebola, os 10.000 estagiários estão testando 10.000 receitas diferentes simultaneamente.

O Beagle foi feito para usar esse "exército". Ele distribui o trabalho de testar milhões de fórmulas matemáticas entre milhares de pequenos núcleos da placa de vídeo, tornando o processo centenas de vezes mais rápido.

A Grande Corrida (O Benchmark)

Os autores do artigo colocaram o Beagle para correr contra dois outros programas famosos (StackGP e PySR) em uma prova de resistência chamada Feynman Benchmark.

O Desafio: Resolver 100 equações da física (como as que descrevem como a gravidade funciona ou como a luz se comporta).
A Regra: Eles tinham apenas 10 e 30 minutos para encontrar as soluções.

O Resultado:
O Beagle venceu de forma esmagadora.

Em 10 minutos, o Beagle (usando uma técnica especial de avaliação chamada "correlação") conseguiu resolver 82 dos 100 problemas.
Os concorrentes (StackGP e PySR) resolveram apenas cerca de 64 a 65.
Em 30 minutos, o Beagle chegou a 91 problemas resolvidos.

O Segredo Extra: Lidando com o "Impossível"

Uma das inovações mais legais do Beagle é como ele lida com erros matemáticos (chamados de NaNs ou "Não é um Número").

Imagine que você está tentando adivinhar uma fórmula, mas em alguns pontos a matemática "explode" (como tentar calcular a raiz quadrada de um número negativo).

Outros programas: Jogam esses dados fora ou param de tentar. É como jogar fora uma parte da receita porque um ingrediente estragou.
O Beagle: Ele é inteligente. Ele percebe: "Ah, a receita original também falha exatamente nesse ponto!". Então, ele recompensa o modelo por falhar no mesmo lugar que os dados reais. Isso ajuda o programa a entender melhor a estrutura da fórmula, mesmo nas partes "quebradas".

Por que isso importa?

Antes, para encontrar essas fórmulas complexas, você precisava de supercomputadores caros ou esperar dias. Com o Beagle:

Velocidade: Você obtém resultados em minutos, não em horas.
Acessibilidade: Qualquer pessoa com um computador gamer moderno pode fazer o que antes exigia um laboratório de pesquisa.
Inteligência: Ele consegue explorar "oceanos" de possibilidades (milhões de fórmulas) que outros sistemas nem sequer olham.

Resumo da Ópera:
O Beagle é como transformar a busca por uma agulha em um palheiro de uma tarefa de uma pessoa solitária para uma operação militar coordenada por um exército de robôs. Ele usa o poder das placas de vídeo para descobrir as leis da física e as fórmulas do universo muito mais rápido do que qualquer sistema anterior, tornando a inteligência artificial mais rápida, barata e acessível para todos.

Resumo Técnico: Programação Genética Acelerada por GPU para Regressão Simbólica com o Framework Beagle

1. O Problema

A Regressão Simbólica (RS), uma aplicação da Programação Genética (PG), visa descobrir expressões matemáticas que descrevam dados observados. Embora poderosa, a PG é inerentemente computacionalmente intensiva devido aos ciclos repetidos de avaliação, variação e seleção de populações de programas.

Gargalo de Recursos: A evolução de modelos complexos exige grandes populações e muitas gerações, o que torna o tempo de execução proibitivo em sistemas baseados apenas em CPU.
Limitações Atuais: Sistemas existentes de RS (como PySR e StackGP) muitas vezes não exploram totalmente o potencial de paralelismo massivo oferecido pelas Unidades de Processamento Gráfico (GPUs), ou enfrentam gargalos de gerenciamento de memória e sobrecarga de troca de dados entre CPU e GPU.
Necessidade: Há uma demanda por frameworks que possam executar buscas evolutivas em grandes espaços de solução dentro de restrições de tempo curtas (ex: 10-30 minutos), tornando a PG mais acessível para aplicações práticas.

2. Metodologia

Os autores apresentaram e avaliaram o Beagle, um novo framework de código aberto para RS projetado especificamente para ambientes de computação heterogênea (CPU + GPU).

Arquitetura do Beagle:

Linguagem e Backend: Desenvolvido em C# utilizando a biblioteca de código aberto ILGPU, permitindo programação no nível mais baixo da CUDA (evitando abstrações de bibliotecas de alto nível).
Divisão de Tarefas:
- GPU: Responsável pela execução de corridas evolutivas e, crucialmente, pela avaliação massiva de funções de aptidão (fitness). Cada bloco CUDA representa um organismo (indivíduo) e cada thread representa um caso de teste.
- CPU: Gerencia a seleção, o ciclo de nascimento/morte e mutações. Não utiliza cruzamento (crossover) na implementação atual.
Otimizações de Desempenho:
- Gerenciamento de Memória: Elimina quase completamente a coleta de lixo (Garbage Collection) e a fragmentação de memória reutilizando memória de indivíduos "mortos" em um "pool morto", em vez de realocar.
- Linguagem Personalizada (GCL): Utiliza uma Linguagem de Computador de Genoma baseada em Programação Genética Linear (LGP) e Notação Polonesa Reversa (RPN). Isso torna o código mais amigável à GPU e à gestão de memória, evitando estruturas baseadas em heap.
- Estratégia de Seleção: Para populações na casa dos milhões, substitui a ordenação completa (que não escala) por uma abordagem inspirada em Monte Carlo, amostrando aleatoriamente 100 indivíduos para determinar percentis de aptidão.
Funções de Aptidão Testadas:
1. Erro Ponto a Ponto (Padrão): Similar ao RMSE, compara saída do modelo com o alvo.
2. Função de Correlação: Baseada no coeficiente de correlação ( $r$ ), maximizando $r^4$ . É mais robusta para escalas e deslocamentos, mas computacionalmente mais custosa.
3. Tratamento de NaNs: O Beagle foi projetado para lidar com valores inválidos (NaN/Infinito) sem descartá-los, recompensando modelos que falham nos mesmos pontos que os dados de treinamento, preservando informações úteis.

Configuração do Benchmark:

Dataset: Feynman Symbolic Regression Benchmark (100 equações de física real).
Comparadores:
- Beagle: Executado em 4 CPUs (Intel Xeon Platinum) e 2 GPUs (NVIDIA V100).
- StackGP: Sistema baseado em pilha em Python (1 CPU, single-threaded).
- PySR: Sistema popular em Python/Julia (4 CPUs, multithreading).
Restrições de Tempo: Execuções de 10 e 30 minutos.
Critério de Sucesso: Um problema é considerado "resolvido" se pelo menos 50% das 10 execuções independentes encontrarem um modelo validado (erro < 0.1% no conjunto de teste).

3. Contribuições Chave

Introdução do Beagle: Um framework de PG otimizado para GPUs que permite populações na casa dos milhões, superando limitações de memória e velocidade de CPU.
Implementação Eficiente de Funções de Correlação na GPU: Demonstrou que é possível executar funções de aptidão complexas (correlação) na GPU com ganhos líquidos de desempenho, apesar do custo computacional individual ser maior.
Tratamento Robusto de Dados Inválidos: Capacidade de explorar domínios onde funções geram números complexos (convertidos para NaN), utilizando essa informação para guiar a evolução, algo que outros sistemas não suportam nativamente.
Benchmarking Abrangente: Avaliação rigorosa contra os sistemas de ponta (StackGP e PySR) sob restrições de tempo realistas.

4. Resultados

Os testes foram realizados em 100 problemas do benchmark de Feynman.

Desempenho em 10 Minutos:
- Beagle (Correlação): Resolveu 82 problemas tipicamente (mediana) e 89 no melhor caso.
- Beagle (Ponto a Ponto): 66 (típico) / 77 (melhor).
- StackGP: 65 (típico) / 82 (melhor).
- PySR: 64 (típico) / 78 (melhor).
- Conclusão: O Beagle com função de correlação superou consistentemente os concorrentes.
Desempenho em 30 Minutos:
- Beagle (Correlação): 84 (típico) / 91 (melhor).
- Beagle (Ponto a Ponto): 74 (típico) / 80 (melhor).
- PySR: 72 (típico) / 86 (melhor).
- StackGP: 70 (típico) / 83 (melhor).
- Conclusão: O Beagle manteve a liderança, resolvendo a maior parte dos problemas com maior consistência.
Estudo de Caso (NaNs): Em um experimento específico com equações quadráticas onde o domínio gerava números imaginários (NaNs), o Beagle encontrou soluções perfeitas em 10/10 execuções quando permitiu o domínio amplo e tratou os NaNs corretamente. StackGP e PySR falharam em encontrar soluções perfeitas em qualquer uma das 10 execuções, pois não suportam esse tratamento de dados inválidos.

5. Significado e Impacto

Aceleração Massiva: O Beagle demonstra que a PG pode ser acelerada significativamente ao mapear corretamente a avaliação de aptidão para GPUs, permitindo populações de milhões de indivíduos que seriam impossíveis em CPUs.
Viabilidade Prática: Os resultados mostram que soluções de alta qualidade podem ser encontradas em menos de 30 minutos, tornando a RS competitiva para aplicações industriais onde o tempo é crítico.
Novas Dinâmicas de Busca: A capacidade de manter populações gigantes e lidar com dados "sujos" (NaNs) abre novas fronteiras para a pesquisa em PG, permitindo a exploração de espaços de busca mais amplos e a descoberta de modelos em domínios onde outras técnicas falham.
Acessibilidade: Ao superar sistemas baseados em CPU, o Beagle oferece uma via para que pesquisadores e praticantes com acesso a GPUs (comum em data centers e até laptops modernos) realizem regressão simbólica de ponta.

Em suma, o trabalho valida que a combinação de hardware GPU moderno com otimizações de software específicas (como o Beagle) supera os métodos tradicionais de CPU, estabelecendo um novo estado da arte para a Regressão Simbólica sob restrições de tempo.