Update app.py

app.py

@@ -21,11 +21,18 @@ class Net(keras.Model):
         self.fc2 = keras.layers.Dense(10, activation='relu')
         self.fc3 = keras.layers.Dense(2)
 
+    def build(self, input_shape):
+        self.fc1.build(input_shape)
+        self.fc2.build(self.fc1.output_shape)
+        self.fc3.build(self.fc2.output_shape)
+        self.built = True
+
     def call(self, x):
         x = self.fc1(x)
         x = self.fc2(x)
         x = self.fc3(x)
         return x
+
 # Define a genetic algorithm class
 class GeneticAlgorithm:
     def __init__(self, population_size, task_id):
@@ -38,38 +45,36 @@ class GeneticAlgorithm:
         fitness = []
         for i, net in enumerate(self.population):
             net.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
+            net.build(input_shape=(None, 10))
             net.fit(X_train, y_train, epochs=10, verbose=0)
             loss, accuracy = net.evaluate(X_test, y_test, verbose=0)
             fitness.append(accuracy)
         if len(fitness) > 0:
-            self.population = [self.population[i] for i in np.argsort(fitness)[-len(self.population)//2:]]
+            self.population = [self.population[i] for i in np.argsort(fitness)[-self.population_size//2:]]
 
     def crossover(self):
         offspring = []
-        for _ in range(len(self.population)//2):
+        X = np.random.rand(1, 10)
+        for _ in range(self.population_size//2):
             parent1, parent2 = random.sample(self.population, 2)
             child = Net()
-            child.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
+            child.build(input_shape=(None, 10))
+            parent1.build(input_shape=(None, 10))
+            parent2.build(input_shape=(None, 10))
             
-            # Get the weights of the parent networks
+            # Average the weights of the two parents
             parent1_weights = parent1.get_weights()
             parent2_weights = parent2.get_weights()
-            
-            # Average the weights of the two parents
-            child_weights = []
-            for w1, w2 in zip(parent1_weights, parent2_weights):
-                child_weights.append((w1 + w2) / 2)
-            
-            # Set the weights of the child network
-            child.fc1.set_weights(child_weights[:2])
-            child.fc2.set_weights(child_weights[2:4])
-            child.fc3.set_weights(child_weights[4:])
+            child_weights = [(np.array(w1) + np.array(w2)) / 2 for w1, w2 in zip(parent1_weights, parent2_weights)]
+            child.set_weights(child_weights)
             
             offspring.append(child)
         self.population += offspring
 
     def mutation(self):
+        X = np.random.rand(1, 10)
         for net in self.population:
+            net.build(input_shape=(None, 10))
             if random.random() < 0.1:
                 weights = net.get_weights()
                 new_weights = [np.array(w) + np.random.randn(*w.shape) * 0.1 for w in weights]
@@ -87,9 +92,7 @@ num_generations = st.sidebar.slider("Number of generations", 1, 100, 10)
 gas = None
 
 # Run the evolution
-gas = []
 if st.button("Run evolution"):
-    gas = [GeneticAlgorithm(population_size, task_id) for task_id in range(num_tasks)]
     gas = [GeneticAlgorithm(population_size, task_id) for task_id in range(num_tasks)]
     for generation in range(num_generations):
         for ga in gas:
@@ -98,47 +101,50 @@ if st.button("Run evolution"):
             ga.mutation()
         st.write(f"Generation {generation+1} complete")
 
-    # Evaluate the final population
-final_accuracy = []
-for task_id, ga in enumerate(gas):
-    X_train, X_test, y_train, y_test = generate_dataset(task_id)
-    accuracy = []
-    for net in ga.population:
-        net.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
-        net.fit(X_train, y_train, epochs=10, verbose=0)
-        loss, acc = net.evaluate(X_test, y_test, verbose=0)
-        accuracy.append(acc)
-    if len(accuracy) > 0:
-        final_accuracy.append(np.mean(accuracy))
-
-        
-
-# Trade populations between tasks
-for i in range(len(gas)):
-    for j in range(i+1, len(gas)):
-        ga1 = gas[i]
-        ga2 = gas[j]
-        population1 = ga1.population
-        population2 = ga2.population
-        num_trade = int(0.1 * population_size)
-        trade1 = random.sample(population1, num_trade)
-        trade2 = random.sample(population2, num_trade)
-        ga1.population = population1 + trade2
-        ga2.population = population2 + trade1
+        # Evaluate the final population
+    if gas is not None:
+        final_accuracy = []
+        for task_id, ga in enumerate(gas):
+            X_train, X_test, y_train, y_test = generate_dataset(task_id)
+            accuracy = []
+            for net in ga.population:
+                net.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
+                net.build(input_shape=(None, 10))
+                net.fit(X_train, y_train, epochs=10, verbose=0)
+                loss, acc = net.evaluate(X_test, y_test, verbose=0)
+                accuracy.append(acc)
+            if len(accuracy) > 0:
+                final_accuracy.append(np.mean(accuracy))
+        if len(final_accuracy) > 0:
+            st.write(f"Final accuracy: {np.mean(final_accuracy)}")
 
-# Evaluate the final population after trading
-final_accuracy_after_trade = []
-for task_id, ga in enumerate(gas):
-    X_train, X_test, y_train, y_test = generate_dataset(task_id)
-    accuracy = []
-    for net in ga.population:
-        net.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
-        net.build(input_shape=(None, 10))  # Compile the model before training
-        net.fit(X_train, y_train, epochs=10, verbose=0)
-        loss, acc = net.evaluate(X_test, y_test, verbose=0)
-        accuracy.append(acc)
-    final_accuracy_after_trade.append(np.mean(accuracy))
-    if len(final_accuracy) > 0:
-        st.write(f"Final accuracy: {np.mean(final_accuracy)}")
-        st.write(f"Final accuracy after trading: {np.mean(final_accuracy_after_trade)}")
+    # Trade populations between tasks
+    if gas is not None:
+        for i in range(len(gas)):
+            for j in range(i+1, len(gas)):
+                ga1 = gas[i]
+                ga2 = gas[j]
+                population1 = ga1.population
+                population2 = ga2.population
+                num_trade = int(0.1 * population_size)
+                trade1 = random.sample(population1, num_trade)
+                trade2 = random.sample(population2, num_trade)
+                ga1.population = population1 + trade2
+                ga2.population = population2 + trade1
 
+    # Evaluate the final population after trading
+    if gas is not None:
+        final_accuracy_after_trade = []
+        for task_id, ga in enumerate(gas):
+            X_train, X_test, y_train, y_test = generate_dataset(task_id)
+            accuracy = []
+            for net in ga.population:
+                net.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
+                net.build(input_shape=(None, 10))
+                net.fit(X_train, y_train, epochs=10, verbose=0)
+                loss, acc = net.evaluate(X_test, y_test, verbose=0)
+                accuracy.append(acc)
+            final_accuracy_after_trade.append(np.mean(accuracy))
+        if len(final_accuracy) > 0 and len(final_accuracy_after_trade) > 0:
+            st.write(f"Final accuracy: {np.mean(final_accuracy)}")
+            st.write(f"Final accuracy after trading: {np.mean(final_accuracy_after_trade)}")