Genetic Algorithms in Python and MATLAB

Learn to implement a binary genetic algorithm in MATLAB by defining mean one optimization problem, minimizing the sum of binary variables, and structuring GA parameters like population size and generations.

Initialize a genetic algorithm by creating a random initial population from an empty individual template, assign positions (chromosomes), evaluate costs with the cost function, and prepare for the evolution loop.

Initialize the best solution ever found with an infinity cost so the first candidate wins. Update and store this best solution as the algorithm runs.

Implement the genetic algorithm main loop by initializing a best-cost matrix and running crossover, mutation, and selection over iterations to evolve the population.

Select two random, distinct parents from the population using a random permutation of indices, enabling crossover in each iteration of the genetic algorithm.

Implement single point crossover by randomly choosing a cut point between 1 and n-1 to create two offsprings from two parents, then evaluate and apply mutation if needed.

Define mutation rate mu, convert the population to a single column, mutate genes using a uniform random threshold, and evaluate results.

Merge and sort the population by cost, then select the top members for the next generation. Update the best solution and its cost for the current iteration as you iterate.

Finalize a genetic algorithm by evolving populations through offspring, mutation, merging, and selection of the best, removing extras and repeating until the maximum iterations.

Explore designing and implementing real-valued crossover operators in genetic algorithms, including double-point and uniform crossover, selecting two cutting points, forming offspring, and building a stochastic crossover function.

Explore roulette wheel selection for genetic algorithms, using probabilities, cumulative sums, and a random number to select the winner, normalizing probabilities based on objective values.

Learn to compute Boltzmann-based selection probabilities for genetic algorithms, normalize costs by the average, explore selection pressure, and implement in MATLAB.

Explore a simple yet powerful binary genetic algorithm that evolves a population through selection, crossover, and mutation to minimize a cost function, track best solutions, and prepare for real-valued optimization.

Minimize the real-valued function f(x) over a vector x with components x1 to xn within given bounds. Explore real-valued crossover and mutation operators to solve these continuous optimization problems.

Perform continuous uniform crossover by sampling alphas in [0,1] to form offspring as convex combinations of parents X1 and X2, optionally expanding to [-gamma, 1+gamma] for exploration.

Explore mutation in the continuous domain by sampling delta from a Gaussian distribution with a step size that adapts over time, and implement crossover and mutation in Matlab.

Solve the sphere function with a real-coded genetic algorithm in MATLAB, using five real-valued variables in [-10, 10], and implement uniform crossover and mutation while removing single-point and double-point crossover.

Implement real-coded uniform crossover by using continuous random values to generate real-valued genes. Apply real-coded mutation by adding gaussian steps with zero mean and variance sigma squared on flagged genes.

Finalize a real-coded genetic algorithm in MATLAB by generating random real-valued chromosomes, applying uniform crossover and mutation with a defined sigma, evaluating costs, and tracking the best solution across iterations.

Explore improving the real-coded genetic algorithm by adjusting the uniform crossover range, introducing a gamma parameter, and rerunning to enhance exploration and solution quality.

Enforce variable bounds in genetic algorithms by checking lower and upper bounds after crossover and mutation, before evaluating the cost function, using per-variable bound arrays.

This lecture demonstrates building a from-scratch genetic algorithm in Python to minimize the sphere function, mirroring MATLAB, and defines a problem structure with cost function, variables, bounds, and GA parameters.

Explore the main function of a genetic algorithm by implementing a Ron function, extracting problem information, accessing the cost function, and printing and plotting optimization results.

Initialize the population by defining an empty individual template, creating an initial population, assigning random positions, evaluating costs with the sphere function, and recording results for the first generation.

Track the best solution ever found by deep-copying updated individuals, initialize the best cost to infinity for a minimization problem, and maintain a history of best costs across iterations.

Execute the main loop of a genetic algorithm to produce offspring via crossover and mutation, merge with the population, then evaluate, sort, and select the best individuals.

Select two distinct random indices from 0 to n pop minus one, shuffle population to form a random permutation and choose first two members as parents P1 and P2.

Implement a real-domain uniform crossover that creates two offspring C1 and C2 from parents P1 and P2 using gamma-based equations, with deep copies to handle reference types.

Implement a mutate function to generate two mutated offspring from a solution using a mutation rate and sigma as the step size, applying gaussian perturbations to selected genes.

Define mu and sigma mutation rate and step size. Apply bounds to offspring positions to ensure valid gene ranges during mutation and evaluation.

Evaluate and compare c1 and c2 by cost, update best solution if cheaper, ensure copies for reference types, append offsprings to popC, then merge, sort, and select the next generation.

Merge two populations, sort the merged list by the cost using a lambda key, and select the top individuals for the next generation, implementing merit sort and select.

Implement and run a fully functional genetic algorithm, track the best cost per iteration, and adjust selection, crossover, mutation, population size, and gamma while plotting convergence.

Explore roulette wheel selection and probabilistic resampling in genetic algorithms using Python and MATLAB, including cumulative sums, normalization, and selection probabilities.

Demonstrates using different lower bounds and upper bounds for decision variables in Python and MATLAB, with five variables, showing convergence to an objective value of 16.