# Regression Example 1 To train a neural network for regression, follow these instructions: 1. Set the `output_activation` parameter in the constructor of the `pygad.gann.GANN` class to `"None"`. It is possible to use the ReLU function if all outputs are nonnegative. ```python GANN_instance = pygad.gann.GANN(... output_activation="None") ``` 2. Wherever the `pygad.nn.predict()` function is used, set the `problem_type` parameter to `"regression"`. ```python predictions = pygad.nn.predict(..., problem_type="regression") ``` 3. Design the fitness function to calculate the error (e.g. mean absolute error). ```python def fitness_func(ga_instance, solution, sol_idx): ... predictions = pygad.nn.predict(..., problem_type="regression") solution_fitness = 1.0/numpy.mean(numpy.abs(predictions - data_outputs)) return solution_fitness ``` The next code builds a complete example for building a neural network for regression. ```python import numpy import pygad import pygad.nn import pygad.gann def fitness_func(ga_instance, solution, sol_idx): global GANN_instance, data_inputs, data_outputs predictions = pygad.nn.predict(last_layer=GANN_instance.population_networks[sol_idx], data_inputs=data_inputs, problem_type="regression") solution_fitness = 1.0/numpy.mean(numpy.abs(predictions - data_outputs)) return solution_fitness def callback_generation(ga_instance): global GANN_instance, last_fitness population_matrices = pygad.gann.population_as_matrices(population_networks=GANN_instance.population_networks, population_vectors=ga_instance.population) GANN_instance.update_population_trained_weights(population_trained_weights=population_matrices) print(f"Generation = {ga_instance.generations_completed}") print(f"Fitness = {ga_instance.best_solution(pop_fitness=ga_instance.last_generation_fitness)[1]}") print(f"Change = {ga_instance.best_solution(pop_fitness=ga_instance.last_generation_fitness)[1] - last_fitness}") last_fitness = ga_instance.best_solution(pop_fitness=ga_instance.last_generation_fitness)[1].copy() # Holds the fitness value of the previous generation. last_fitness = 0 # Preparing the NumPy array of the inputs. data_inputs = numpy.array([[2, 5, -3, 0.1], [8, 15, 20, 13]]) # Preparing the NumPy array of the outputs. data_outputs = numpy.array([[0.1, 0.2], [1.8, 1.5]]) # The length of the input vector for each sample (i.e. number of neurons in the input layer). num_inputs = data_inputs.shape[1] # Creating an initial population of neural networks. The return of the initial_population() function holds references to the networks, not their weights. Using such references, the weights of all networks can be fetched. num_solutions = 6 # A solution or a network can be used interchangeably. GANN_instance = pygad.gann.GANN(num_solutions=num_solutions, num_neurons_input=num_inputs, num_neurons_hidden_layers=[2], num_neurons_output=2, hidden_activations=["relu"], output_activation="None") # population does not hold the numerical weights of the network instead it holds a list of references to each last layer of each network (i.e. solution) in the population. A solution or a network can be used interchangeably. # If there is a population with 3 solutions (i.e. networks), then the population is a list with 3 elements. Each element is a reference to the last layer of each network. Using such a reference, all details of the network can be accessed. population_vectors = pygad.gann.population_as_vectors(population_networks=GANN_instance.population_networks) # To prepare the initial population, there are 2 ways: # 1) Prepare it yourself and pass it to the initial_population parameter. This way is useful when the user wants to start the genetic algorithm with a custom initial population. # 2) Assign valid integer values to the sol_per_pop and num_genes parameters. If the initial_population parameter exists, then the sol_per_pop and num_genes parameters are useless. initial_population = population_vectors.copy() num_parents_mating = 4 # Number of solutions to be selected as parents in the mating pool. num_generations = 500 # Number of generations. mutation_percent_genes = 5 # Percentage of genes to mutate. This parameter has no action if the parameter mutation_num_genes exists. parent_selection_type = "sss" # Type of parent selection. crossover_type = "single_point" # Type of the crossover operator. mutation_type = "random" # Type of the mutation operator. keep_parents = 1 # Number of parents to keep in the next population. -1 means keep all parents and 0 means keep nothing. init_range_low = -1 init_range_high = 1 ga_instance = pygad.GA(num_generations=num_generations, num_parents_mating=num_parents_mating, initial_population=initial_population, fitness_func=fitness_func, mutation_percent_genes=mutation_percent_genes, init_range_low=init_range_low, init_range_high=init_range_high, parent_selection_type=parent_selection_type, crossover_type=crossover_type, mutation_type=mutation_type, keep_parents=keep_parents, on_generation=callback_generation) ga_instance.run() # After the generations complete, a plot is shown that summarizes how the fitness values evolve over the generations. ga_instance.plot_fitness() # Returning the details of the best solution. solution, solution_fitness, solution_idx = ga_instance.best_solution(pop_fitness=ga_instance.last_generation_fitness) print(f"Parameters of the best solution : {solution}") print(f"Fitness value of the best solution = {solution_fitness}") print(f"Index of the best solution : {solution_idx}") if ga_instance.best_solution_generation != -1: print(f"Best fitness value reached after {ga_instance.best_solution_generation} generations.") # Predicting the outputs of the data using the best solution. predictions = pygad.nn.predict(last_layer=GANN_instance.population_networks[solution_idx], data_inputs=data_inputs, problem_type="regression") print(f"Predictions of the trained network : {predictions}") # Calculating some statistics abs_error = numpy.mean(numpy.abs(predictions - data_outputs)) print(f"Absolute error : {abs_error}.") ``` The next figure shows how the fitness value changes for the generations used. ![example_regression](https://user-images.githubusercontent.com/16560492/92948154-3cf24b00-f459-11ea-94ea-952b66ab2145.png)