more tests

Author: ahmedfgad

pygad/cnn/cnn.py

@@ -78,7 +78,7 @@ def layers_weights_as_matrix(model, vector_weights):
             layer_weights_size = layer.initial_weights.size
 
             weights_vector=vector_weights[start:start + layer_weights_size]
-    #        matrix = pygad.nn.DenseLayer.to_array(vector=weights_vector, shape=layer_weights_shape)
+            # matrix = pygad.nn.DenseLayer.to_array(vector=weights_vector, shape=layer_weights_shape)
             matrix = numpy.reshape(weights_vector, (layer_weights_shape))
             network_weights.append(matrix)
 

tests/test_cnn.py

@@ -0,0 +1,49 @@
+import pygad.cnn
+import numpy
+
+def test_cnn_layers_and_model():
+    """Test pygad.cnn layers and Model class."""
+    # Dummy data
+    data_inputs = numpy.random.uniform(0, 1, (4, 10, 10, 3))
+    # The test do not care about the outputs predicted by the network.
+    # data_outputs = numpy.array([0, 1, 1, 0])
+
+    input_layer = pygad.cnn.Input2D(input_shape=(10, 10, 3))
+    conv_layer = pygad.cnn.Conv2D(num_filters=2,
+                                   kernel_size=3,
+                                   previous_layer=input_layer,
+                                   activation_function="relu")
+    max_pooling_layer = pygad.cnn.MaxPooling2D(pool_size=2, 
+                                               previous_layer=conv_layer,
+                                               stride=2)
+    flatten_layer = pygad.cnn.Flatten(previous_layer=max_pooling_layer)
+    dense_layer = pygad.cnn.Dense(num_neurons=2, 
+                                   previous_layer=flatten_layer,
+                                   activation_function="softmax")
+
+    model = pygad.cnn.Model(last_layer=dense_layer,
+                            epochs=1,
+                            learning_rate=0.01)
+
+    # Test predict
+    predictions = model.predict(data_inputs=data_inputs)
+    assert len(predictions) == 4
+
+    # Test summary (just to ensure it doesn't crash)
+    model.summary()
+    
+    # Test layers_weights
+    weights = pygad.cnn.layers_weights(model)
+    assert isinstance(weights, list)
+    assert len(weights) > 0
+
+    # Test layers_weights_as_vector
+    weights_vector = pygad.cnn.layers_weights_as_vector(model)
+    assert isinstance(weights_vector, numpy.ndarray)
+    assert weights_vector.ndim == 1
+    
+    print("test_cnn_layers_and_model passed.")
+
+if __name__ == "__main__":
+    test_cnn_layers_and_model()
+    print("\nAll CNN tests passed!")

tests/test_gacnn.py

@@ -0,0 +1,57 @@
+import pygad.cnn
+import pygad.gacnn
+import pygad
+import numpy
+
+def test_gacnn_evolution():
+    """Test pygad.gacnn with pygad.GA."""
+    # Small dummy data
+    data_inputs = numpy.random.uniform(0, 1, (4, 10, 10, 3))
+    data_outputs = numpy.array([0, 1, 1, 0])
+
+    input_layer = pygad.cnn.Input2D(input_shape=(10, 10, 3))
+    conv_layer = pygad.cnn.Conv2D(num_filters=2,
+                                   kernel_size=3,
+                                   previous_layer=input_layer,
+                                   activation_function="relu")
+    flatten_layer = pygad.cnn.Flatten(previous_layer=conv_layer)
+    dense_layer = pygad.cnn.Dense(num_neurons=2, 
+                                   previous_layer=flatten_layer,
+                                   activation_function="softmax")
+
+    model = pygad.cnn.Model(last_layer=dense_layer,
+                            epochs=1,
+                            learning_rate=0.01)
+
+    gacnn_instance = pygad.gacnn.GACNN(model=model,
+                                     num_solutions=4)
+
+    def fitness_func(ga_instance, solution, sol_idx):
+        predictions = gacnn_instance.population_networks[sol_idx].predict(data_inputs=data_inputs)
+        correct_predictions = numpy.where(predictions == data_outputs)[0].size
+        solution_fitness = (correct_predictions/data_outputs.size)*100
+        return solution_fitness
+
+    def callback_generation(ga_instance):
+        population_matrices = pygad.gacnn.population_as_matrices(population_networks=gacnn_instance.population_networks, 
+                                                                population_vectors=ga_instance.population)
+        gacnn_instance.update_population_trained_weights(population_trained_weights=population_matrices)
+
+    initial_population = pygad.gacnn.population_as_vectors(population_networks=gacnn_instance.population_networks)
+
+    ga_instance = pygad.GA(num_generations=2, 
+                           num_parents_mating=2, 
+                           initial_population=initial_population,
+                           fitness_func=fitness_func,
+                           on_generation=callback_generation,
+                           suppress_warnings=True)
+
+    ga_instance.run()
+    assert ga_instance.run_completed
+    assert ga_instance.generations_completed == 2
+    
+    print("test_gacnn_evolution passed.")
+
+if __name__ == "__main__":
+    test_gacnn_evolution()
+    print("\nAll GACNN tests passed!")

tests/test_kerasga.py

@@ -0,0 +1,46 @@
+import numpy
+import pygad
+import pygad.kerasga
+import tensorflow.keras
+
+def test_kerasga_evolution():
+    """Test pygad.kerasga with pygad.GA."""
+
+    # XOR data
+    data_inputs = numpy.array([[0, 0], [0, 1], [1, 0], [1, 1]])
+    data_outputs = numpy.array([[1, 0], [0, 1], [0, 1], [1, 0]]) # One-hot encoded
+
+    input_layer = tensorflow.keras.layers.Input(2)
+    dense_layer = tensorflow.keras.layers.Dense(4, activation="relu")(input_layer)
+    output_layer = tensorflow.keras.layers.Dense(2, activation="softmax")(dense_layer)
+
+    model = tensorflow.keras.Model(inputs=input_layer, outputs=output_layer)
+
+    keras_ga = pygad.kerasga.KerasGA(model=model, num_solutions=10)
+
+    def fitness_func(ga_instance, solution, solution_idx):
+        model_weights_matrix = pygad.kerasga.model_weights_as_matrix(model=model,
+                                                                     weights_vector=solution)
+        model.set_weights(weights=model_weights_matrix)
+        predictions = model.predict(data_inputs, verbose=0)
+        
+        cce = tensorflow.keras.losses.CategoricalCrossentropy()
+        loss = cce(data_outputs, predictions).numpy()
+        fitness = 1.0 / (loss + 0.00000001)
+        return fitness
+
+    ga_instance = pygad.GA(num_generations=2,
+                           num_parents_mating=5,
+                           initial_population=keras_ga.population_weights,
+                           fitness_func=fitness_func,
+                           suppress_warnings=True)
+
+    ga_instance.run()
+    assert ga_instance.run_completed
+    assert ga_instance.generations_completed == 2
+    
+    print("test_kerasga_evolution passed.")
+
+if __name__ == "__main__":
+    test_kerasga_evolution()
+    print("\nAll KerasGA tests passed!")

tests/test_torchga.py

@@ -0,0 +1,45 @@
+import pygad
+import torch
+
+def test_torchga_evolution():
+    """Test pygad.torchga with pygad.GA."""
+
+    # XOR data
+    data_inputs = torch.tensor([[0.0, 0.0], [0.1, 0.6], [1.0, 0.0], [1.1, 1.3]])
+    data_outputs = torch.tensor([[1.0, 0.0], [0.0, 1.0], [0.0, 1.0], [1.0, 0.0]]) # One-hot encoded
+
+    model = torch.nn.Sequential(
+        torch.nn.Linear(2, 4),
+        torch.nn.ReLU(),
+        torch.nn.Linear(4, 2),
+        torch.nn.Softmax(dim=1)
+    )
+
+    torch_ga = pygad.torchga.TorchGA(model=model, num_solutions=10)
+
+    def fitness_func(ga_instance, solution, solution_idx):
+        model_weights_dict = pygad.torchga.model_weights_as_dict(model=model,
+                                                                 weights_vector=solution)
+        model.load_state_dict(model_weights_dict)
+        predictions = model(data_inputs)
+        
+        loss_func = torch.nn.CrossEntropyLoss()
+        loss = loss_func(predictions, data_outputs).detach().numpy()
+        fitness = 1.0 / (loss + 0.00000001)
+        return fitness
+
+    ga_instance = pygad.GA(num_generations=2,
+                           num_parents_mating=5,
+                           initial_population=torch_ga.population_weights,
+                           fitness_func=fitness_func,
+                           suppress_warnings=True)
+
+    ga_instance.run()
+    assert ga_instance.run_completed
+    assert ga_instance.generations_completed == 2
+    
+    print("test_torchga_evolution passed.")
+
+if __name__ == "__main__":
+    test_torchga_evolution()
+    print("\nAll TorchGA tests passed!")