- `fitness_func` : Accepts a function that must accept 2 parameters (a single solution and its index in the population) and return the fitness value of the solution. Available starting from [PyGAD](https://pypi.org/project/pygad) 1.0.17 until 1.0.20 with a single parameter representing the solution. Changed in [PyGAD](https://pypi.org/project/pygad) 2.0.0 and higher to include the second parameter representing the solution index.

- `initial_population`: A user-defined initial population. It is useful when the user wants to start the generations with a custom initial population. It defaults to `None` which means no initial population is specified by the user. In this case, [**PyGAD**](https://pypi.org/project/pygad) creates an initial population using the `sol_per_pop` and `num_genes` parameters. An exception is raised if the `initial_population` is `None` while any of the 2 parameters (`sol_per_pop` or `num_genes`) is also `None`. Introduced in PyGAD 2.0.0 and higher.

- `sol_per_pop` : Number of solutions (i.e. chromosomes) within the population.

- `init_range_low=-4`: The lower value of the random range from which the gene values in the initial population are selected. `init_range_low` defaults to `-4`. Available in [PyGAD](https://pypi.org/project/pygad) 1.0.20 and higher.

- `init_range_high=4`: The upper value of the random range from which the gene values in the initial population are selected. `init_range_high` defaults to `+4`. Available in [PyGAD](https://pypi.org/project/pygad) 1.0.20 and higher.

- `callback_generation`: If not `None`, then it accepts a function to be called after each generation. This function must accept a **single parameter** representing the instance of the genetic algorithm.

All the parameters and functions passed to the GA class constructor are used as attributes and methods in the instances of the GA class. In addition to such attributes, there are other attributes and methods added to the instances of the GA class which are:

- `generations_completed`: Holds the number of the last completed generation.

- `population`: A NumPy array holding the initial population.

- `valid_parameters`: Set to `True` when all the parameters passed in the `GA` class constructor are valid.

- `run_completed`: Set to `True` only after the `run()` method completes gracefully.

- `pop_size`: The population size.

- `crossover`: Refers to the method that applies the crossover operator based on the selected type of crossover in the `crossover_type` property.

- `mutation`: Refers to the method that applies the mutation operator based on the selected type of mutation in the `mutation_type` property.

- `select_parents`: Refers to a method that selects the parents based on the parent selection type specified in the `parent_selection_type` attribute.

- `best_solution_fitness`: A list holding the fitness value of the best solution for each generation.

- `cal_pop_fitness`: A method that calculates the fitness values for all solutions within the population by calling the function passed to the `fitness_func` parameter for each solution.

On **`15 April 2020`**, a new argument named `fitness_func` is added to PyGAD 1.0.17 that allows the user to specify a custom function to be used as a fitness function. This function must be a **maximization function** so that a solution with a high fitness value returned is selected compared to a solution with a low value. Doing that allows the user to freely use the library to solve any problem by passing the appropriate fitness function.

So, the task is about using the genetic algorithm to find the best values for the 6 weight `W1` to `W6`. Thinking of the problem, it is clear that the best solution is that returning an output that is close to the desired output `y=44`. So, the fitness function should return a value that gets higher when the solution's output is closer to `y=44`. Here is a function that does that:

def fitness_func(solution, solution_idx):

The function must accept 2 parameters:

1. 1D vector representing a single solution. Introduced in PyGAD 1.0.17 and higher.

2. Solution index within the population. Introduced in PyGAD 2.0.0 and higher.

fitness_function = fitness_func

sol_per_pop = 8

num_genes = len(function_inputs)

keep_parents = 1

mutation_percent_genes = 10

In PyGAD 2.0.0 and higher, an optional parameter named `callback_generation` is supported which allow the user to call a function (with a single parameter) after each generation. Here is a simple function that just prints the current generation number and the fitness value of the best solution in the current generation. The `generations_completed` attribute of the GA class returns the number of the last completed generation.

def callback_gen(ga_instance):

print("Generation : ", ga_instance.generations_completed)

print("Fitness of the best solution :", ga_instance.best_solution()[1])

After being defined, the function is assigned to the `callback_generation` parameter of the GA class constructor. By doing that, the `callback_gen()` function will be called after each generation.

ga_instance = pygad.GA(...,

callback_generation=callback_gen,

...)

ga_instance = pygad.GA(num_generations=num_generations,

num_parents_mating=num_parents_mating,

fitness_func=fitness_function,

sol_per_pop=sol_per_pop,

num_genes=num_genes,

init_range_low=init_range_low,

init_range_high=init_range_high,

parent_selection_type=parent_selection_type,

keep_parents=keep_parents,

crossover_type=crossover_type,

mutation_type=mutation_type,

mutation_percent_genes=mutation_percent_genes)

loaded_ga_instance = pygad.load(filename=filename)

- Single point: Implemented using the `single_point_crossover()` method.

- Two points: Implemented using the `two_points_crossover()` method.

- Uniform: Implemented using the `uniform_crossover()` method.

- Random: Implemented using the `random_mutation()` method.

- Swap: Implemented using the `swap_mutation()` method.

- Inversion: Implemented using the `inversion_mutation()` method.

- Scramble: Implemented using the `scramble_mutation()` method.

- Steady state: Implemented using the `steady_state_selection()` method.

- Roulette wheel: Implemented using the `roulette_wheel_selection()` method.

- Stochastic universal: Implemented using the `stochastic_universal_selection()` method.

- Rank: Implemented using the `rank_selection()` method.

- Random: Implemented using the `random_selection()` method.

- Tournament: Implemented using the `tournament_selection()` method.

PyGAD 1.0.20 (4 May 2020):

PyGAD 2.0.0 (13 May 2020)

1. The fitness function accepts a new argument named `sol_idx` representing the index of the solution within the population.

2. A new parameter to the GA constructor named `initial_population` is supported to allow the user to use a custom initial population to be used by the genetic algorithm. If not None, then the passed population will be used. If `None`, then the genetic algorithm will create the initial population using the `sol_per_pop` and `num_genes` parameters.

3. The parameters `sol_per_pop` and `num_genes` are optional and set to `None` by default.

4. A new parameter named `callback_generation` is introduced in the GA class constructor. It accepts a function with a single parameter representing the GA instance. This function called after each generation. This helps the user to do post-processing or debugging operations after each generation.