Master Genetic Algorithms with PyGAD: 5 Practical Applications

Unlock the power of genetic algorithms (GAs) and discover how to apply them to real-world problems using the PyGAD library. This comprehensive guide explores genetic algorithm applications with practical examples and step-by-step instructions, making complex concepts accessible to everyone. Learn how to use PyGAD, a powerful Python library, to implement and customize GAs for diverse challenges.

Why Use Genetic Algorithms?

Genetic algorithms are powerful optimization techniques inspired by natural selection. The process mimics the mechanics of biological evolution and adaptation to optimize a problem. They excel at finding optimal or near-optimal solutions for complex problems where traditional methods struggle.

• Flexibility: GAs can be used to solve a wide range of problems across different domains.
• Robustness: They are less susceptible to getting stuck in local optima compared to other optimization algorithms.
• Adaptability: GAs can adapt to changing problem landscapes, making them suitable for dynamic environments.

What You'll Learn: PyGAD and Genetic Algorithm Applications

This tutorial provides hands-on experience with real-world genetic algorithm examples. You’ll discover how to:

• Install and set up PyGAD.
• Understand the fundamental concepts of genetic algorithms.
• Apply GAs to solve practical problems.

Here's a sneak peek at the 5 applications covered:

• Fitting a linear model using the genetic algorithm
• Reproducing images with evolving pixel values.
• Solving the classic 8 Queen Puzzle.
• Training a neural network.
• Training a convolutional neural network (CNN).

Setting Up Your Environment: Installing PyGAD

Before diving into the applications, let’s get PyGAD installed. It’s a breeze using pip:

pip install pygad

Alternatively, on Mac/Linux, use pip3:

pip3 install pygad

Confirm the installation by checking the version:

import pygad
print(pygad.__version__)

Getting Started with PyGAD: Core Concepts

PyGAD simplifies the implementation of genetic algorithms with its user-friendly interface and customizable parameters. The core of PyGAD revolves around the GA class.

To use PyGAD effectively, follow these steps:

1. Define the Fitness Function: This function evaluates the quality of each solution (or "chromosome") in the population. It takes a solution and its index as input, returning a fitness score.

2. Set Parameters: Configure the pygad.GA class with parameters like the number of generations, population size, and selection methods.

3. Instantiate the GA Class: Create an instance of the pygad.GA class with your chosen parameters.

4. Run the Algorithm: Call the run() method to start the evolutionary process.

Essential PyGAD Parameters:

• num_generations: The number of iterations the algorithm will run.
• num_parents_mating: The number of parents selected to create offspring.
• fitness_func: Your custom fitness function.
• sol_per_pop: Number of solutions in the population.

Application 1: Fitting a Linear Model with Genetic Algorithms

Let's start with a practical example: finding the optimal parameters for a linear equation.

The Problem:

Given the equation y = w1x1 + w2x2 + w3x3 + w4x4 + w5x5 + w6x6, where x1 through x6 are inputs and y is the desired output, find the values of the parameters w1 through w6.

The Solution:

1. Define the Fitness Function: Calculate the difference between the predicted output and the desired output.
2. Set Parameters: Define the number of generations, population size, and other relevant parameters.
3. Run PyGAD: Instantiate the pygad.GA class, run the algorithm, and plot the results.

import pygad
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

ga_instance = pygad.GA(num_generations=50,
                       num_parents_mating=10,
                       fitness_func=fitness_func,
                       sol_per_pop=100,
                       num_genes=6)
ga_instance.run()
ga_instance.plot_result()

solution, solution_fitness, solution_idx = ga_instance.best_solution()
print("Parameters of the best solution : {solution}".format(solution=solution))
print("Fitness value of the best solution = {solution_fitness}".format(solution_fitness=solution_fitness))

Application 2: Reproducing Images Using Genetic Algorithms

This application demonstrates how to use GAs to create images that resemble a target image, starting with random pixel values and evolving them over generations.

The key is to:

1. Convert the images into 1-dimensional arrays to work with PyGAD, by using img2chromosome() and chromosome2img() functions.
2. Calculate the fitness, which measures how closely the current solution (image) resembles the target image.

import imageio
import numpy
import pygad

# Load the target image
target_im = imageio.imread('fruit.jpg')
target_im = numpy.asarray(target_im/255, dtype=numpy.float)

# Convert the image to one dimension
def img2chromosome(img_arr):
    return numpy.reshape(a=img_arr, newshape=(-1))

# Function to convert a chromosome back to an image
def chromosome2img(vector, shape):
    return numpy.reshape(a=vector, newshape=shape)

# Define the fitness function
target_chromosome = img2chromosome(target_im)

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

# Instantiate the GA class
ga_instance = pygad.GA(num_generations=2000,
                       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)

# Run the GA
ga_instance.run()

# Display the fitness and resulting images
solution, solution_fitness, solution_idx = ga_instance.best_solution()
import matplotlib.pyplot

result = chromosome2img(solution, target_im.shape)
matplotlib.pyplot.imshow(result)
matplotlib.pyplot.show()

Application 3: Solving the 8 Queen Puzzle with Genetic Algorithms

The 8 Queen Puzzle is a classic constraint satisfaction problem. The goal is to place eight queens on an 8x8 chessboard so that no two queens threaten each other.

How GAs Solve It:

1. Represent Solutions: Each solution is a vector representing the column position of a queen in each row.
2. Fitness Function: The fitness function calculates the number of attacks between queens. The goal is to minimize the number of attacks.
3. Genetic Operations: Crossover and mutation are used to explore different queen placements and evolve solutions.

Application 4 & 5: Training Neural Networks and CNNs with Genetic Algorithms (Brief Overview)

PyGAD can train neural networks, including CNNs, by using a GA to optimize the network's weights. In this approach, each solution represents a set of weights for the neural network. The fitness function evaluates the network's performance on a training dataset.

Maximize Reader Engagement

• Write clear, concise content that is easy to understand.
• Use plenty of visuals to illustrate concepts.
• Provide code examples that users can easily copy and paste.
• Anticipate common questions and provide clear answers.
• Encourage readers to experiment and share their results.