How to implement Genetic Algorithm using PyTorch

Last Updated : 01 Apr, 2024

The optimization algorithms are capable of solving complex problems and genetic algorithm is one of the optimization algorithm. Genetic Algorithm can be easily integrate with PyTorch to address a wide array of optimization tasks. We will understand how to implement Genetic Algorithm using PyTorch.

Genetic Algorithms

Genetic algorithms (GAs) are optimization techniques inspired by natural selection. They start with a population of potential solutions to a problem and improve them over many generations. Genetic algorithms imitate natural selection to solve problems. They start with a group of solutions, evaluate how good they are, and then mix and mutate the best ones to create new solutions. This process continues, improving the solutions over many iterations until a satisfactory one is found. GAs are useful for complex problems where traditional methods struggle.

Algorithm:

Population: Begin with a group of random solutions to the problem.
Fitness Function: Evaluate how good each solution is using a fitness function, which measures how well it solves the problem.
Selection: Choose the best solutions from the population to become parents for the next generation.
Crossover: Combine pairs of parents to create new solutions (offspring).
Mutation: Occasionally introduce random changes to keep the solutions diverse.
Repeat: Continue this process for many generations, gradually improving the solutions.

Implementing Genetic Algorithm using PyTorch

Here, we implement a simple genetic algorithm (GA) to optimize the hyperparameters of a neural network using PyTorch. We create an initial population of individuals representing different sets of hyperparameters, evaluate their fitness by training and evaluating neural networks, perform selection, crossover, and mutation operations, and iterate for a fixed number of generations. For this we follow these steps:

Step 1: Import necessary libraries

We will first import necessary libraries:

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

Step 2: Define neural network

The CNN class defines a Convolutional Neural Network architecture using PyTorch's nn.Module. It consists of two convolutional layers (conv1 and conv2) followed by max-pooling operations and two fully connected layers (fc1 and fc2).

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.max_pool2d(x, kernel_size=2, stride=2)
        x = torch.relu(self.conv2(x))
        x = torch.max_pool2d(x, kernel_size=2, stride=2)
        x = x.view(-1, 64 * 7 * 7)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return torch.log_softmax(x, dim=1)

Step 3: Compute Fitness

The function calculates the accuracy of a given model (individual) on the test dataset. It trains the model on the training dataset for a fixed number of epochs (5 in this case) and then evaluates its accuracy on the test dataset.

def compute_fitness(model, train_loader, test_loader):
    criterion = nn.NLLLoss()
    optimizer = optim.Adam(model.parameters())

    model.train()
    for epoch in range(5):
        for data, target in train_loader:
            optimizer.zero_grad()
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()

    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for data, target in test_loader:
            output = model(data)
            _, predicted = torch.max(output.data, 1)
            total += target.size(0)
            correct += (predicted == target).sum().item()

    accuracy = correct / total
    return accuracy

Step 4: Define Genetic Algorithm Parameters

population_size: Number of individuals in the population.
mutation_rate: Probability of mutation for each parameter.
num_generations: Number of generations for the genetic algorithm.

# Genetic algorithm parameters
population_size = 10
mutation_rate = 0.1
num_generations = 5

Step 5: Population Initialization Function

The function initializes the population with a specified number of CNN models.

# Initialize genetic algorithm parameters
def initialize_population():
    population = []
    for _ in range(population_size):
        model = CNN()
        population.append(model)
    return population

Step 6: Crossover Operator (crossover):

The crossover operator combines genetic information from two parent models to produce two child models. It implements single-point crossover by swapping weights between the parent models' convolutional layers.

# Crossover operator: Single-point crossover
def crossover(parent1, parent2):
    child1 = CNN()
    child2 = CNN()
    child1.conv1.weight.data = torch.cat((parent1.conv1.weight.data[:16], parent2.conv1.weight.data[16:]), dim=0)
    child2.conv1.weight.data = torch.cat((parent2.conv1.weight.data[:16], parent1.conv1.weight.data[16:]), dim=0)
    return child1, child2

Step 7: Mutation Operator (mutate):

The mutation operator introduces random perturbations to the parameters of the model with a certain probability (mutation_rate). It adds Gaussian noise to the model's parameters.

# Mutation operator: Random mutation
def mutate(model):
    for param in model.parameters():
        if torch.rand(1).item() < mutation_rate:
            param.data += torch.randn_like(param.data) * 0.1  # Adding Gaussian noise with std=0.1
    return model

Step 8: Loading Dataset

The MNIST dataset is loaded using torchvision. It consists of handwritten digit images and corresponding labels.

# Load MNIST dataset
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

Step 9: Executing Genetic Algorithm

The genetic algorithm iterates over multiple generations, evaluating the fitness of each individual (model) in the population, selecting the top-performing individuals for the next generation, and applying crossover and mutation operators to generate new individuals.

# Genetic algorithm
population = initialize_population()
for generation in range(num_generations):
    print("Generation:", generation + 1)
    best_accuracy = 0
    best_individual = None

    # Compute fitness for each individual
    for individual in population:
        fitness = compute_fitness(individual, train_loader, test_loader)
        if fitness > best_accuracy:
            best_accuracy = fitness
            best_individual = individual

    print("Best accuracy in generation", generation + 1, ":", best_accuracy)
    print("Best individual:", best_individual)

    next_generation = []

    # Select top individuals for next generation
    selected_individuals = population[:population_size // 2]

    # Crossover and mutation
    for i in range(0, len(selected_individuals), 2):
        parent1 = selected_individuals[i]
        parent2 = selected_individuals[i + 1]
        child1, child2 = crossover(parent1, parent2)
        child1 = mutate(child1)
        child2 = mutate(child2)
        next_generation.extend([child1, child2])

    population = next_generation

Complete Code

Python3

import torch import torch.nn as nn import torch.optim as optim from torchvision import datasets, transforms from torch.utils.data import DataLoader  # Define the neural network architecture (CNN) class CNN(nn.Module):     def __init__(self):         super(CNN, self).__init__()         self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)         self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)         self.fc1 = nn.Linear(64 * 7 * 7, 128)         self.fc2 = nn.Linear(128, 10)      def forward(self, x):         x = torch.relu(self.conv1(x))         x = torch.max_pool2d(x, kernel_size=2, stride=2)         x = torch.relu(self.conv2(x))         x = torch.max_pool2d(x, kernel_size=2, stride=2)         x = x.view(-1, 64 * 7 * 7)         x = torch.relu(self.fc1(x))         x = self.fc2(x)         return torch.log_softmax(x, dim=1)  # Function to compute fitness (accuracy) of an individual (hyperparameters) def compute_fitness(model, train_loader, test_loader):     criterion = nn.NLLLoss()     optimizer = optim.Adam(model.parameters())      model.train()     for epoch in range(5):         for data, target in train_loader:             optimizer.zero_grad()             output = model(data)             loss = criterion(output, target)             loss.backward()             optimizer.step()      model.eval()     correct = 0     total = 0     with torch.no_grad():         for data, target in test_loader:             output = model(data)             _, predicted = torch.max(output.data, 1)             total += target.size(0)             correct += (predicted == target).sum().item()      accuracy = correct / total     return accuracy  # Genetic algorithm parameters population_size = 10 mutation_rate = 0.1 num_generations = 5  # Initialize genetic algorithm parameters def initialize_population():     population = []     for _ in range(population_size):         model = CNN()         population.append(model)     return population  # Crossover operator: Single-point crossover def crossover(parent1, parent2):     child1 = CNN()     child2 = CNN()     child1.conv1.weight.data = torch.cat((parent1.conv1.weight.data[:16], parent2.conv1.weight.data[16:]), dim=0)     child2.conv1.weight.data = torch.cat((parent2.conv1.weight.data[:16], parent1.conv1.weight.data[16:]), dim=0)     return child1, child2  # Mutation operator: Random mutation def mutate(model):     for param in model.parameters():         if torch.rand(1).item() < mutation_rate:             param.data += torch.randn_like(param.data) * 0.1  # Adding Gaussian noise with std=0.1     return model  # Load MNIST dataset transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))]) train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True) train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True) test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True) test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)  # Genetic algorithm population = initialize_population() for generation in range(num_generations):     print("Generation:", generation + 1)     best_accuracy = 0     best_individual = None      # Compute fitness for each individual     for individual in population:         fitness = compute_fitness(individual, train_loader, test_loader)         if fitness > best_accuracy:             best_accuracy = fitness             best_individual = individual      print("Best accuracy in generation", generation + 1, ":", best_accuracy)     print("Best individual:", best_individual)      next_generation = []      # Select top individuals for next generation     selected_individuals = population[:population_size // 2]      # Crossover and mutation     for i in range(0, len(selected_individuals), 2):         parent1 = selected_individuals[i]         parent2 = selected_individuals[i + 1]         child1, child2 = crossover(parent1, parent2)         child1 = mutate(child1)         child2 = mutate(child2)         next_generation.extend([child1, child2])      population = next_generation  # Print final population print("Final population:") for individual in population:     print("Individual:", individual)

Output:

Generation: 1
Best accuracy in generation 1 : 0.912
Best individual: CNN(
  (conv1): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (conv2): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=3136, out_features=128, bias=True)
  (fc2): Linear(in_features=128, out_features=10, bias=True)
)
...

Generation: 5
Best accuracy in generation 5 : 0.935
Best individual: CNN(
  (conv1): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (conv2): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=3136, out_features=128, bias=True)
  (fc2): Linear(in_features=128, out_features=10, bias=True)
)

Final population:
Individual: CNN(
  (conv1): Conv2d(1, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (conv2): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (fc1): Linear(in_features=3136, out_features=128, bias=True)
  (fc2): Linear(in_features=128, out_features=10, bias=True)
)
...

Output Explanation

For each generation, the code prints the generation number (Generation: X).
It also displays the best accuracy achieved in that generation (Best accuracy in generation X : Y).
Additionally, it shows the architecture of the best individual CNN model in that generation (Best individual: ...).
After all generations are processed, the code prints the final population of evolved CNN models.
Each individual in the final population represents a CNN model with its architecture printed.

Conclusion

In summary, combining PyTorch with genetic algorithms or optimization methods offers a powerful way to solve complex problems in machine learning and beyond. By leveraging PyTorch's flexibility and genetic algorithms' exploration abilities, practitioners can efficiently optimize neural network architectures, fine-tune hyperparameters, defend against attacks, allocate resources effectively, and automate machine learning processes. This collaboration between PyTorch and genetic algorithms promises to drive innovation and solve challenging optimization problems across various domains.

How to Implement Various Optimization Algorithms in Pytorch?

deepkumarpatra

Improve

Article Tags :