Practical Genetic Algorithms in Python and MATLAB: Video Tutorial

Genetic algorithms (GAs) are optimization techniques inspired by natural selection and genetic inheritance. Potential solutions are individuals in a population. Through selection, crossover (combining traits) and mutation (introducing variations), the population evolves over generations, and the fittest individuals are favored.

GAs are a subset of Evolutionary Algorithms (EAs), which simulate an artificial environment based on the theory of evolution to solve mathematical problems, especially optimization problems. They also belong to the broader class of metaheuristics, which are general-purpose search methods that need only the values of the objective function.

About the course

The free course “Practical Genetic Algorithms in Python and MATLAB” is taught by Mostapha Kalami Heris on Yarpiz. It has seven videos, about 4 hours and 14 minutes in total, in three parts:

1. Theory. The core ideas of evolutionary algorithms and genetic algorithms, and the main GA operators.
2. MATLAB implementation. A Binary Genetic Algorithm built from scratch, then changed into a Real-Coded Genetic Algorithm.
3. Python implementation. The real-coded GA implemented from scratch in Python with VS Code.

In both MATLAB and Python, the code is run, results are plotted, and parameters are changed to show how the algorithm behaves. The source code from the course is available in the downloads section of this page.

How a genetic algorithm works

The course starts from a general optimization problem: find the vector $x = (x_1, \dots, x_n)$ that minimizes a function $f(x)$. It compares this with evolution in nature, where living forms are solutions to the problem of living in different conditions.

Every evolutionary algorithm follows the same loop. It creates a random initial population, selects members to reproduce, creates offspring, and selects again from parents and offspring, until a stopping condition is met. The GA in the course runs these steps:

1. Initialization. Create and evaluate a random population of $n_{\text{pop}}$ individuals.
2. Crossover. Select pairs of parents. Each pair creates two offspring.
3. Mutation. Mutate the offspring.
4. Merging. Merge the main population and the offspring.
5. Evaluation, sorting and selection. Sort the merged population by cost and keep the best $n_{\text{pop}}$ members.
6. Termination. Stop, or go back to step 2.

Crossover

Crossover combines the genes of two parents. For binary chromosomes, the course shows three operators:

• Single point crossover cuts both parents at one random point and swaps the right-hand parts.
• Double point crossover cuts at two random points and swaps the middle parts.
• Uniform crossover decides gene by gene which parent each gene comes from.

Uniform crossover can be written with a vector $\alpha$ of random zeros and ones:

Mutation

Mutation simulates errors in copying genes. It makes the algorithm more explorative and lets it find new solutions. For binary chromosomes, a mutation flips a gene from 0 to 1 or from 1 to 0. The mutation rate $\mu$ is the share of genes that change. For example, changing 2 genes out of 100 is a mutation rate of 2%.

Parent selection

The course compares three ways to select parents:

• Random selection gives every member the same chance. It is simple, but it ignores the quality of the solutions.
• Tournament selection picks a few members at random and chooses the best of them, or chooses one of them with a probability that is higher for better members.
• Roulette wheel selection gives each member a selection probability, and better members get higher probabilities.

For the roulette wheel, the course uses a rule similar to the Boltzmann distribution. With costs $c_i$ and their mean $\bar{c}$, the selection probability is

The selection pressure $\beta$ controls how strongly the better members are favored. With $\beta = 0$ all members have the same chance. Larger values concentrate selection on the members with lower costs.

Operators for real numbers

When the decision variables are real numbers with lower and upper bounds, the operators change:

• Crossover uses the same blend formula, but each $\alpha_i$ is a real random number. To explore more, it can be drawn from $[-\gamma, 1+\gamma]$ instead of $[0, 1]$, with a small $\gamma$ such as 0.1.
• Mutation adds a random step to the chosen genes, $x_j' = x_j + \sigma z$, where $z$ is drawn from the standard normal distribution. The step size $\sigma$ is an important parameter.
• Bounds. After crossover and mutation, every value outside its range is set back to the nearest bound.

Videos in the course

Play playlistLoads from YouTube

The playlist above contains all seven videos. The topics of each video are listed below, in order, with start times.

1. Introduction to Genetic Algorithms (39:12)

The theory described in the section above, in this order: the optimization problem and evolution (from 1:26), the structure of an evolutionary algorithm (from 4:04), the steps of a GA (from 8:05), crossover (from 12:02), mutation (from 24:17), parent selection (from 29:36), and merging, sorting and truncation (from 34:55).

2. Binary Genetic Algorithm in MATLAB, Part A (43:37)

The test problem is MinOne: minimize $f(x) = \sum_{i=1}^{n} x_i$ with binary $x_i$, whose solution is all zeros. The video writes MinOne.m and a main script app1.m with three sections: problem definition, GA parameters, and a call to out = RunGA(problem, params). It stores the problem and the parameters in structures (from 5:26), builds the population with an individual template and repmat (from 13:25), and creates random binary chromosomes with randi (from 16:04). It keeps the best solution ever found, which starts with a cost of infinity (from 21:25), and an array of best costs per iteration created with nan. In the main loop, the number of offspring comes from a parameter pC and is rounded to an even number (from 27:21). Parents are first chosen at random with randperm (from 32:11), and SinglePointCrossover.m is written (from 35:00).

3. Binary Genetic Algorithm in MATLAB, Part B (36:41)

The video writes Mutate.m, which flips each gene with probability $\mu$ by comparing rand with the mutation rate and using logical indexing (from 0:08). It then evaluates the mutants, merges the populations, sorts them with sort and its second output, and moves the sorting into SortPopulation.m (from 9:34). With iteration information shown with disp, the GA runs for the first time (from 18:56). When the problem grows, single point crossover struggles, and a smaller mutation rate helps (from 20:14). The video then writes DoublePointCrossover.m (from 22:53) and UniformCrossover.m, with a short review of element-wise products in MATLAB (from 28:21). Finally, MyCrossover.m picks one of the three operators at random (from 32:19).

4. Binary Genetic Algorithm in MATLAB, Part C (26:47)

The video explains roulette wheel selection by unrolling the wheel into a line and comparing a random number with the cumulative sum of the probabilities, using cumsum and find (from 0:06). It writes RouletteWheelSelection.m so that the probabilities do not need to add up to 1 (from 9:35). It then derives the selection probabilities from the costs with the Boltzmann type rule and the selection pressure $\beta$ (from 13:34), and handles a mean cost of zero, which first causes an error (from 20:07). The video ends with a review of the whole binary GA and a convergence plot (from 21:30).

5. Real-Coded Genetic Algorithm in MATLAB (31:19)

The video defines real-valued problems with lower and upper bounds, and the real-coded crossover and Gaussian mutation, including the $\gamma$ extension (from 0:07). The test problem is the sphere function, $f(x) = \sum_{i=1}^{n} x_i^2$ (from 6:45). The binary code is copied and changed: real $\alpha$ in the crossover, a step size $\sigma$ in the mutation, and random positions from unifrnd (from 12:08). The convergence plot changes from plot to semilogy (from 18:46), and $\gamma$ becomes a parameter (from 21:22). The video then clips the offspring to the bounds (from 22:43). It shows that each variable can have its own bounds, given as vectors. With one variable limited to $[5, 8]$, the best cost is 25, and without the bound check the GA returns an infeasible answer (from 26:48).

6. Genetic Algorithm in Python, Part A (42:40)

The Python version implements the real-coded GA in two files, app.py and ga.py, with NumPy and Matplotlib. Problem and parameters are stored with the structure class of the ypstruct package, installed with pip install ypstruct (from 1:28). The video writes the function run(problem, params) (from 6:46) and the population, using repeat for the template and np.random.uniform for random positions (from 10:43). Because structures are references, it uses deepcopy for the best solution (from 16:01). It computes the number of offspring, selects random parents with np.random.permutation (from 21:25), and writes crossover with the $\gamma$ extension (from 28:01) and mutate with np.argwhere and np.random.randn (from 33:18).

7. Genetic Algorithm in Python, Part B (33:49)

The video adds the parameters $\mu$ and $\sigma$, and an apply_bound function based on np.maximum and np.minimum (from 0:06). It evaluates the offspring, merges and sorts the population with sorted and a lambda key (from 6:45), and runs the GA for the first time after fixing the type of the offspring count (from 12:10). It draws the convergence plot with Matplotlib, first with plot and then with semilogy (from 13:30). It writes roulette_wheel_selection with np.cumsum and np.argwhere (from 17:34) and adds the Boltzmann type selection probabilities (from 24:15). It ends with different bounds for each variable, where the best cost is 16 (from 29:32), and a remark that most problems can be coded with real variables (from 32:11).

The course code

The download holds the final code of the course:

• MATLAB/Binary GA: app1.m, RunGA.m, MinOne.m, SinglePointCrossover.m, DoublePointCrossover.m, UniformCrossover.m, MyCrossover.m, Mutate.m, RouletteWheelSelection.m and SortPopulation.m.
• MATLAB/Real-Coded GA: app1.m, RunGA.m, Sphere.m, UniformCrossover.m, Mutate.m, RouletteWheelSelection.m and SortPopulation.m.
• Python: app.py and ga.py.

To run a version, open its folder and run app1.m in MATLAB, or app.py in Python. The parameters are set in these files:

The real-coded versions use a different range for each variable. The MATLAB code also uses unifrnd, which comes from the Statistics and Machine Learning Toolbox, so the real-coded MATLAB version probably needs that toolbox.

Check the result

For the binary MinOne example, the minimum cost is 0 at the all-zero chromosome. For the real-coded examples, use the stated bounds when identifying the expected minimum: excluding the origin changes the best feasible Sphere value. Check both the returned variables and the cost after each change to crossover, mutation, or bound handling. The course implementation and the separate MATLAB code package have different defaults, so compare their own parameter tables rather than mixing settings.

Requirements

• Basic programming skills, because the course implements GAs in MATLAB and Python.
• Basic mathematics, such as algebra and some probability.
• MATLAB, Python with NumPy, Matplotlib and ypstruct, and a code editor such as VS Code.

No prior knowledge of genetic algorithms is needed. The course suits students and engineers who work on optimization problems, and anyone interested in AI and algorithms.

Related posts

• Binary and Real-Coded Genetic Algorithms in MATLAB shares another structured GA implementation, with roulette wheel, tournament and random selection.
• YPEA is a MATLAB toolbox with a GA and 14 other algorithms that share one problem definition.

Mostapha Kalami Heris, Practical Genetic Algorithms in Python and MATLAB: Video Tutorial (YPGA191215), Yarpiz, 2020. https://yarpiz.com/practical-genetic-algorithms-in-python-and-matlab-ypga191215

@misc{yarpiz-ypga191215,
  author = {{Mostapha Kalami Heris}},
  title = {{Practical Genetic Algorithms in Python and MATLAB: Video Tutorial}},
  howpublished = {Yarpiz},
  year = {2020},
  note = {Code YPGA191215},
  url = {https://yarpiz.com/practical-genetic-algorithms-in-python-and-matlab-ypga191215}
}