Genetic Algorithm for Minimization Optimization

The following code demonstrates how to use genetic algorithms to solve minimization problems. Genetic algorithms are heuristic search algorithms that simulate biological evolution processes, gradually exploring solutions to find optimal results. This algorithm is particularly suitable for solving complex optimization problems, such as function minimization.

The code implementation includes key genetic operations:

```

# Genetic Algorithm for Minimum Value Search

import random

# Objective function - calculates fitness value (minimization target)

def fitness(x):

return x ** 2 # Example minimization of quadratic function

# Chromosome generation - creates initial population members

def gene():

return random.uniform(-10, 10) # Random values in specified range

# Crossover operation - combines parent chromosomes to produce offspring

def crossover(parent1, parent2):

child1 = (parent1 + parent2) / 2 # Arithmetic crossover method

child2 = (parent1 - parent2) / 2

return child1, child2

# Mutation operation - introduces random changes to maintain diversity

def mutation(child):

return child + random.uniform(-1, 1) # Small random perturbation

# Initialize population - create starting generation

population = [gene() for i in range(10)] # Population size of 10

# Evolution loop - main genetic algorithm iteration

for i in range(100): # 100 generations of evolution

# Fitness evaluation - calculate performance metrics

fitnesses = [fitness(x) for x in population]

# Selection process - choose parents based on fitness weights

parents = random.choices(population, weights=fitnesses, k=2)

# Crossover application - generate new offspring

children = crossover(*parents)

# Mutation application - diversify the population

children = [mutation(child) for child in children]

# Population update - replace worst-performing individuals

population[random.randint(0, 9)] = children[0]

population[random.randint(0, 9)] = children[1]

# Output optimal solution - display best found result

print(min(population, key=fitness)) # Minimum value based on fitness function

```

This code can be adapted to solve various minimization problems by modifying the `fitness(x)` function. The algorithm implements standard genetic operations including selection, crossover, and mutation, following evolutionary principles to converge toward optimal solutions. Key parameters like population size (10), generation count (100), and mutation range can be adjusted for different optimization scenarios.