Unlock the Power of Genetic Algorithms: 5 Real-World Applications Using PyGAD

Want to solve complex problems with the help of AI? This article dives into the fascinating world of genetic algorithms and how you can implement them using PyGAD, a powerful and user-friendly Python library. We'll explore five diverse genetic algorithm applications, complete with actionable code examples, that will dramatically improve your problem-solving skills. Learn how to leverage these evolutionary techniques for everything from fitting linear models to training neural networks using a genetic algorithm and more.

Why Genetic Algorithms? Discover Simple Solutions to Complex Algorithms.

Genetic algorithms are inspired by the process of natural selection. They're particularly useful for optimization problems where finding the absolute best solution is difficult or impossible. Imagine searching for the optimal design of an airplane wing or the perfect route for a delivery truck. They excel at finding near-optimal solutions in a reasonable time.

Install PyGAD: Your Gateway to Simple Implementation of Genetic Algorithms

Before diving into the applications, let's ensure you have PyGAD installed. Open your terminal or command prompt and run one of the following commands:

Windows:

pip install pygad

MacOS/Linux:

pip3 install pygad

Verify the installation by importing the library in your Python shell.

python
import pygad
print(pygad.__version__)

You're now ready to explore the power of genetic algorithms.

PyGAD Essentials: Setting Up Your Optimization Journey

PyGAD is designed for simplicity. The core of the library is the pygad.GA class. Implementing a genetic algorithm involves these steps:

1. Define a Fitness Function: This function evaluates how "good" each solution is.
2. Set Parameters: Configure settings like the number of generations and the number of parents to select.
3. Create a GA Instance: Initialize an object of the pygad.GA class with your parameters.
4. Run the Algorithm: Start the evolutionary process with the run() method.

Application 1: Fitting a Linear Model with PyGAD

Let's say you have an equation with multiple variables and want to determine the best values that satisfy the equation. A genetic algorithm can do this easily. For demonstration purposes, here is a linear equation:

y = f(w1:w6) = w1x1 + w2x2 + w3x3 + w4x4 + w5x5 + 6wx6

Let's assume the inputs are (4,-2,3.5,5,-11,-4.7) and the output is 44. Create a fitness function that measures how close a solution is to the desired output. The fitness is a maximization function, meaning you must maximize it as the generations evolve. You can achieve this by taking the inverse of the absolute difference between the calculated output and the desired output.

import numpy

function_inputs = [4,-2,3.5,5,-11,-4.7]
desired_output = 44

def fitness_func(solution, solution_idx):
    output = numpy.sum(solution * function_inputs)
    fitness = 1.0 / numpy.abs(output - desired_output)
    return fitness

Next, define key parameters which the fitness function will use to provide values.

sol_per_pop = 50
num_genes = len(function_inputs)

init_range_low = -2
init_range_high = 5

mutation_percent_genes = 1

Then, create an instance of the pygad.GA class using those parameters like below.

ga_instance = pygad.GA(num_generations=num_generations,
                    num_parents_mating=num_parents_mating,
                    fitness_func=fitness_func,
                    sol_per_pop=sol_per_pop,
                    num_genes=num_genes,
                    init_range_low=init_range_low,
                    init_range_high=init_range_high,
                    mutation_percent_genes=mutation_percent_genes)

Finally, run the algorithm to provide the fitness values for each generation!

ga_instance.run()

And voila! You've fit a linear model using a genetic algorithm and PyGAD.

Application 2: Reproducing Images Using Genetic Algorithms

Can a genetic algorithm recreate an image? Absolutely! We start with random pixel values and evolve them to match a target image. The image must be converted to a 1D vector for the genetic algorithm. Here's where the fitness function calculates the difference between the solution image and the target image. This is a great example of genetic algorithm applications.

import imageio
import numpy
import pygad

target_im = imageio.imread('fruit.jpg')
target_im = numpy.asarray(target_im/255, dtype=numpy.float)
target_chromosome = gari.img2chromosome(target_im)

def fitness_fun(solution, solution_idx):
 fitness = numpy.sum(numpy.abs(target_chromosome-solution))

 # Negating the fitness value to make it increasing rather than decreasing.
 fitness = numpy.sum(target_chromosome) - fitness
 return fitness

ga_instance = pygad.GA(num_generations=20000,
 num_parents_mating=10,
 fitness_func=fitness_fun,
 sol_per_pop=20,
 num_genes=target_im.size,
 init_range_low=0.0,
 init_range_high=1.0,
 mutation_percent_genes=0.01,
 mutation_type="random",
 mutation_by_replacement=True,
 random_mutation_min_val=0.0,
 random_mutation_max_val=1.0)

ga_instance.run()

Application 3: Solving the 8 Queen Puzzle with PyGAD

The classic 8 Queen Puzzle involves placing eight queens on a chessboard so that no two queens threaten each other. Using PyGAD you can determine the best placement positions without conflict, and solve a complex logical problem. The fitness function calculates the number of attacks between the queens.

Application 4: Training Neural Networks with Genetic Algorithms

Did you know that genetic algorithms can be used to train neural networks? PyGAD provides specialized modules (pygad.nn and pygad.gann) for this purpose. The algorithm optimizes the weights of the neural network. Optimize performance for a neural network using a genetic algorithm.

Application 5: Training Convolutional Neural Networks (CNNs)

You can even train convolutional neural networks (CNNs) using genetic algorithms and PyGAD. The pygad.cnn and pygad.gacnn modules make this possible. The genetic algorithm is used to optimize the CNN architecture and weights. Achieve unparalleled performance with CNN training through a genetic algorithm.

Level Up Your Problem-Solving

By understanding these five genetic algorithm applications within PyGAD, you're well-equipped to tackle a wide range of optimization problems. With PyGAD's intuitive design and flexible features, unlocking the potential of evolutionary computation has never been more accessible.