Optimizing a Simple Function with a Genetic Algorithm

Genetic algorithms are powerful search techniques inspired by natural selection. This challenge asks you to implement a genetic algorithm in Python to find the maximum value of a simple mathematical function. This is a foundational problem for understanding genetic algorithms and their application to optimization.

Problem Description

You are tasked with implementing a genetic algorithm to find the maximum value of the function f(x) = -x^2 + 5x + 10 within the range of [0, 10]. The algorithm should iteratively evolve a population of candidate solutions (represented as chromosomes) through selection, crossover, and mutation, aiming to converge towards the optimal solution.

What needs to be achieved:

• Implement a genetic algorithm that searches for the maximum value of the given function within the specified range.
• The algorithm should include the following components:
  • Initialization: Create an initial population of random candidate solutions.
  • Fitness Evaluation: Evaluate the fitness of each candidate solution using the function f(x).
  • Selection: Select parent solutions for reproduction based on their fitness. Roulette wheel selection is recommended.
  • Crossover: Combine the genetic material of parent solutions to create offspring. Single-point crossover is recommended.
  • Mutation: Introduce random changes to the offspring to maintain diversity.
  • Replacement: Replace the existing population with the new offspring.
• The algorithm should run for a specified number of generations.

Key Requirements:

• The chromosome representation should be a floating-point number representing a value within the range [0, 10].
• The fitness function should accurately evaluate the candidate solutions.
• The selection, crossover, and mutation operators should be implemented correctly.
• The algorithm should converge towards the optimal solution within a reasonable number of generations.

Expected Behavior:

The algorithm should output the best solution found (the value of x that maximizes f(x)) and its corresponding fitness (the value of f(x)). The best solution should be close to x = 2.5 (the theoretical maximum).

Edge Cases to Consider:

• Handling invalid input (although the input range is fixed, consider how the algorithm behaves with extreme values near the boundaries).
• Ensuring diversity in the population to prevent premature convergence.
• Tuning the algorithm's parameters (population size, crossover rate, mutation rate) to achieve optimal performance.

Examples

Example 1:

Input: population_size = 50, generations = 100, crossover_rate = 0.7, mutation_rate = 0.01
Output: Best Solution: 2.48, Fitness: 15.78
Explanation: After 100 generations, the algorithm converges to a solution close to x = 2.5, resulting in a fitness value near 15.75.  The exact values will vary due to the stochastic nature of the algorithm.

Example 2:

Input: population_size = 20, generations = 50, crossover_rate = 0.5, mutation_rate = 0.005
Output: Best Solution: 2.55, Fitness: 15.63
Explanation: With a smaller population and fewer generations, the algorithm may converge slightly slower, but still finds a reasonably good solution.

Example 3: (Edge Case - High Mutation Rate)

Input: population_size = 50, generations = 100, crossover_rate = 0.7, mutation_rate = 0.1
Output: Best Solution: 2.32, Fitness: 15.52
Explanation: A high mutation rate can disrupt convergence and prevent the algorithm from finding the optimal solution quickly. The algorithm might explore the search space more broadly but with less precision.

Constraints

• Population Size: The population size should be between 20 and 100.
• Generations: The number of generations should be between 50 and 200.
• Crossover Rate: The crossover rate should be between 0.5 and 0.9.
• Mutation Rate: The mutation rate should be between 0.001 and 0.05.
• Range: The candidate solutions (chromosomes) must be within the range [0, 10].
• Performance: The algorithm should complete within a reasonable time (e.g., less than 5 seconds).

Notes

• Consider using NumPy for efficient array operations.
• Roulette wheel selection is a common and effective selection method.
• Single-point crossover is a simple and widely used crossover operator.
• Experiment with different parameter settings to observe their impact on the algorithm's performance.
• The goal is to find a solution that is close to the theoretical maximum, not necessarily the exact maximum. Due to the random nature of the algorithm, slight variations in the output are expected.
• Focus on clarity and modularity in your code. Well-commented code is appreciated.