Algoritmo Genético para Classificação

Biblioteca em Python que treina um classificador linear usando algoritmo genético, escrita do zero com NumPy.

Em vez de usar gradiente (como a regressão logística), o modelo evolui uma população de soluções: as melhores se reproduzem, sofrem mutações e, geração após geração, a classificação melhora.

Funciona para:

• Classificação binária (2 classes: 0 e 1)
• Classificação ordinal (K classes com ordem, ex: ruim < médio < bom)

Como funciona

Cada cromossomo é uma lista de números: um bias e um peso para cada feature. Com eles o modelo calcula uma nota para cada amostra:

nota = bias + peso₁·x₁ + peso₂·x₂ + ... + pesoₙ·xₙ

• Binário: nota ≥ 0 → classe 1, nota < 0 → classe 0
• Ordinal: a nota é dividida em faixas pelos thresholds (pontos de corte), e cada faixa é uma classe

O fitness

A nota de cada cromossomo (fitness) é o produto do recall de cada classe:

fitness = recall(classe 0) × recall(classe 1) × ... × recall(classe K-1)

Se o modelo errar todas as amostras de uma classe, o fitness vira 0. Isso obriga o modelo a acertar todas as classes, e não só a mais comum, o que é útil quando as classes são desbalanceadas.

O ciclo do algoritmo

 1. criar população aleatória
          │
          ▼
 2. calcular fitness ◄──────────────┐
          │                         │
          ▼                         │
 3. selecionar pai e mãe (roleta)   │
          │                         │
          ▼                         │
 4. cruzamento (corte em 1 ponto)   │
          │                         │
          ▼                         │
 5. mutação                         │
          │                         │
          ▼                         │
 6. trocar os piores pelos ─────────┘
    melhores filhos

O ciclo para quando atinge o fitness alvo ou acaba o número de gerações.

Instalação

Requer Python 3.10+.

pip install algoritmo-genetico

Ou direto do GitHub:

pip install git+https://github.com/FeAlmassy/AlgoritmoGenetico.git

Para desenvolver

git clone https://github.com/FeAlmassy/AlgoritmoGenetico.git
cd AlgoritmoGenetico
python -m venv venv_ag
source venv_ag/bin/activate        # no Windows: venv_ag\Scripts\activate
pip install -e .                   # modo editável: mudanças no código valem na hora

Uso rápido

Binário

from algoritmo_genetico import rodar, prever, ler_excel, dividir_treino_teste

X, y = ler_excel("exemplos/exemplo_1_binario/dados_binario_1.xlsx")
X_treino, X_teste, y_treino, y_teste = dividir_treino_teste(X, y, seed=0)

modelo = rodar(X_treino, y_treino, geracoes=500, fitness_alvo=0.90, seed=0)

previsoes = prever(modelo, X_teste)

As funções de cada etapa (criar_cromossomos, fitness_binario, selecionar_pais_roleta, cruzar_um_ponto, mutar, atualizar_populacao) também podem ser usadas separadamente, importando dos seus módulos (ex: from algoritmo_genetico.mutacao import mutar).

Ordinal (várias classes)

As classes precisam ser números de 0 a K-1, na ordem da menor para a maior. Para K classes, passe K-1 thresholds em ordem crescente:

import numpy as np

thresholds = np.array([-1.5, -0.5, 0.5, 1.5])   # 4 cortes -> 5 classes

modelo = rodar(X, y, thresholds=thresholds, geracoes=2000, fitness_alvo=1.0)
previsoes = prever(modelo, X_novo)

Parâmetros do rodar

O rodar devolve um dicionário com cromossomo (o melhor encontrado), fitness, acuracia (fração de acertos nos dados de treino), geracao (em que geração parou), thresholds e historico (listas melhor, medio e acuracia com a evolução por geração).

Formato dos dados

A planilha (.xlsx ou .csv) deve seguir este layout:

• Primeira coluna: identificador da amostra (é ignorada)
• Colunas do meio: features
• Última coluna: classe

Um modelo pronto está em exemplos/base_de_dados_para_exemplos/modelo_base.xlsx.

Exemplos e resultados

* Treino com 80% dos dados e teste com os 20% restantes, que o modelo nunca viu. Com np.random.seed(0).

O notebook binário mostra uma geração passo a passo, chamando cada função na ordem do algoritmo. O multiclasse mostra como escolher a ordem das classes quando ela não é conhecida.

Estrutura do projeto

AlgoritmoGenetico/
├── src/
│   └── algoritmo_genetico/
│       ├── __init__.py      # API pública: rodar, prever, ler_excel, ler_csv, dividir_treino_teste
│       ├── nucleo.py        # loop principal (rodar) e previsão (prever)
│       ├── criacao.py       # 1. população inicial
│       ├── fitness.py       # 2. fitness binário, ordinal e percentual
│       ├── selecao.py       # 3. seleção por roleta
│       ├── cruzamento.py    # 4. cruzamento de 1 ponto
│       ├── mutacao.py       # 5. mutação
│       ├── atualizacao.py   # 6. troca dos piores pelos melhores filhos
│       ├── leitura.py       # leitura de .xlsx e .csv
│       └── divisao.py       # divisão em treino e teste (estratificada)
├── exemplos/                # notebooks e datasets de exemplo
├── testes/                  # testes automáticos
├── pyproject.toml           # configuração do pacote (nome, versão, dependências)
├── LICENSE                  # licença MIT
└── requirements.txt

Cada etapa do algoritmo fica em um módulo próprio, então dá para trocar uma peça (por exemplo, testar outra seleção) sem mexer nas outras. Todas as funções verificam os parâmetros recebidos e dão mensagens de erro claras.

Próximos passos

• Empacotar com pyproject.toml e publicar no PyPI
• Testes automáticos com pytest
• Classe no estilo scikit-learn (treinar / prever)
• Salvar e carregar modelos treinados
• Aceitar classes em texto (ex: "bom", "ruim") sem conversão manual

Licença

Distribuído sob a licença MIT: pode usar, modificar e redistribuir livremente, desde que mantenha o aviso de copyright.

Autores

• Fellipe Almassy — GitHub
• Matheus Gomes — GitHub