# Genetic Algorithms

> Genetic algorithm optimization

- Skill: `ffsshhttiikk/genetic-algorithms` (Agent Skill)
- Install (CLI): `npx skillmds@latest add ffsshhttiikk/genetic-algorithms`
- Raw SKILL.md: https://api.skillmd.com/api/skills/ffsshhttiikk/genetic-algorithms/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: MIT
- Author: ffsshhttiikk (https://skillmd.com/u/ffsshhttiikk)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/ffsshhttiikk/genetic-algorithms

---


## What I do

- Implement evolutionary algorithms
- Design genetic representations
- Create fitness functions
- Implement selection and crossover
- Handle mutation operators
- Optimize using evolution

## When to use me

Use me when:
- Complex optimization problems
- Noisy or non-differentiable fitness
- Multi-objective optimization
- Feature selection
- Neural architecture search

## Key Concepts

### Genetic Algorithm Flow
```
┌──────────────┐
│   Population │◀──────────────┐
│   Generation │                │
└──────┬───────┘               │
       │                       │
       ▼                       │
┌──────────────┐    ┌─────────┐│
│   Evaluate   │    │ Select ││
│   Fitness    │───▶│ Parents││
└──────────────┘    └────┬────┘
                        │
                        ▼
                 ┌─────────────┐
                 │  Crossover  │
                 │   + Mutate  │
                 └──────┬──────┘
                        │
                        ▼
                 ┌─────────────┐
                 │   Replace   │
                 │  Population │
                 └──────┬──────┘
                        │
                        ▼
                 ┌──────────────┐
                 │   Continue?  │
                 └──────────────┘
```

### Implementation
```python
import random
import numpy as np

class GeneticAlgorithm:
    def __init__(self, pop_size=100, mutation_rate=0.1, 
                 crossover_rate=0.8):
        self.pop_size = pop_size
        self.mutation_rate = mutation_rate
        self.crossover_rate = crossover_rate
    
    def init_population(self):
        return [self.create_individual() for _ in range(self.pop_size)]
    
    def fitness(self, individual):
        raise NotImplemented
    
    def selection(self, population, fitnesses):
        # Tournament selection
        selected = []
        for _ in range(len(population)):
            i, j = random.sample(range(len(population)), 2)
            if fitnesses[i] > fitnesses[j]:
                selected.append(population[i].copy())
            else:
                selected.append(population[j].copy())
        return selected
    
    def crossover(self, parent1, parent2):
        if random.random() > self.crossover_rate:
            return parent1.copy(), parent2.copy()
        
        point = random.randint(1, len(parent1) - 1)
        child1 = parent1[:point] + parent2[point:]
        child2 = parent2[:point] + parent1[point:]
        return child1, child2
    
    def mutate(self, individual):
        for i in range(len(individual)):
            if random.random() < self.mutation_rate:
                individual[i] = self.random_gene()
        return individual
    
    def evolve(self, generations=100):
        population = self.init_population()
        
        for gen in range(generations):
            fitnesses = [self.fitness(ind) for ind in population]
            
            # Elitism - keep best
            best_idx = np.argmax(fitnesses)
            new_pop = [population[best_idx].copy()]
            
            # Selection
            parents = self.selection(population, fitnesses)
            
            # Crossover and mutation
            for i in range(0, len(parents) - 1, 2):
                child1, child2 = self.crossover(parents[i], parents[i+1])
                new_pop.append(self.mutate(child1))
                new_pop.append(self.mutate(child2))
            
            population = new_pop[:self.pop_size]
            
        return max(population, key=self.fitness)
```

### Operators
- **Selection**: Tournament, roulette, rank
- **Crossover**: One-point, two-point, uniform
- **Mutation**: Bit flip, swap, Gaussian
- **Replacement**: Generational, elitism