importtorchimporttorchgaimportpygaddeffitness_func(ga_instance,solution,sol_idx):globaldata_inputs,data_outputs,torch_ga,model,loss_functionpredictions=pygad.torchga.predict(model=model,solution=solution,data=data_inputs)abs_error=loss_function(predictions,data_outputs).detach().numpy()+0.00000001solution_fitness=1.0/abs_errorreturnsolution_fitnessdefon_generation(ga_instance):print(f"Generation ={ga_instance.generations_completed}")print(f"Fitness    ={ga_instance.best_solution()[1]}")# Create the PyTorch model.input_layer=torch.nn.Linear(3,5)relu_layer=torch.nn.ReLU()output_layer=torch.nn.Linear(5,1)model=torch.nn.Sequential(input_layer,relu_layer,output_layer)# print(model)# Create an instance of the pygad.torchga.TorchGA class to build the initial population.torch_ga=torchga.TorchGA(model=model,num_solutions=10)loss_function=torch.nn.L1Loss()# Data inputsdata_inputs=torch.tensor([[0.02,0.1,0.15],[0.7,0.6,0.8],[1.5,1.2,1.7],[3.2,2.9,3.1]])# Data outputsdata_outputs=torch.tensor([[0.1],[0.6],[1.3],[2.5]])# Prepare the PyGAD parameters. Check the documentation for more information: https://pygad.readthedocs.io/en/latest/pygad.html#pygad-ga-classnum_generations=250# Number of generations.num_parents_mating=5# Number of solutions to be selected as parents in the mating pool.initial_population=torch_ga.population_weights# Initial population of network weightsga_instance=pygad.GA(num_generations=num_generations,num_parents_mating=num_parents_mating,initial_population=initial_population,fitness_func=fitness_func,on_generation=on_generation)ga_instance.run()# After the generations complete, some plots are showed that summarize how the outputs/fitness values evolve over generations.ga_instance.plot_fitness(title="PyGAD & PyTorch - Iteration vs. Fitness",linewidth=4)# Returning the details of the best solution.solution,solution_fitness,solution_idx=ga_instance.best_solution()print(f"Fitness value of the best solution ={solution_fitness}")print(f"Index of the best solution :{solution_idx}")# Make predictions based on the best solution.predictions=pygad.torchga.predict(model=model,solution=solution,data=data_inputs)print("Predictions :\n",predictions.detach().numpy())abs_error=loss_function(predictions,data_outputs)print("Absolute Error : ",abs_error.detach().numpy())

importtorchimporttorchgaimportpygaddeffitness_func(ga_instance,solution,sol_idx):globaldata_inputs,data_outputs,torch_ga,model,loss_functionpredictions=pygad.torchga.predict(model=model,solution=solution,data=data_inputs)solution_fitness=1.0/(loss_function(predictions,data_outputs).detach().numpy()+0.00000001)returnsolution_fitnessdefon_generation(ga_instance):print(f"Generation ={ga_instance.generations_completed}")print(f"Fitness    ={ga_instance.best_solution()[1]}")# Create the PyTorch model.input_layer=torch.nn.Linear(2,4)relu_layer=torch.nn.ReLU()dense_layer=torch.nn.Linear(4,2)output_layer=torch.nn.Softmax(1)model=torch.nn.Sequential(input_layer,relu_layer,dense_layer,output_layer)# print(model)# Create an instance of the pygad.torchga.TorchGA class to build the initial population.torch_ga=torchga.TorchGA(model=model,num_solutions=10)loss_function=torch.nn.BCELoss()# XOR problem inputsdata_inputs=torch.tensor([[0.0,0.0],[0.0,1.0],[1.0,0.0],[1.0,1.0]])# XOR problem outputsdata_outputs=torch.tensor([[1.0,0.0],[0.0,1.0],[0.0,1.0],[1.0,0.0]])# Prepare the PyGAD parameters. Check the documentation for more information: https://pygad.readthedocs.io/en/latest/pygad.html#pygad-ga-classnum_generations=250# Number of generations.num_parents_mating=5# Number of solutions to be selected as parents in the mating pool.initial_population=torch_ga.population_weights# Initial population of network weights.# Create an instance of the pygad.GA classga_instance=pygad.GA(num_generations=num_generations,num_parents_mating=num_parents_mating,initial_population=initial_population,fitness_func=fitness_func,on_generation=on_generation)# Start the genetic algorithm evolution.ga_instance.run()# After the generations complete, some plots are showed that summarize how the outputs/fitness values evolve over generations.ga_instance.plot_fitness(title="PyGAD & PyTorch - Iteration vs. Fitness",linewidth=4)# Returning the details of the best solution.solution,solution_fitness,solution_idx=ga_instance.best_solution()print(f"Fitness value of the best solution ={solution_fitness}")print(f"Index of the best solution :{solution_idx}")# Make predictions based on the best solution.predictions=pygad.torchga.predict(model=model,solution=solution,data=data_inputs)print("Predictions :\n",predictions.detach().numpy())# Calculate the binary crossentropy for the trained model.print("Binary Crossentropy : ",loss_function(predictions,data_outputs).detach().numpy())# Calculate the classification accuracy of the trained model.a=torch.max(predictions,axis=1)b=torch.max(data_outputs,axis=1)accuracy=torch.sum(a.indices==b.indices)/len(data_outputs)print("Accuracy : ",accuracy.detach().numpy())

input_layer=torch.nn.Linear(2,4)relu_layer=torch.nn.ReLU()dense_layer=torch.nn.Linear(4,2)output_layer=torch.nn.Softmax(1)model=torch.nn.Sequential(input_layer,relu_layer,dense_layer,output_layer)

# XOR problem inputsdata_inputs=torch.tensor([[0.0,0.0],[0.0,1.0],[1.0,0.0],[1.0,1.0]])# XOR problem outputsdata_outputs=torch.tensor([[1.0,0.0],[0.0,1.0],[0.0,1.0],[1.0,0.0]])

loss_function=torch.nn.BCELoss()

Fitnessvalueofthebestsolution=100000000.0Indexofthebestsolution:0Predictions:[[1.0000000e+001.3627675e-10][3.8521746e-091.0000000e+00][4.2789325e-101.0000000e+00][1.0000000e+003.3668417e-09]]BinaryCrossentropy:0.0Accuracy:1.0

importtorchimporttorchgaimportpygadimportnumpydeffitness_func(ga_instance,solution,sol_idx):globaldata_inputs,data_outputs,torch_ga,model,loss_functionpredictions=pygad.torchga.predict(model=model,solution=solution,data=data_inputs)solution_fitness=1.0/(loss_function(predictions,data_outputs).detach().numpy()+0.00000001)returnsolution_fitnessdefon_generation(ga_instance):print(f"Generation ={ga_instance.generations_completed}")print(f"Fitness    ={ga_instance.best_solution()[1]}")# Build the PyTorch model using the functional API.input_layer=torch.nn.Linear(360,50)relu_layer=torch.nn.ReLU()dense_layer=torch.nn.Linear(50,4)output_layer=torch.nn.Softmax(1)model=torch.nn.Sequential(input_layer,relu_layer,dense_layer,output_layer)# Create an instance of the pygad.torchga.TorchGA class to build the initial population.torch_ga=torchga.TorchGA(model=model,num_solutions=10)loss_function=torch.nn.CrossEntropyLoss()# Data inputsdata_inputs=torch.from_numpy(numpy.load("dataset_features.npy")).float()# Data outputsdata_outputs=torch.from_numpy(numpy.load("outputs.npy")).long()# The next 2 lines are equivelant to this Keras function to perform 1-hot encoding: tensorflow.keras.utils.to_categorical(data_outputs)# temp_outs = numpy.zeros((data_outputs.shape[0], numpy.unique(data_outputs).size), dtype=numpy.uint8)# temp_outs[numpy.arange(data_outputs.shape[0]), numpy.uint8(data_outputs)] = 1# Prepare the PyGAD parameters. Check the documentation for more information: https://pygad.readthedocs.io/en/latest/pygad.html#pygad-ga-classnum_generations=200# Number of generations.num_parents_mating=5# Number of solutions to be selected as parents in the mating pool.initial_population=torch_ga.population_weights# Initial population of network weights.# Create an instance of the pygad.GA classga_instance=pygad.GA(num_generations=num_generations,num_parents_mating=num_parents_mating,initial_population=initial_population,fitness_func=fitness_func,on_generation=on_generation)# Start the genetic algorithm evolution.ga_instance.run()# After the generations complete, some plots are showed that summarize how the outputs/fitness values evolve over generations.ga_instance.plot_fitness(title="PyGAD & PyTorch - Iteration vs. Fitness",linewidth=4)# Returning the details of the best solution.solution,solution_fitness,solution_idx=ga_instance.best_solution()print(f"Fitness value of the best solution ={solution_fitness}")print(f"Index of the best solution :{solution_idx}")# Fetch the parameters of the best solution.best_solution_weights=torchga.model_weights_as_dict(model=model,weights_vector=solution)model.load_state_dict(best_solution_weights)predictions=model(data_inputs)# print("Predictions : \n", predictions)# Calculate the crossentropy loss of the trained model.print("Crossentropy : ",loss_function(predictions,data_outputs).detach().numpy())# Calculate the classification accuracy for the trained model.accuracy=torch.sum(torch.max(predictions,axis=1).indices==data_outputs)/len(data_outputs)print("Accuracy : ",accuracy.detach().numpy())

loss_function=torch.nn.CrossEntropyLoss()

importtorchimporttorchgaimportpygadimportnumpydeffitness_func(ga_instance,solution,sol_idx):globaldata_inputs,data_outputs,torch_ga,model,loss_functionpredictions=pygad.torchga.predict(model=model,solution=solution,data=data_inputs)solution_fitness=1.0/(loss_function(predictions,data_outputs).detach().numpy()+0.00000001)returnsolution_fitnessdefon_generation(ga_instance):print(f"Generation ={ga_instance.generations_completed}")print(f"Fitness    ={ga_instance.best_solution()[1]}")# Build the PyTorch model.input_layer=torch.nn.Conv2d(in_channels=3,out_channels=5,kernel_size=7)relu_layer1=torch.nn.ReLU()max_pool1=torch.nn.MaxPool2d(kernel_size=5,stride=5)conv_layer2=torch.nn.Conv2d(in_channels=5,out_channels=3,kernel_size=3)relu_layer2=torch.nn.ReLU()flatten_layer1=torch.nn.Flatten()# The value 768 is pre-computed by tracing the sizes of the layers' outputs.dense_layer1=torch.nn.Linear(in_features=768,out_features=15)relu_layer3=torch.nn.ReLU()dense_layer2=torch.nn.Linear(in_features=15,out_features=4)output_layer=torch.nn.Softmax(1)model=torch.nn.Sequential(input_layer,relu_layer1,max_pool1,conv_layer2,relu_layer2,flatten_layer1,dense_layer1,relu_layer3,dense_layer2,output_layer)# Create an instance of the pygad.torchga.TorchGA class to build the initial population.torch_ga=torchga.TorchGA(model=model,num_solutions=10)loss_function=torch.nn.CrossEntropyLoss()# Data inputsdata_inputs=torch.from_numpy(numpy.load("dataset_inputs.npy")).float()data_inputs=data_inputs.reshape((data_inputs.shape[0],data_inputs.shape[3],data_inputs.shape[1],data_inputs.shape[2]))# Data outputsdata_outputs=torch.from_numpy(numpy.load("dataset_outputs.npy")).long()# Prepare the PyGAD parameters. Check the documentation for more information: https://pygad.readthedocs.io/en/latest/pygad.html#pygad-ga-classnum_generations=200# Number of generations.num_parents_mating=5# Number of solutions to be selected as parents in the mating pool.initial_population=torch_ga.population_weights# Initial population of network weights.# Create an instance of the pygad.GA classga_instance=pygad.GA(num_generations=num_generations,num_parents_mating=num_parents_mating,initial_population=initial_population,fitness_func=fitness_func,on_generation=on_generation)# Start the genetic algorithm evolution.ga_instance.run()# After the generations complete, some plots are showed that summarize how the outputs/fitness values evolve over generations.ga_instance.plot_fitness(title="PyGAD & PyTorch - Iteration vs. Fitness",linewidth=4)# Returning the details of the best solution.solution,solution_fitness,solution_idx=ga_instance.best_solution()print(f"Fitness value of the best solution ={solution_fitness}")print(f"Index of the best solution :{solution_idx}")# Make predictions based on the best solution.predictions=pygad.torchga.predict(model=model,solution=solution,data=data_inputs)# print("Predictions : \n", predictions)# Calculate the crossentropy for the trained model.print("Crossentropy : ",loss_function(predictions,data_outputs).detach().numpy())# Calculate the classification accuracy for the trained model.accuracy=torch.sum(torch.max(predictions,axis=1).indices==data_outputs)/len(data_outputs)print("Accuracy : ",accuracy.detach().numpy())

input_layer=torch.nn.Conv2d(in_channels=3,out_channels=5,kernel_size=7)relu_layer1=torch.nn.ReLU()max_pool1=torch.nn.MaxPool2d(kernel_size=5,stride=5)conv_layer2=torch.nn.Conv2d(in_channels=5,out_channels=3,kernel_size=3)relu_layer2=torch.nn.ReLU()flatten_layer1=torch.nn.Flatten()# The value 768 is pre-computed by tracing the sizes of the layers' outputs.dense_layer1=torch.nn.Linear(in_features=768,out_features=15)relu_layer3=torch.nn.ReLU()dense_layer2=torch.nn.Linear(in_features=15,out_features=4)output_layer=torch.nn.Softmax(1)model=torch.nn.Sequential(input_layer,relu_layer1,max_pool1,conv_layer2,relu_layer2,flatten_layer1,dense_layer1,relu_layer3,dense_layer2,output_layer)