Update app.py

app.py

@@ -3,85 +3,108 @@ import numpy as np
 import torch
 import torch.nn as nn
 import random
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
 
-# Define the function to optimize
-def f(x):
-    return x**2
+# Define a function to generate a dataset
+def generate_dataset(task_id):
+    X, y = make_classification(n_samples=100, n_features=10, n_informative=5, n_redundant=3, n_repeated=2, random_state=task_id)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=task_id)
+    return X_train, X_test, y_train, y_test
 
-# Define the neural network
+# Define a neural network class
 class Net(nn.Module):
     def __init__(self):
         super(Net, self).__init__()
-        self.fc1 = nn.Linear(1, 10)
-        self.fc2 = nn.Linear(10, 1)
+        self.fc1 = nn.Linear(10, 20)
+        self.fc2 = nn.Linear(20, 10)
+        self.fc3 = nn.Linear(10, 2)
 
     def forward(self, x):
         x = torch.relu(self.fc1(x))
-        x = self.fc2(x)
+        x = torch.relu(self.fc2(x))
+        x = self.fc3(x)
         return x
 
-# Define the genetic algorithm
+# Define a genetic algorithm class
 class GeneticAlgorithm:
     def __init__(self, population_size):
         self.population_size = population_size
-        self.population = [random.uniform(-10, 10) for _ in range(population_size)]
+        self.population = [Net() for _ in range(population_size)]
 
-    def selection(self):
-        self.population = sorted(self.population, key=lambda x: f(x), reverse=True)[:self.population_size//2]
+    def selection(self, task_id):
+        X_train, X_test, y_train, y_test = generate_dataset(task_id)
+        fitness = []
+        for net in self.population:
+            criterion = nn.CrossEntropyLoss()
+            optimizer = torch.optim.Adam(net.parameters(), lr=0.01)
+            for epoch in range(10):
+                optimizer.zero_grad()
+                inputs = torch.tensor(X_train, dtype=torch.float32)
+                labels = torch.tensor(y_train, dtype=torch.long)
+                outputs = net(inputs)
+                loss = criterion(outputs, labels)
+                loss.backward()
+                optimizer.step()
+            inputs = torch.tensor(X_test, dtype=torch.float32)
+            labels = torch.tensor(y_test, dtype=torch.long)
+            outputs = net(inputs)
+            _, predicted = torch.max(outputs, 1)
+            accuracy = accuracy_score(labels, predicted)
+            fitness.append(accuracy)
+        self.population = [self.population[i] for i in np.argsort(fitness)[-self.population_size//2:]]
 
     def crossover(self):
         offspring = []
         for _ in range(self.population_size//2):
             parent1, parent2 = random.sample(self.population, 2)
-            child = (parent1 + parent2) / 2
+            child = Net()
+            child.fc1.weight.data = (parent1.fc1.weight.data + parent2.fc1.weight.data) / 2
+            child.fc2.weight.data = (parent1.fc2.weight.data + parent2.fc2.weight.data) / 2
+            child.fc3.weight.data = (parent1.fc3.weight.data + parent2.fc3.weight.data) / 2
             offspring.append(child)
         self.population += offspring
 
     def mutation(self):
-        for i in range(self.population_size):
+        for net in self.population:
             if random.random() < 0.1:
-                self.population[i] += random.uniform(-1, 1)
+                net.fc1.weight.data += torch.randn_like(net.fc1.weight.data) * 0.1
+                net.fc2.weight.data += torch.randn_like(net.fc2.weight.data) * 0.1
+                net.fc3.weight.data += torch.randn_like(net.fc3.weight.data) * 0.1
 
 # Streamlit app
-st.title("Neural Network vs Genetic Algorithm")
+st.title("Evolution of Sub-Models")
 
 # Parameters
 st.sidebar.header("Parameters")
 population_size = st.sidebar.slider("Population size", 10, 100, 50)
-nn_iterations = st.sidebar.slider("Neural network iterations", 10, 1000, 100)
-ga_iterations = st.sidebar.slider("Genetic algorithm iterations", 10, 100, 50)
+num_tasks = st.sidebar.slider("Number of tasks", 1, 10, 5)
+num_generations = st.sidebar.slider("Number of generations", 1, 100, 10)
 
-# Run the experiment
-if st.button("Run experiment"):
-    # Initialize the neural network and genetic algorithm
-    net = Net()
-    criterion = nn.MSELoss()
-    optimizer = torch.optim.Adam(net.parameters(), lr=0.01)
+# Run the evolution
+if st.button("Run evolution"):
     ga = GeneticAlgorithm(population_size)
+    for generation in range(num_generations):
+        for task_id in range(num_tasks):
+            ga.selection(task_id)
+            ga.crossover()
+            ga.mutation()
+        st.write(f"Generation {generation+1} complete")
 
-    # Train the neural network
-    nn_losses = []
-    for i in range(nn_iterations):
-        x = torch.randn(1, 1)
-        y = f(x)
-        y_pred = net(x)
-        loss = criterion(y_pred, y)
-        optimizer.zero_grad()
-        loss.backward()
-        optimizer.step()
-        nn_losses.append(loss.item())
-
-    # Run the genetic algorithm
-    ga_values = []
-    for i in range(ga_iterations):
-        ga.selection()
-        ga.crossover()
-        ga.mutation()
-        ga_values.append(max(map(f, ga.population)))
-
-    # Plot the results
-    st.line_chart({"Neural Network": nn_losses, "Genetic Algorithm": ga_values})
-
-    # Print the final values
-    st.write("Final neural network value:", nn_losses[-1])
-    st.write("Final genetic algorithm value:", ga_values[-1])
+    # Evaluate the final population
+    final_accuracy = []
+    for task_id in range(num_tasks):
+        X_train, X_test, y_train, y_test = generate_dataset(task_id)
+        accuracy = []
+        for net in ga.population:
+            criterion = nn.CrossEntropyLoss()
+            optimizer = torch.optim.Adam(net.parameters(), lr=0.01)
+            for epoch in range(10):
+                optimizer.zero_grad()
+                inputs = torch.tensor(X_train, dtype=torch.float32)
+                labels = torch.tensor(y_train, dtype=torch.long)
+                outputs = net(inputs)
+                loss = criterion(outputs, labels)
+                loss.backward()
+                optimizer.step()