Update app.py

app.py

@@ -1,11 +1,11 @@
 import streamlit as st
 import numpy as np
-import torch
-import torch.nn as nn
-import random
+import tensorflow as tf
+from tensorflow import keras
 from sklearn.datasets import make_classification
 from sklearn.model_selection import train_test_split
 from sklearn.metrics import accuracy_score
+import random
 
 # Define a function to generate a dataset
 def generate_dataset(task_id):
@@ -14,16 +14,16 @@ def generate_dataset(task_id):
     return X_train, X_test, y_train, y_test
 
 # Define a neural network class
-class Net(nn.Module):
+class Net(keras.Model):
     def __init__(self):
         super(Net, self).__init__()
-        self.fc1 = nn.Linear(10, 20)
-        self.fc2 = nn.Linear(20, 10)
-        self.fc3 = nn.Linear(10, 2)
+        self.fc1 = keras.layers.Dense(20, activation='relu', input_shape=(10,))
+        self.fc2 = keras.layers.Dense(10, activation='relu')
+        self.fc3 = keras.layers.Dense(2)
 
-    def forward(self, x):
-        x = torch.relu(self.fc1(x))
-        x = torch.relu(self.fc2(x))
+    def call(self, x):
+        x = self.fc1(x)
+        x = self.fc2(x)
         x = self.fc3(x)
         return x
 
@@ -37,21 +37,9 @@ class GeneticAlgorithm:
         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)
+            net.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
+            net.fit(X_train, y_train, epochs=10, verbose=0)
+            loss, accuracy = net.evaluate(X_test, y_test, verbose=0)
             fitness.append(accuracy)
         self.population = [self.population[i] for i in np.argsort(fitness)[-self.population_size//2:]]
 
@@ -60,18 +48,27 @@ class GeneticAlgorithm:
         for _ in range(self.population_size//2):
             parent1, parent2 = random.sample(self.population, 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
+            child.fc1.set_weights((np.array(parent1.fc1.get_weights()) + np.array(parent2.fc1.get_weights())) / 2)
+            child.fc2.set_weights((np.array(parent1.fc2.get_weights()) + np.array(parent2.fc2.get_weights())) / 2)
+            child.fc3.set_weights((np.array(parent1.fc3.get_weights()) + np.array(parent2.fc3.get_weights())) / 2)
             offspring.append(child)
         self.population += offspring
 
     def mutation(self):
         for net in self.population:
             if random.random() < 0.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
+                weights = net.fc1.get_weights()
+                weights[0] += np.random.randn(*weights[0].shape) * 0.1
+                weights[1] += np.random.randn(*weights[1].shape) * 0.1
+                net.fc1.set_weights(weights)
+                weights = net.fc2.get_weights()
+                weights[0] += np.random.randn(*weights[0].shape) * 0.1
+                weights[1] += np.random.randn(*weights[1].shape) * 0.1
+                net.fc2.set_weights(weights)
+                weights = net.fc3.get_weights()
+                weights[0] += np.random.randn(*weights[0].shape) * 0.1
+                weights[1] += np.random.randn(*weights[1].shape) * 0.1
+                net.fc3.set_weights(weights)
 
 # Streamlit app
 st.title("Evolution of Sub-Models")
@@ -98,13 +95,9 @@ if st.button("Run evolution"):
         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()
+            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)
+        final_accuracy.append(np.mean(accuracy))
+    st.write(f"Final accuracy: {np.mean(final_accuracy)}")