Genetic Algorithms Explained: A Python Implementation Guide

In 2006, NASA launched a satellite called Space Technology 5 (ST5). Bolted to its hull was a small, oddly bent piece of wire — an antenna that looked less like something from JPL and more like a crumpled paper clip designed by a distracted toddler. No human drew it. It was evolved. Starting from a population of random wire shapes, a genetic algorithm iteratively bred better performers over thousands of generations, and the final design outperformed every antenna the human engineers had proposed. It was the first artificial object in space designed by a computational evolutionary process, and it worked beautifully.

That is the promise of genetic algorithms. You do not need to know what the answer looks like. You do not need derivatives, closed-form models, or clever insights. You only need a way to score a candidate solution, and enough patience to let simulated evolution do what biological evolution spent three and a half billion years perfecting. In this guide, we will unpack exactly how a genetic algorithm works, build one from scratch in Python, and examine where they shine and where they fall flat.

The Big Idea: Evolution as a Search Algorithm

Most optimization you learned in school assumed a smooth, well-behaved function. You take the derivative, set it to zero, solve, done. That works beautifully for convex problems like linear regression or logistic regression. It falls apart the moment the landscape gets rugged — non-differentiable, discontinuous, combinatorial, or riddled with local optima. You cannot take the derivative of “which twelve cities should a truck visit in which order.” You cannot gradient-descend a Boolean satisfiability problem.

Nature faced a similar problem. The fitness landscape of biological organisms is hideously complex — high-dimensional, non-differentiable, deceptive — and evolution solved it without any calculus at all. It uses a population, not a single candidate. It measures fitness empirically, not analytically. It reproduces with variation. And over enough generations, it converges on remarkable designs. Genetic algorithms, introduced formally by John Holland in his 1975 book Adaptation in Natural and Artificial Systems, are a computational transcription of this idea.

The Darwinian analogy maps cleanly onto code. A population is a set of candidate solutions. Each candidate is a chromosome, a data structure encoding one possible answer. A fitness function scores how good each candidate is. Selection picks the fittest individuals as parents. Crossover combines two parents into offspring. Mutation injects random variation so the population does not stagnate. Repeat until something good emerges.

When GAs Shine

Genetic algorithms are the right tool when several of the following are true: you have no gradient, the search space is combinatorial (permutations, subsets, graphs), the problem is NP-hard and you need a good solution rather than a proven optimum, you are exploring a design space and want diverse candidates, or you have multiple competing objectives and want a Pareto frontier rather than a single answer.

They have been used to design jet engine components, optimize investment portfolios, schedule airline crews, evolve game-playing AI, tune hyperparameters for neural networks, compress images, and route delivery trucks. Boeing uses evolutionary methods for wing shape refinement. Waste management companies evolve garbage truck routes. Researchers have applied GAs to the 85,900-city “pla85900” Traveling Salesman instance with solutions within a fraction of a percent of the proven optimum.

When NOT to Use GAs

They are also easy to misuse. If your problem is convex and differentiable, gradient descent will find the optimum in a tiny fraction of the time. If the search space is small enough to enumerate, brute force is simpler and exact. If a specialized solver exists — integer linear programming, SAT solvers, mixed-integer programming, dynamic programming — use it. GAs are a tool of last resort for problems where nothing else works well, not a default optimizer.

GA Mechanics, Step by Step

A GA is defined by five design decisions: how to represent a solution, how to score it, how to select parents, how to combine them, and how to mutate offspring. Get these right and the algorithm will converge. Get them wrong and you will waste days watching populations drift aimlessly.

Chromosome Representation

The chromosome is how you encode a candidate solution as data. The representation profoundly affects everything that follows — which crossover and mutation operators are valid, how hard it is to generate valid solutions, and how smoothly the fitness landscape maps onto the genotype.

• Binary strings: the classical Holland-style encoding. A candidate might be [1,0,1,1,0,0,1,0]. Works naturally for feature selection, knapsack problems, and anywhere the decisions are on/off.
• Real-valued vectors: a list of floats. Natural for continuous optimization like tuning a physical parameter or minimizing a mathematical function. Most modern GAs use this.
• Permutations: an ordering of items, like the sequence of cities in a TSP tour. Requires specialized operators that preserve the permutation property.
• Trees: used in Genetic Programming, where the chromosome is an expression tree representing an actual program. This is how Koza’s famous GP work evolved symbolic regression formulas.

The Fitness Function — the Most Important Decision

If there is one place where GAs go wrong, it is here. The fitness function defines what “better” means, and the algorithm will relentlessly optimize it. If your fitness function has a loophole, evolution will find it — the AI safety community calls this “specification gaming” and it shows up in evolutionary systems all the time. A famous example: a GA tasked with evolving fast simulated creatures evolved extremely tall, thin creatures that fell over rapidly and “moved” by converting height into forward momentum. Technically correct, entirely useless.

A good fitness function is cheap to evaluate (you will call it millions of times), smooth enough to provide gradient information (“close” solutions should have similar fitness), and watertight against loopholes. For constrained problems, you typically add penalty terms for constraint violations rather than throwing away invalid chromosomes outright.

Selection Methods

Selection picks the parents that will produce the next generation. There is a fundamental tension here between exploitation (favoring the current best) and exploration (keeping diversity). Too much exploitation and you converge prematurely to a local optimum. Too much exploration and you essentially do random search.

In practice, most modern GA implementations use tournament selection with k=3 combined with small elitism (keep the top 1–5%). Tournament selection is simple, scale-invariant, and easy to parallelize. It also degrades gracefully — if two candidates have nearly equal fitness, the competition is roughly a coin flip, preserving diversity.

Crossover (Recombination)

Crossover is the engine of innovation. It takes two parent chromosomes and combines them to produce offspring, recombining existing good building blocks into new configurations. The hope — formalized in Holland’s schema theorem — is that short, high-fitness sub-patterns will propagate through the population even as whole chromosomes come and go.

Mutation

Mutation injects randomness. Without it, the gene pool can only shuffle existing alleles — once a position has converged across the population (every chromosome has the same value there), crossover cannot restore diversity. Mutation rate is typically small (0.5% to 5% per gene) because too much mutation turns the GA into random search. A useful heuristic: mutation rate ≈ 1/L, where L is chromosome length, so on average one gene mutates per offspring.

Termination Criteria

When do you stop? Common choices: a fixed number of generations (simplest), a wall-clock time budget, hitting a target fitness threshold, or detecting a fitness plateau (no improvement in the best or average fitness for N generations). In competitions and time-constrained production settings, you usually use a time budget. For research, fixed generations are reproducible.

A Full Python Implementation from Scratch

Let’s build a complete GA that can minimize the Rastrigin function — a classic non-convex optimization benchmark defined as f(x) = 10n + Σ [xi2 − 10 cos(2πxi)]. It has a single global minimum at the origin and dozens of local minima nearby, which makes it perfect for illustrating why gradient descent struggles and why a population-based search helps.

import numpy as np
import random
from dataclasses import dataclass, field
from typing import Callable, List, Optional, Tuple


@dataclass
class GAConfig:
    """Configuration for the genetic algorithm."""
    pop_size: int = 100
    gene_count: int = 10
    gene_low: float = -5.12
    gene_high: float = 5.12
    crossover_rate: float = 0.8
    mutation_rate: float = 0.1          # per-gene probability
    mutation_sigma: float = 0.3         # std dev of Gaussian noise
    tournament_k: int = 3
    elitism: int = 2
    generations: int = 300
    seed: Optional[int] = 42


class GeneticAlgorithm:
    """A real-valued genetic algorithm for continuous optimization.

    Minimizes fitness_fn. If you have a maximization problem, negate it.
    """

    def __init__(self, fitness_fn: Callable[[np.ndarray], float], config: GAConfig):
        self.fitness_fn = fitness_fn
        self.cfg = config
        if config.seed is not None:
            random.seed(config.seed)
            np.random.seed(config.seed)

        self.population: np.ndarray = self._init_population()
        self.fitness: np.ndarray = self._evaluate(self.population)
        self.history: List[dict] = []

    # -------- Initialization --------
    def _init_population(self) -> np.ndarray:
        c = self.cfg
        return np.random.uniform(c.gene_low, c.gene_high, size=(c.pop_size, c.gene_count))

    def _evaluate(self, pop: np.ndarray) -> np.ndarray:
        return np.array([self.fitness_fn(ind) for ind in pop])

    # -------- Selection --------
    def _tournament(self) -> np.ndarray:
        """Tournament selection: pick k at random, return the best."""
        idx = np.random.randint(0, self.cfg.pop_size, self.cfg.tournament_k)
        best = idx[np.argmin(self.fitness[idx])]
        return self.population[best].copy()

    # -------- Crossover --------
    def _crossover(self, p1: np.ndarray, p2: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
        """Blend crossover for real values: child = alpha*p1 + (1-alpha)*p2."""
        if random.random() > self.cfg.crossover_rate:
            return p1.copy(), p2.copy()
        alpha = np.random.uniform(-0.25, 1.25, size=p1.shape)  # BLX-alpha style
        c1 = alpha * p1 + (1 - alpha) * p2
        c2 = alpha * p2 + (1 - alpha) * p1
        return self._clip(c1), self._clip(c2)

    def _clip(self, x: np.ndarray) -> np.ndarray:
        return np.clip(x, self.cfg.gene_low, self.cfg.gene_high)

    # -------- Mutation --------
    def _mutate(self, ind: np.ndarray) -> np.ndarray:
        mask = np.random.random(ind.shape) < self.cfg.mutation_rate
        noise = np.random.normal(0.0, self.cfg.mutation_sigma, size=ind.shape)
        ind = ind + mask * noise
        return self._clip(ind)

    # -------- Evolution loop --------
    def run(self) -> Tuple[np.ndarray, float]:
        c = self.cfg
        for gen in range(c.generations):
            # Sort by fitness (ascending — we minimize)
            order = np.argsort(self.fitness)
            self.population = self.population[order]
            self.fitness = self.fitness[order]

            # Elitism: keep top N unchanged
            new_pop = [self.population[i].copy() for i in range(c.elitism)]

            # Fill the rest via selection + crossover + mutation
            while len(new_pop) < c.pop_size:
                p1 = self._tournament()
                p2 = self._tournament()
                c1, c2 = self._crossover(p1, p2)
                new_pop.append(self._mutate(c1))
                if len(new_pop) < c.pop_size:
                    new_pop.append(self._mutate(c2))

            self.population = np.array(new_pop)
            self.fitness = self._evaluate(self.population)

            best_idx = int(np.argmin(self.fitness))
            self.history.append({
                "generation": gen,
                "best_fitness": float(self.fitness[best_idx]),
                "mean_fitness": float(self.fitness.mean()),
                "best_chromosome": self.population[best_idx].copy(),
            })

            if gen % 20 == 0:
                print(f"Gen {gen:4d} | best={self.fitness[best_idx]:.6f} | mean={self.fitness.mean():.4f}")

        best_idx = int(np.argmin(self.fitness))
        return self.population[best_idx], float(self.fitness[best_idx])


# -------- Example: Rastrigin function --------
def rastrigin(x: np.ndarray) -> float:
    A = 10.0
    return A * len(x) + np.sum(x * x - A * np.cos(2 * np.pi * x))


if __name__ == "__main__":
    cfg = GAConfig(pop_size=120, gene_count=10, generations=300)
    ga = GeneticAlgorithm(rastrigin, cfg)
    best_x, best_f = ga.run()
    print(f"\nBest solution: {best_x}")
    print(f"Best fitness:  {best_f:.6f}  (true minimum = 0.0 at x = 0)")

Run this and you will watch the best fitness drop from around 80–100 (random initialization on a 10-dimensional Rastrigin) down to something close to zero within a few hundred generations. The population converges visibly — print self.population.std(axis=0) and you will see the spread shrink generation by generation.

A Second Example: Traveling Salesman

The Rastrigin example uses real-valued chromosomes with blend crossover. TSP needs permutation chromosomes and a specialized order crossover (OX) that preserves the permutation property. Here is a compact implementation.

import numpy as np
import random


def tour_length(tour: list, dist: np.ndarray) -> float:
    return sum(dist[tour[i], tour[(i + 1) % len(tour)]] for i in range(len(tour)))


def order_crossover(p1: list, p2: list) -> list:
    """OX: copy a slice from p1, fill the rest from p2 in order, skipping duplicates."""
    n = len(p1)
    a, b = sorted(random.sample(range(n), 2))
    child = [None] * n
    child[a:b] = p1[a:b]
    fill = [g for g in p2 if g not in child[a:b]]
    j = 0
    for i in range(n):
        if child[i] is None:
            child[i] = fill[j]
            j += 1
    return child


def swap_mutation(tour: list, rate: float = 0.02) -> list:
    tour = tour[:]
    for i in range(len(tour)):
        if random.random() < rate:
            j = random.randrange(len(tour))
            tour[i], tour[j] = tour[j], tour[i]
    return tour


def tournament(pop, fitnesses, k=3):
    idx = random.sample(range(len(pop)), k)
    return pop[min(idx, key=lambda i: fitnesses[i])]


def ga_tsp(coords: np.ndarray, pop_size=200, generations=500, elite=4):
    n = len(coords)
    # Precompute distance matrix
    dist = np.linalg.norm(coords[:, None, :] - coords[None, :, :], axis=-1)

    population = [random.sample(range(n), n) for _ in range(pop_size)]
    fitnesses = [tour_length(t, dist) for t in population]

    for gen in range(generations):
        order = sorted(range(pop_size), key=lambda i: fitnesses[i])
        population = [population[i] for i in order]
        fitnesses = [fitnesses[i] for i in order]

        new_pop = population[:elite]
        while len(new_pop) < pop_size:
            p1 = tournament(population, fitnesses)
            p2 = tournament(population, fitnesses)
            child = order_crossover(p1, p2)
            child = swap_mutation(child, rate=0.02)
            new_pop.append(child)

        population = new_pop
        fitnesses = [tour_length(t, dist) for t in population]

        if gen % 50 == 0:
            print(f"Gen {gen:4d} | best tour length = {min(fitnesses):.2f}")

    best = min(range(pop_size), key=lambda i: fitnesses[i])
    return population[best], fitnesses[best]


if __name__ == "__main__":
    np.random.seed(0)
    random.seed(0)
    coords = np.random.rand(30, 2) * 100  # 30 random cities in a 100x100 square
    tour, length = ga_tsp(coords)
    print(f"\nBest tour length: {length:.2f}")

On 30 random cities, this converges to near-optimal tours in about 500 generations on a laptop. For serious TSP work you’d combine it with a local-search step like 2-opt after each generation (a memetic algorithm) — that hybrid approach is what solved the 85,900-city instance to within 0.04% of optimum.

Real-World Applications

GAs are used wherever the search space is rough and the objective is clear. Here are the categories where they have had the greatest impact.

Engineering Design

NASA’s ST5 antenna is the iconic example — the evolved design met the mission’s bandwidth, gain, and radiation-pattern requirements simultaneously, something human antenna engineers had failed to achieve for that form factor. Boeing has used evolutionary methods for wing-shape refinement in computational fluid dynamics loops, where each fitness evaluation is an expensive CFD simulation. Automotive crashworthiness teams evolve body-panel geometry to distribute impact energy. In all of these, the search space is massive, gradients are expensive or unavailable, and you don’t know what the right answer looks like until you find it.

Scheduling and Routing

University timetabling, airline crew scheduling, hospital shift rostering, and factory job-shop scheduling are combinatorial nightmares — hard-constraint-laden, NP-hard, with thousands of interdependent decisions. GAs with domain-specific repair operators (making sure the schedule is feasible after crossover) are a workhorse here. Vehicle routing problems for delivery logistics — variants of TSP with capacity, time-window, and driver-hour constraints — similarly benefit, and many commercial routing solvers use GAs alongside local search.

Machine Learning

In machine learning, GAs show up in three places. First, hyperparameter optimization — evolving learning rates, batch sizes, regularization strengths. This is competitive with Bayesian optimization when the search space has integer or categorical dimensions. Second, feature selection — evolving binary masks over input features to find the most predictive subset, relevant for small-data regimes and interpretable models. Third, neural architecture search via methods like NEAT and NeuroEvolution, where entire network topologies are evolved. OpenAI’s 2017 paper on “Evolution Strategies as a Scalable Alternative to Reinforcement Learning” showed ES could rival deep RL on Atari and MuJoCo with much simpler, embarrassingly parallel code.

For time-series heavy workflows, GAs are a natural fit for tuning forecasting model ensembles and for selecting detector thresholds in anomaly detection pipelines where the objective mixes precision, recall, and alert fatigue constraints that no gradient can cleanly express.

Finance

Portfolio optimization with non-convex constraints — integer position sizing, cardinality constraints (hold at most 30 of 500 assets), transaction costs, and tax-lot accounting — breaks classical mean-variance optimization. GAs handle these cleanly because the fitness function can include anything representable in Python.

Game AI and Design

Evolving game-playing strategies has a long history — from tic-tac-toe policies to checkers heuristics to StarCraft build orders. Procedural content generation in games (levels, creatures, weapons) sometimes uses GAs to evolve items that satisfy designer-specified fitness functions while remaining diverse.

Advanced Topics: NSGA-II, GP, and Hybrids

Multi-Objective Optimization: NSGA-II

Real problems rarely have one objective. You want a portfolio with high return AND low risk. A car design with high safety AND low weight AND low cost. A neural architecture with high accuracy AND low latency. In classical optimization you’d pick weights and scalarize, which forces you to commit to trade-offs up front. Multi-objective GAs instead find the Pareto frontier — the set of solutions where improving any one objective would worsen another.

NSGA-II (Deb et al., 2002) is the standard algorithm here. Instead of a scalar fitness, each individual has a vector of objective values, and the population is ranked by non-dominated sorting: front 1 contains all solutions not dominated by any other; front 2 contains solutions dominated only by front 1; and so on. Ties within a front are broken by crowding distance, which prefers solutions in less-crowded regions to preserve diversity along the frontier. The result is a GA that returns not one answer but an entire Pareto-optimal set, letting a human decide which trade-off to deploy.

Genetic Programming

Ordinary GAs evolve fixed-length chromosomes. Genetic programming, developed by John Koza in the early 1990s, evolves expression trees — actual programs. A chromosome might be the parse tree for (x + 3) * sin(y). Crossover swaps random subtrees; mutation replaces a node with a new random subtree. GP has been used for symbolic regression (finding formulas that fit data), evolving controllers for robots, and automatic algorithm design. It’s a striking approach that feels almost like watching code write itself.

Hybrid and Parallel Methods

Pure GAs are often outperformed by memetic algorithms that combine a GA with a local search step — each generation, every (or a fraction of) offspring get improved via hill-climbing or a problem-specific heuristic like 2-opt for TSP. The GA handles exploration; local search handles refinement. For the 85,900-city TSP instance mentioned earlier, the winning approach was a memetic algorithm with Lin-Kernighan local search.

Island model GAs run several populations in parallel on different processes, with occasional migration of a few individuals between islands. This preserves diversity (each island can converge to a different basin) and maps cleanly to multi-core and distributed infrastructure. Orchestrating these experiments with tools like Apache Airflow is a convenient way to manage long-running evolutionary campaigns with checkpointing.

Related Methods

GAs sit in a family of population-based or stochastic methods. Particle Swarm Optimization (PSO) uses swarming behavior without crossover. Differential Evolution (DE) is excellent for continuous optimization and often outperforms GAs on real-valued problems. CMA-ES adapts a covariance matrix to the landscape and is the gold standard for smooth-but-hard continuous optimization. Simulated Annealing uses a single candidate with a cooling temperature and is simple, effective, and often underestimated. On any given problem, one of these methods will likely beat GAs — worth trying several and benchmarking.

Practical Tips for Making GAs Work

Use these as starting points, then tune. A few rules of thumb that tend to hold across problems:

• Always use elitism — keep the top 1–5%. Without elitism you can lose your current best to bad luck in crossover or mutation. With 100% elitism you’ll converge prematurely.
• Tune mutation rate by watching diversity. If the standard deviation of the population collapses too fast, you need more mutation. If the best fitness oscillates wildly, you have too much.
• Seed the initial population intelligently when you can. A few hand-crafted known-good solutions among the random ones can accelerate convergence dramatically.
• Detect convergence and restart. If fitness plateaus for 50 generations, it’s often worth re-randomizing all but the top few individuals. A single run converging to a local optimum is fate; multiple restarts are science.
• Parallelize fitness evaluation. Fitness is almost always the bottleneck. Use multiprocessing.Pool or Ray — each individual’s fitness is independent, so this is embarrassingly parallel.
• Write reproducible code. Seed your RNGs, log each generation’s stats, save checkpoints. GAs are stochastic and debugging them without reproducibility is agony. Our team adheres to clean-code principles and keeps experiment configs under version control for exactly this reason.

Python Libraries: DEAP, PyGAD, pymoo, inspyred

You don’t need to roll your own for production work. Several mature Python libraries exist, each with different design philosophies.

For most production use today, DEAP is the Swiss Army knife and pymoo is the go-to for multi-objective work. PyGAD is what you reach for when a data scientist wants to evolve hyperparameters or weights without thinking too hard about operators. Here’s a minimal DEAP sketch for context.

from deap import base, creator, tools, algorithms
import random, numpy as np

creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
creator.create("Individual", list, fitness=creator.FitnessMin)

toolbox = base.Toolbox()
toolbox.register("gene", random.uniform, -5.12, 5.12)
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.gene, 10)
toolbox.register("population", tools.initRepeat, list, toolbox.individual)

def rastrigin(ind):
    x = np.array(ind)
    return (10 * len(x) + np.sum(x * x - 10 * np.cos(2 * np.pi * x))),

toolbox.register("evaluate", rastrigin)
toolbox.register("mate", tools.cxBlend, alpha=0.3)
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=0.3, indpb=0.1)
toolbox.register("select", tools.selTournament, tournsize=3)

pop = toolbox.population(n=120)
hof = tools.HallOfFame(1)
algorithms.eaSimple(pop, toolbox, cxpb=0.8, mutpb=0.2, ngen=300, halloffame=hof, verbose=False)
print("Best:", hof[0], "fitness:", hof[0].fitness.values)

Limitations and Pitfalls

GAs are powerful and genuinely useful, but they are heuristics, not magic. It’s worth being blunt about the failure modes.

• No convergence guarantee. Unlike gradient descent on convex problems, there is no theorem that says “if you run long enough you’ll find the global optimum.” Schema theorem and related results tell you about expected propagation of building blocks, not about optimality.
• Tuning is art, not science. Population size, mutation rate, crossover rate, selection pressure, elitism — all interact, and the right settings are problem-dependent. Expect to spend significant time tuning.
• Expensive fitness functions kill you. A GA with population 100 running 300 generations does 30,000 fitness evaluations. If each one is a CFD simulation taking ten minutes, that’s 208 CPU-days. Surrogate models (cheap approximations used inside the GA, with occasional true evaluations) mitigate this but add complexity.
• Premature convergence to local optima is the default failure mode. Too much selection pressure, too little mutation, not enough diversity preservation — all lead to a converged but suboptimal population. Diagnostics: watch population diversity (standard deviation of genes) over time.
• Fitness function design is where most projects fail. If your fitness function is wrong, the GA will optimize the wrong thing with terrifying efficiency. Evolution does not care about your intent; it cares about your objective.
• Performance is modest compared to specialized methods. On convex or near-convex continuous problems, well-implemented gradient methods or quasi-Newton methods will usually beat a GA by orders of magnitude.

None of this means GAs are bad. It means they are a tool for specific jobs — black-box, combinatorial, multi-objective, or design-space problems — and when you use them outside that niche, you will be disappointed.

Frequently Asked Questions

When should I use a Genetic Algorithm instead of gradient descent?

Use gradient descent whenever the objective is differentiable and the search space is continuous — it will always be faster. Reach for a GA when you have a combinatorial search space (permutations, subsets, graphs), a non-differentiable objective, multiple competing objectives, a black-box simulator as your fitness function, or when you need to explore a design space rather than find a single best point.

Are Genetic Algorithms still relevant in the era of deep learning?

Yes, in specific niches. Deep learning dominates when you have gradients, data, and a smooth parameterization. GAs complement deep learning in hyperparameter optimization, neural architecture search (NEAT, regularized evolution), reinforcement learning (OpenAI ES rivals policy gradient on many tasks), and domain-specific design problems where the fitness function is an engineering simulation rather than a loss on labeled data. They are also widely used in non-ML engineering optimization where deep learning simply doesn’t apply.

How do I choose population size and mutation rate?

Start with population size 100–200 and mutation rate ≈ 1/L (where L is chromosome length). Then watch diagnostics: if the population diversity collapses fast, increase mutation or population size. If the best fitness jitters without improving, decrease mutation. Harder problems need larger populations; finer-grained search needs lower mutation. Always run several seeds and report averages — GAs are stochastic and a single run tells you little.

Can GAs train neural networks?

They can, but for supervised learning with large networks, backpropagation is vastly more efficient. Where evolutionary methods are competitive is in reinforcement learning (OpenAI’s Evolution Strategies paper), neural architecture search, and small-network tasks where gradients are noisy or unavailable. NEAT famously evolved both weights and topology simultaneously. For a typical image classification or language model, stick to backprop.

What’s the difference between a Genetic Algorithm and Genetic Programming?

A Genetic Algorithm evolves fixed-length chromosomes (bit strings, real vectors, permutations) representing parameters or choices. Genetic Programming evolves variable-size tree structures that represent actual programs or expressions — e.g., the formula sin(x) + 2y. GP is a specialization of GAs for the case where you want to evolve computation itself rather than parameter values.

References and Further Reading

• Holland, J. H. (1975). Adaptation in Natural and Artificial Systems. University of Michigan Press. The original formulation of genetic algorithms.
• Hornby, G. S., Globus, A., Linden, D. S., & Lohn, J. D. (2006). “Automated Antenna Design with Evolutionary Algorithms.” AIAA Space. The NASA ST5 antenna paper.
• Deb, K., Pratap, A., Agarwal, S., & Meyarivan, T. (2002). “A fast and elitist multiobjective genetic algorithm: NSGA-II.” IEEE Transactions on Evolutionary Computation. The canonical multi-objective reference.
• Koza, J. R. (1992). Genetic Programming: On the Programming of Computers by Means of Natural Selection. MIT Press.
• Salimans, T., Ho, J., Chen, X., Sidor, S., & Sutskever, I. (2017). “Evolution Strategies as a Scalable Alternative to Reinforcement Learning.” arXiv:1703.03864.
• DEAP documentation — distributed evolutionary algorithms in Python.
• pymoo documentation — multi-objective optimization in Python.
• PyGAD documentation — beginner-friendly GA library with ML integration.

Disclaimer: The financial and portfolio examples in this article are for informational purposes only and do not constitute investment advice. Evolutionary methods applied to financial data are particularly prone to overfitting; any strategy developed via GA should be rigorously validated out-of-sample and stress-tested before real-world use.