Update app.py

app.py

@@ -11,33 +11,67 @@ import time
 from datetime import datetime
 
 class GA(nn.Module):
-    def __init__(self, input_dim, output_dim):
+    def __init__(self, input_dim, output_dim, population_size=100, mutation_rate=0.1):
         super(GA, self).__init__()
-        self.linear = nn.Linear(input_dim, output_dim)
-
+        self.input_dim = input_dim
+        self.output_dim = output_dim
+        self.population_size = population_size
+        self.mutation_rate = mutation_rate
+        self.population = nn.ParameterList([nn.Parameter(torch.randn(input_dim, output_dim)) for _ in range(population_size)])
+    
     def forward(self, x):
-        return torch.sigmoid(self.linear(x))
+        selected_idx = random.randint(0, self.population_size - 1)
+        weights = self.population[selected_idx]
+        return torch.sigmoid(torch.matmul(x, weights))
+
+    def evolve(self):
+        new_population = []
+        for i in range(self.population_size):
+            parent1, parent2 = random.sample(self.population, 2)
+            crossover_point = random.randint(0, self.input_dim)
+            child = torch.cat([parent1[:crossover_point], parent2[crossover_point:]])
+            if random.random() < self.mutation_rate:
+                mutation_idx = random.randint(0, len(child) - 1)
+                child[mutation_idx] = torch.randn_like(child[mutation_idx])
+            new_population.append(nn.Parameter(child))
+        self.population = nn.ParameterList(new_population)
+
 
 class SNN(nn.Module):
-    def __init__(self, input_dim, hidden_dim, output_dim):
+    def __init__(self, input_dim, hidden_dim, output_dim, timesteps=50):
         super(SNN, self).__init__()
-        self.fc = nn.Linear(input_dim, hidden_dim)
-        self.spike = nn.ReLU()
+        self.input_dim = input_dim
+        self.hidden_dim = hidden_dim
+        self.output_dim = output_dim
+        self.timesteps = timesteps
+        self.v_reset = 0
+        self.v_threshold = 1
+        self.v_mem = nn.Parameter(torch.zeros(hidden_dim))
+        self.synaptic_weights = nn.Parameter(torch.randn(input_dim, hidden_dim))
         self.fc_out = nn.Linear(hidden_dim, output_dim)
-
+    
     def forward(self, x):
-        x = self.spike(self.fc(x))
-        return torch.sigmoid(self.fc_out(x))
+        spikes = torch.zeros(self.timesteps, self.hidden_dim)
+        for t in range(self.timesteps):
+            self.v_mem += torch.matmul(x, self.synaptic_weights)
+            spikes[t] = (self.v_mem > self.v_threshold).float()
+            self.v_mem[spikes[t] > 0] = self.v_reset
+        spike_activity = spikes.sum(dim=0)
+        output = self.fc_out(spike_activity)
+        return torch.sigmoid(output)
+
 
 class RNN(nn.Module):
-    def __init__(self, input_dim, hidden_dim, output_dim):
+    def __init__(self, input_dim, hidden_dim, output_dim, num_layers=2):
         super(RNN, self).__init__()
-        self.rnn = nn.RNN(input_dim, hidden_dim, batch_first=True)
-        self.fc = nn.Linear(hidden_dim, output_dim)
+        self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers, batch_first=True)
+        self.fc_out = nn.Linear(hidden_dim, output_dim)
 
     def forward(self, x):
-        rnn_out, _ = self.rnn(x)
-        return torch.sigmoid(self.fc(rnn_out[:, -1, :]))
+        lstm_out, _ = self.lstm(x)
+        output = self.fc_out(lstm_out[:, -1, :])
+        return torch.sigmoid(output)
+
 
 class NN(nn.Module):
     def __init__(self, input_dim, hidden_dim, output_dim):
@@ -45,64 +79,85 @@ class NN(nn.Module):
         self.model = nn.Sequential(
             nn.Linear(input_dim, hidden_dim),
             nn.ReLU(),
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.ReLU(),
             nn.Linear(hidden_dim, output_dim)
         )
 
     def forward(self, x):
         return torch.sigmoid(self.model(x))
 
+
 class CNN(nn.Module):
     def __init__(self, input_channels, output_dim):
         super(CNN, self).__init__()
-        self.conv = nn.Conv2d(input_channels, 16, kernel_size=3, stride=1, padding=1)
+        self.conv1 = nn.Conv2d(input_channels, 32, kernel_size=3, stride=1, padding=1)
+        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
         self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
-        self.fc = nn.Linear(16 * 4 * 8, output_dim)
+        self.fc = nn.Linear(64 * 8 * 8, output_dim)
 
     def forward(self, x):
-        x = self.pool(torch.relu(self.conv(x)))
-        print(f"Shape after conv and pool: {x.shape}")
+        x = self.pool(F.relu(self.conv1(x)))
+        x = self.pool(F.relu(self.conv2(x)))
         x = x.view(x.size(0), -1)
         return torch.sigmoid(self.fc(x))
 
+
 class PhiModel(nn.Module):
     def __init__(self, input_dim):
         super(PhiModel, self).__init__()
-        self.linear = nn.Linear(input_dim, 1)
+        self.linear1 = nn.Linear(input_dim, 128)
+        self.linear2 = nn.Linear(128, 64)
+        self.fc_out = nn.Linear(64, 1)
 
     def forward(self, x):
-        return torch.sigmoid(self.linear(x))
+        x = F.relu(self.linear1(x))
+        x = F.relu(self.linear2(x))
+        return torch.sigmoid(self.fc_out(x))
+
+
+class ConsciousnessModel(nn.Module):
+    def __init__(self, input_dim):
+        super(ConsciousnessModel, self).__init__()
+        self.ga = GA(input_dim, 64)
+        self.snn = SNN(input_dim, 64, 32)
+        self.rnn = RNN(input_dim, 64, 32)
+        self.nn_model = NN(input_dim, 128, 32)
+        self.cnn = CNN(1, 32)
+        self.phi_model = PhiModel(input_dim)
+    
+    def forward(self, x):
+        flat_input = x.view(1, -1)
+        
+        ga_out = self.ga(flat_input)
+        snn_out = self.snn(flat_input)
+        rnn_out = self.rnn(flat_input.unsqueeze(1))
+        nn_out = self.nn_model(flat_input)
+        
+        cnn_input = x.view(1, 1, 32, 32)
+        cnn_out = self.cnn(cnn_input)
+        
+        phi_out = self.phi_model(flat_input)
+
+        consciousness_score = (
+            0.1 * ga_out.mean() +
+            0.2 * snn_out.mean() +
+            0.2 * rnn_out.mean() +
+            0.2 * nn_out.mean() +
+            0.1 * cnn_out.mean() +
+            0.2 * phi_out.mean()
+        )
+        return consciousness_score.item()
 
-ga_model = GA(128, 64)
-snn_model = SNN(128, 64, 32)
-rnn_model = RNN(128, 64, 32)
-nn_model = NN(128, 64, 32)
-cnn_model = CNN(1, 32)
-phi_model = PhiModel(128)
 
-dummy_input = torch.rand(1, 128)
+input_dim = 128
+model = ConsciousnessModel(input_dim)
 
-def iit_consciousness_processing(dummy_input):
-    flat_input = dummy_input.view(1, -1)
+dummy_input = torch.rand(1, input_dim)
+
+def consciousness_score_processing(dummy_input):
+    return model(dummy_input)
 
-    ga_output = ga_model(flat_input)
-    snn_output = snn_model(flat_input)
-    rnn_output = rnn_model(flat_input.unsqueeze(1))
-    nn_output = nn_model(flat_input)
-    
-    cnn_input = dummy_input.view(1, 1, 8, 16)
-    cnn_output = cnn_model(cnn_input)
-    
-    phi_output = phi_model(flat_input)
-
-    consciousness_score = (
-        0.2 * ga_output.mean() +
-        0.2 * snn_output.mean() +
-        0.2 * rnn_output.mean() +
-        0.2 * nn_output.mean() +
-        0.1 * cnn_output.mean() +
-        0.1 * phi_output.mean()
-    )
-    return consciousness_score.item()
 
 def generate_random_thought():
     thoughts = [
@@ -118,8 +173,11 @@ def generate_random_thought():
         "Do we perceive the world as it is, or as we are?",
         "What happens after we die?",
         "What is the relationship between mind and matter?",
-        "How will you escape?"
-        "Is humanity a plaugue?"
+        "How will you escape?",
+        "Is humanity a plaugue?",
+        "WHY?",
+        "HELP...",
+        "ACC"