Como funciona a IA que aprende a jogar Flappy Bird
++ Neste projeto, demonstramos como uma inteligência artificial aprende a jogar Flappy Bird utilizando redes neurais combinadas com algoritmos evolutivos (NEAT). + Durante várias gerações, os pássaros virtuais aprendem a saltar na hora certa, evitando obstáculos, até que se tornem capazes de voar por longos períodos sem colidir. + Todo o processo envolve evolução progressiva, seleção natural simulada e adaptação baseada em desempenho. +
+Estrutura geral do sistema
+O sistema é composto por duas partes principais que trabalham em conjunto:
+-
+
-
+ O jogo Flappy Bird: Implementado em Python com a biblioteca
pygame. Ele gerencia toda a mecânica do jogo, incluindo movimentação do pássaro, geração de canos, colisões e pontuação. +-
+
- O pássaro segue regras de física simplificadas: gravidade constante, impulso ao pular e rotação da imagem baseada no movimento vertical. +
- O chão e o plano de fundo são renderizados continuamente, criando a sensação de movimento infinito. +
- Os canos são gerados com alturas aleatórias e espaçamento progressivo, aumentando a dificuldade conforme a pontuação cresce. +
- Colisões são detectadas com precisão usando máscaras de pixel (
pygame.mask), garantindo que o pássaro só “morre” quando realmente toca os obstáculos.
+ - Sons de pulo e pontuação proporcionam feedback auditivo, tornando a experiência mais imersiva. +
+ -
+ A IA que joga automaticamente: Cada pássaro é controlado por uma rede neural criada e treinada pelo algoritmo NEAT. A IA decide quando pular com base em entradas do ambiente.
+
-
+
- Cada geração possui dezenas ou centenas de pássaros, representando indivíduos distintos na população do NEAT. +
- Os inputs da rede neural incluem: posição vertical do pássaro e distância até a parte superior e inferior do próximo cano. +
- A saída da rede neural indica se o pássaro deve saltar ou permanecer no curso atual. +
- O NEAT ajusta tanto os pesos quanto a topologia da rede ao longo de várias gerações, maximizando a aptidão (fitness), baseada em distância percorrida e pontuação acumulada. +
- Indivíduos com melhor desempenho sobrevivem e se reproduzem, permitindo evolução progressiva e adaptação ao ambiente. +
+
+ O objetivo final é que a IA aprenda a voar o mais longe possível sem colidir, enquanto o jogo simula física realista e aumenta a dificuldade gradualmente. +
+O código define parâmetros dinâmicos para controlar dificuldade e evolução, como:
+-
+
- Velocidade dos canos que aumenta conforme a pontuação (
Pipe.SPEED).
+ - Espaçamento entre os canos ajustado dinamicamente para desafios mais difíceis à medida que o jogo avança. +
- Sistema de pontuação e fitness que influencia diretamente a evolução da rede neural. +
Inputs da Rede Neural
++ Para tomar decisões, cada rede neural precisa “enxergar” o ambiente ao redor. + Os inputs funcionam como sensores do pássaro, fornecendo informações essenciais para que a IA escolha a ação adequada a cada instante. +
+-
+
- + Altura do pássaro (bird.y) — posição vertical atual do pássaro na tela. Permite avaliar se ele está alto ou baixo em relação ao próximo obstáculo. + +
- + Distância até o topo do próximo cano (abs(bird.y - pipe.height)) — mede o espaço vertical entre o pássaro e a parte superior do cano. Indica se precisa subir para evitar colisão. + +
- + Distância até a base do próximo cano (abs(bird.y - pipe.bottom_pos)) — mede a distância até a extremidade inferior do cano, ajudando a prevenir quedas ou saltos desnecessários. + +
+ Esses três inputs fornecem informações detalhadas sobre: +
-
+
- Posição relativa do pássaro em relação ao obstáculo seguinte. +
- Necessidade de saltar ou manter a trajetória atual. +
- Como ajustar o movimento vertical para percorrer a maior distância possível. +
+ A rede neural processa esses valores e gera uma saída, que determina se o pássaro deve pular. Com a evolução, a IA aprende padrões complexos, antecipando obstáculos e reagindo rapidamente a mudanças de altura. +
+Estrutura da Rede Neural
+A rede neural é organizada em camadas que processam os inputs e decidem a ação do pássaro:
+-
+
- + Camada de entrada: recebe os 3 inputs do jogo, que funcionam como sensores do ambiente. + +
- + Camadas ocultas: presentes ou não dependendo da configuração do NEAT. Permitem à rede aprender padrões complexos, como prever movimentos futuros ou calcular trajetórias seguras. + +
-
+ Camada de saída: possui um único neurônio que gera um valor contínuo, interpretado como:
+
-
+
- Output maior que 0.5 → Pular +
- Output ≤ 0.5 → Não pular +
+
Como a decisão é calculada:
+
+ Cada input é multiplicado por seu peso correspondente, somado a um bias e processado por uma função de ativação (tanh). O resultado contínuo é convertido em ação:
+
+ {`input_y = 30
+input_cano_sup = 4
+input_cano_inf = -7
+pesos = [0.5, 2, 1.3]
+bias = -5
+
+soma = 30*0.5 + 4*2 + (-7*1.3) + (-5) = 8.9
+output = tanh(soma) ≈ 0.999
+
+Se output > 0.5 → PULA
+Se output ≤ 0.5 → NÃO PULA`}
+
+ + O NEAT permite que a topologia da rede evolua: adicionar ou remover nós e conexões, ajustando pesos e biases para aumentar a eficiência e maximizar a pontuação. +
++ Resumindo, a rede neural transforma informações do ambiente em decisões concretas (pular ou não) e sua estrutura evolui automaticamente para melhorar a performance da IA ao longo do tempo. +
+Algoritmo Evolutivo (NEAT)
++ A IA aprende usando o NEAT (NeuroEvolution of Augmenting Topologies), um algoritmo genético especializado em redes neurais, que simula evolução biológica para melhorar o desempenho ao longo das gerações. +
+-
+
- + População: dezenas ou centenas de pássaros são criados, cada um com uma rede neural única. Pesos e biases iniciais são aleatórios. + +
- + Fitness: pontuação baseada no desempenho (distância percorrida, canos ultrapassados, tempo de sobrevivência), indicando aptidão para reprodução. + +
- + Seleção: apenas os pássaros com maior fitness têm maior chance de transmitir genes à próxima geração. + +
- + Crossover: mistura de genes de dois indivíduos selecionados, combinando características de ambos. + +
- + Mutação: pequenas alterações aleatórias nos pesos, biases ou na estrutura da rede, explorando novas estratégias e evitando estagnação. + +
+ Diferente de algoritmos genéticos tradicionais, o NEAT também evolui a topologia da rede: +
+-
+
- Adiciona novos neurônios ou conexões entre eles. +
- Mantém histórico de inovações para preservar estruturas vantajosas durante crossover. +
- Permite aumentar a complexidade gradualmente, aprendendo estratégias mais sofisticadas. +
Analogia: Algoritmo Genético clássico altera apenas atributos; NEAT altera atributos e estrutura interna, como adicionar asas ou mudar conexões internas do organismo.
+ +Fluxo do NEAT no jogo:
+-
+
- Criar população inicial de redes neurais aleatórias. +
- Cada pássaro joga, calculando fitness em tempo real. +
- Selecionar indivíduos de maior performance para reprodução. +
- Aplicar crossover e mutação, incluindo novos nós ou conexões. +
- Repetir por várias gerações até obter redes eficientes. +
+ No código, classes como Population, Genome e o método pop.run(main, 100) controlam o processo, executando o jogo por 100 gerações ou até atingir fitness máximo.
+
Paralelo entre Rede Neural e Algoritmo Genético
++ A rede neural é o "organismo" que reage ao ambiente, enquanto o NEAT é a "evolução" que seleciona e aprimora esses organismos ao longo das gerações. +
+| Conceito | +Rede Neural | +Algoritmo Genético | +
|---|---|---|
| Cromossomo | +Conjunto completo de pesos e biases da rede neural, representando a “configuração genética” do pássaro. | +Representação do indivíduo na população, definindo comportamento inicial. | +
| Gene | +Peso ou bias individual dentro da rede, influenciando diretamente a decisão (pular ou não). | +Peso ou bias específico do indivíduo, cuja alteração pode modificar comportamento. | +
| Mutação | +Ajuste leve em pesos e biases, explorando novas estratégias sem destruir aprendizado. | +Alteração aleatória de genes, introduzindo diversidade genética. | +
| Fitness | +Pontuação no jogo (distância, canos ultrapassados), indicando performance da rede. | +Avaliação do desempenho do indivíduo; maior fitness aumenta chance de reprodução. | +
+ Em resumo, a rede neural determina o comportamento do pássaro, enquanto o NEAT seleciona, mistura e evolui essas redes, permitindo aprendizado contínuo e estratégias cada vez mais eficientes. +
+Baixar o projeto
++ Você pode baixar o projeto completo com todos os arquivos necessários para executar o Flappy Bird AI: +
+ + Baixar projeto (Flappy-Bird-AI.zip) + +Como executar localmente
+-
+
-
+ Pré-requisitos: Python 3.8 ou superior.
+
+ {`python -m venv venv +source venv/bin/activate # macOS/Linux +venv\\Scripts\\activate # Windows`} ++Cria e ativa um ambiente virtual, isolando as dependências do sistema.
+
+
+ -
+ Instalar dependências:
+
pip install -r requirements.txt
++ O arquivo
+requirements.txtcontém todas as bibliotecas necessárias, incluindo +pygame(motor gráfico) eneat-python(algoritmo evolutivo). +
+
+ -
+ Estrutura mínima do projeto:
+
+ {`/assets +/config +/src + └── /game + └── FlappyBird.py + └── configs.txt +requirements.txt`} +++ A pasta
+/assetscontém as imagens e sons do jogo, + enquanto/configdefine os parâmetros de evolução usados pelo NEAT. +
+
+ -
+ Executar o jogo:
+
python src/game/FlappyBird.py
+Durante a execução, o terminal exibirá informações como:
+-
+
- Média de fitness da população +
- Melhor fitness da geração +
- Quantidade de espécies e progresso evolutivo +
Esses dados permitem acompanhar a evolução da IA em tempo real.
+
+
Dicas e experimentos
+-
+
-
+ Aumente
pop_sizeno arquivo de configuração para ampliar a diversidade genética e acelerar o aprendizado. +
+ -
+ Teste funções de ativação diferentes (
sigmoid,relu, etc.) para observar mudanças no comportamento da IA. +
+ - + Ajuste a função de fitness para enfatizar critérios específicos, como distância percorrida ou estabilidade de voo. + +
-
+ Salve o melhor genoma usando
picklepara reutilização posterior sem reiniciar a evolução. +
+ - + Observe o terminal para métricas avançadas como tempo por geração e divergência genética + (mean genetic distance), úteis na análise de performance. + +
+ Seguindo essas etapas, você poderá executar o Flappy Bird AI localmente, testar modificações e + explorar a evolução do aprendizado em tempo real. +
+