Optimization with Metaheuristics in Python

Simulated annealing, a probabilistic metaheuristic derived from the Metropolis algorithm, models cooling in a heat bath to perform local search and converge toward an optimal solution.

Explore how simulated annealing uses temperature, cooling rate, and probabilistic acceptance of worse moves to escape local minima and converge to better solutions.

This lecture explains simulated annealing basics, including initial and final solutions, the objective function, temperature schedules, cooling rate, neighborhood moves, and probabilistic acceptance of worse moves.

Apply simulated annealing to a continuous optimization problem in Python by minimizing the Himmelblau function, noting four global minima between -6 and 6.

Implement simulated annealing on the Himmelblau continuous problem in Python, using numpy and matplotlib to minimize the objective function and visualize progress.

Explore simulated annealing in Python for the Himmelblau objective, starting from a point and moving through neighborhood solutions, while tuning initial temperature, M, N, alpha, and K for small steps.

Explore neighborhood search in Python, starting at a point and moving to neighboring (X, Y) solutions with random steps and temperature-based acceptance for better or worse neighbors.

Explore simulated annealing for continuous optimization, comparing current and neighbor solutions in x and y. Learn when to accept worse moves using a probabilistic rule based on the objective function.

Learn how simulated annealing solves a continuous problem with an outer loop and inner 15-neighbor searches, updating temperature by alpha to converge on X, Y, and the objective value.

Run the simulated annealing process multiple times to explore different outcomes for a continuous problem, recording X, Y, and Z values, and plot temperature versus Z.

Plot the simulated annealing results by showing temperature on the x-axis and the final objective value for each M across 300 steps, as the Himmelblau function is minimized.

Plot the simulated annealing results for the Himmelblau function, linking temperature schedules (initial to final) with objective values, and compare how different M and N settings affect convergence.

Explore coding a combinatorial quadratic assignment problem with simulated annealing in Python, building distance and flow matrices, and minimizing total cost by optimal department placement.

Configure simulated annealing parameters, generate a random initial solution, reindex the distance matrix, convert to an array, and compute the cost as distance times flow to obtain the objective value.

Explore solving the quadratic assignment problem with simulated annealing in Python by swapping departments, computing cost as flow times distance, and cooling to minimize the objective.

Genetic algorithm drives population-based search using evolution-inspired mechanisms, natural selection, reproduction, survival of the fittest, and encodes solutions in binary chromosomes, mapping genotype to phenotype through crossover and mutation.

Delve into genetic algorithms by exploring crossover (two-point, single-point, multi), mutation with bit flips, and elitism guided by fitness values, plus selection methods like roulette wheel and tournament selection.

Decode a binary string for continuous problems by bounding the variable, selecting chromosome length, and computing precision to derive the fitness, with genotype as encoding and phenotype as decoding.

Explore how a genetic algorithm runs from a written pseudocode to a flowchart, detailing generations, population size, crossover and mutation probabilities, tournament selection, elitism, and choosing the best final chromosome.

Evolve a population across generations in a genetic algorithm by tournament selection of two parents, two-point crossover, and mutation, while tracking the best chromosome for the final solution.

Code a genetic algorithm from scratch for continuous optimization using the Himmelblau function. Minimize the objective to zero and locate the four global minima.

Decode binary chromosomes for a genetic algorithm into X and Y values using bitwise summation and precision, then minimize the Himmelblau objective function within defined bounds in Python.

Decode x and y from a 24-gene chromosome using bounds (-6, 6) and precision, then compute the objective value f(x,y) = x^2 + (y-11)^2 to evaluate the continuous problem.

Decode a chromosome into X and Y, compute the himmelblau objective value, and return decoded X, decoded Y, and the objective value via a single function.

Select two parents via tournament selection by decoding x and y from the chromosome and computing the himmelblau objective value to drive cross over and mutate in minimization problem.

Create a population of 20 solutions by shuffling chromosomes, with 12 genes (6 x, 6 y); decode x and y, and evaluate fitness with Himmelblau to select two parents.

Select three unique candidates from the initial population of 12-gene solutions using tournament selection, evaluate their objective function values, and choose the best as each parent.

Apply tournament selection with three randomly chosen chromosomes, decode to X and Y, and use the Himmelblau objective value to select the lowest fitness as the first parent.

Use tournament selection with k=3 to pick two parents for crossover by looping twice, storing them in an empty array, and selecting the lowest fitness values for a minimization problem.

Learn tournament-based parent selection in a genetic algorithm with Python: define a reusable find_parents function, select three individuals, compare fitness for minimization, and return two parents.

explore two-point crossover in genetic algorithms for continuous problems, showing how to select two crossover points, guarantee different indices, and apply 100% crossover to generate children while preserving genetic information.

Learn two-point crossover in Python for problems by dividing each parent into three segments to create two children, using left-to-right indices and smaller to parent one, larger to parent two.

Explore the crossover operator in a genetic algorithm for continuous problems using Python, showing how to form children from two parents' first, middle, and last segments with a default probability.

Explore the mutation operator for a continuous binary GA, applying bit-flip mutation to generate diversity, with a 0.3 probability and experiments with high and low rates using child updates.

Mutate a chromosome with a 0.3 probability across indices 0 to 5, updating the first child and printing before and after states. Mirror the mutation for a second child.

Explore how a genetic algorithm mutates a child by applying a mutation probability to each gene, flipping bits when a random number is below the threshold, with 0/1 sequences illustrated.

Develop and test a python mutation function for two child arrays in a genetic algorithm, using a default 0.2 probability to flip each gene.

Learn to structure a genetic algorithm for continuous problems by isolating GA functions in a reusable ga_functions_continuous.py file, using tournament selection, crossover, and mutation for Himmelblau.

Implement a genetic algorithm in python to minimize the continuous himmelblau problem, using a 200-solution population over 180 generations with crossover and mutation.

Initialize a 200-solution pool with 13 x and 13 y genes, run 180 generations, use parent and mutation steps, track objective values, and plot the best per generation.

Explore a genetic algorithm approach for continuous optimization in python, detailing population initialization, selection of two parents, crossover, mutation, and maintaining a 200-solution generation across cycles.

Compute fitness values for two mutant chromosomes by evaluating their objective functions, pair each chromosome with its objective value, and prepare generation tracking in a continuous genetic algorithm using Python.

Construct each generation by spawning a random initial population and then stacking two mutant children to build a 200-solution new population. Track solution's objective value for the next generation.

Describe running a genetic algorithm with a 200-solution population, selecting parents, creating mutant children, and forming generations while tracking solutions by objective value in a minimization problem.

Explore how to extract the global minima in a genetic algorithm by comparing convergence from the last population with the best-of-generation approach, and decode the final X and Y strings.

Decode converged and best genetic algorithm strings to get decoded X and Y and their objective values, illustrating progression across generations for the Himmelblau function.

Experiment with a genetic algorithm on the Himmelblau function using a larger population and more generations, exploring crossover and a 30% mutation rate to approach global minima.

Extract the best converged and best overall objective values from generations, and plot the best-of-generation values across generations with matplotlib, including red dashed reference lines and axes labels.

Code a ga to solve the quadratic assignment problem in python, building distance and flow matrices and an initial random solution to minimize flow times distance.

Apply a genetic algorithm in python with tournament selection, crossover 1, mutation 0.3, and elitism to evolve a 100-solution population over 30 generations for eight-department problem, minimizing distance times flow.

Learn to implement a two-cut-point crossover for a combinatorial problem in Python: choose cut points, build middle and first segments, and assemble feasible offspring by removing duplicates.

Mutate two offspring by selecting two random indices and reversing the segment between them, handling a1 and a2 order, then compute distance, total cost, and update fitness for each mutant.

Apply genetic algorithm techniques in Python to solve a quadratic assignment problem by mutating, stacking, and elitist selection across generations to find the minimum cost solution.

Explore tabu search, a 1986 local neighborhood search method by Fred Glover for combinatorial problems, using a tabu list to prohibit revisiting solutions within a set number of iterations.

Explore tabu search fundamentals: tabu list memory, aspiration criteria, intensification versus diversification, and short term, intermediate term, long term memory with frequency based memory.

Explore tabu search fundamentals by configuring iterations, tabu list length, and move operators, swap two cities in a traveling salesman problem, and use aspiration criteria to diversify and avoid cycling.

Code the quadratic assignment problem with tabu search, using distance and flow matrices, a random initial solution, and a swap-based neighborhood to compute costs as flow times distance.

Explore coding a combinatorial problem in Python by running 60 iterations, generating 28 neighbor solutions via two-department swaps, and computing costs as distance times flow, then sorting by objective values.

This lecture demonstrates tabu search for the quadratic assignment problem, using department swaps, a dynamic tabu list, and aspiration criteria to reach the best solution after 60 runs.

Explore evolutionary strategies for continuous problems, focusing on mutation-driven search, mu and lambda variations, and parent–offspring competition in a population-based framework.

Explore evolutionary strategies, where mutation is the primary operator and recombination designs new parents; learn how many children exceed parents, how sigma governs mutations, and the one-fifth rule.

Implement evolution strategies by mutating to form lambda children from mu parents, then select the best mu to replace the population while adjusting sigma via the one fifth rule (0.82–0.85).

Code an evolution strategies approach to minimize a continuous two-variable cosine function in Python, with 120 parents and 720 children within defined bounds and initial sigmas.

Develops a continuous optimization workflow in Python by evolving a random initial population, selecting five random parents, creating children with gaussian mutations, and applying the one fifth rule.

Apply evolution strategies in Python to a continuous problem, tracking parents and children, using the one fifth rule to adapt sigma, and converge on x1 and x2.

Learn constraint handling in optimization by discarding, repairing, or penalizing infeasible solutions to stay within the feasible region for both minimization and maximization problems. Includes a chair and table example.

Use a penalty function to handle two constraints in a genetic algorithm, decoding binary chromosomes into x and y within -5 to 5 to approach the global minimum.

Apply penalty functions to handle constraints in a genetic algorithm, adding penalties when X or Y violate bounds. Learn about decoding, selection, crossover, mutation, and elitism in a minimization setting.