Assessment 03

Genetic Algorithm Visualisation

Algorithm Timeout (ms): Population Size: Elite Percentage: Mutation Rate: Generations:

Current Generation: 0

Algorithm Timeout

The Genetic Algorithm works by creating multiple generations of solutions (in this case, binary matrices), and each generation is an iteration of the algorithm where it creates a new set of solutions based on the previous generation.

The "Algorithm Timeout" parameter is used to set a delay between these generations. This delay is implemented using the setTimeout function in JavaScript. The setTimeout function is used to schedule the execution of the next generation after a specified number of milliseconds.

This delay is useful for visualizing the progress of the algorithm over time. Without this delay, the algorithm would run as fast as possible, and it would be difficult to see how the solutions evolve from one generation to the next. By setting a delay, you can slow down the algorithm and watch the evolution of the solutions in real time.

In the ga.js file, the "Algorithm Timeout" parameter is read from the algorithmTimeout input field in the HTML, and it's passed as an argument to the geneticAlgorithm function. Inside the function, this parameter is used to set the delay between generations with the setTimeout function.

Elite Percentage

Elitism is a technique used in Genetic Algorithms to ensure that the best solutions found so far are not lost from one generation to the next. It works by taking a certain number of the top-performing individuals from the current generation and passing them on to the next generation unchanged.

The "Elite Percentage" parameter determines what proportion of the population is considered elite. For example, if the elite percentage is 10% and the population size is 100, then the top 10 individuals will be passed on to the next generation unchanged.

In the ga.js file, the "Elite Percentage" parameter is read from the elitePercentage input field in the HTML, and it's passed as an argument to the geneticAlgorithm function. Inside the function, this parameter is used to calculate the number of elites.

The number of elites is calculated by multiplying the elite percentage by the population size and rounding down to the nearest whole number. These elites are then selected from the population based on their fitness scores and included in the new generation.

Population Size

A Genetic Algorithm works by creating a population of potential solutions and then evolving that population over time. Each potential solution is called an individual. In this case, each individual is a binary matrix.

The "Population Size" parameter determines how many individuals are in each generation. A larger population size means more diversity in the population, which can lead to better solutions. However, it also means more computation is required for each generation, which can slow down the algorithm.

In the ga.js file, the "Population Size" parameter is read from the populationSize input field in the HTML, and it's passed as an argument to the geneticAlgorithm function. Inside the function, this parameter is used to determine the size of the initial population and the size of each subsequent generation.

The initial population is created by generating a number of random binary matrices equal to the population size. In each subsequent generation, a new population of the same size is created by selecting, crossing over, and mutating individuals from the previous generation. The top individuals from the previous generation (the elites) are also included in the new generation to ensure that the best solutions are not lost.

Mutation Rate

Mutation is a key part of Genetic Algorithms. It introduces random changes into the population, which can help to maintain diversity and prevent the algorithm from getting stuck in local optima.

In this case, each individual in the population is a binary matrix, and mutation involves flipping the value of a cell (from 0 to 1 or from 1 to 0). The "Mutation Rate" parameter controls the chance of each cell being flipped during mutation. A higher mutation rate means more randomness, but too much randomness can disrupt the progress of the algorithm.

In the ga.js file, the "Mutation Rate" parameter is read from the mutationRate input field in the HTML, and it's passed as an argument to the geneticAlgorithm function. Inside the function, this parameter is used in the mutate function.

The mutate function goes through each cell in a matrix and flips it with a probability equal to the mutation rate. This is done using a random number generator: if a random number is less than the mutation rate, the cell is flipped; otherwise, it remains the same.

This way, the "Mutation Rate" parameter directly controls the amount of randomness introduced into the population in each generation.

Generations

A Genetic Algorithm works by creating a population of potential solutions and then evolving that population over a number of generations. Each generation is an iteration of the algorithm where it creates a new set of solutions based on the previous generation.

The "Generations" parameter determines how many generations the algorithm will run for. A larger number of generations allows more time for the algorithm to explore the solution space and converge towards an optimal solution. However, it also means more computation is required, which can slow down the algorithm.

In the ga.js file, the "Generations" parameter is read from the generations input field in the HTML, and it's passed as an argument to the geneticAlgorithm function. Inside the function, this parameter is used to control the main loop of the algorithm.

The main loop of the algorithm runs for a number of iterations equal to the "Generations" parameter. In each iteration, it creates a new generation of solutions based on the previous generation, evaluates the fitness of each solution, and selects the best solutions to pass on to the next generation.

In this case, the loop continues until it has run for the specified number of generations or until it finds a solution with a fitness of 0 (which means it has found a solution that satisfies all the constraints).