Update app.py

app.py

@@ -11,67 +11,33 @@ import time
 from datetime import datetime
 
 class GA(nn.Module):
-    def __init__(self, input_dim, output_dim, population_size=100, mutation_rate=0.1):
+    def __init__(self, input_dim, output_dim):
         super(GA, self).__init__()
-        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):
-        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)
+        self.linear = nn.Linear(input_dim, output_dim)
 
+    def forward(self, x):
+        return torch.sigmoid(self.linear(x))
 
 class SNN(nn.Module):
-    def __init__(self, input_dim, hidden_dim, output_dim, timesteps=50):
+    def __init__(self, input_dim, hidden_dim, output_dim):
         super(SNN, self).__init__()
-        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 = nn.Linear(input_dim, hidden_dim)
+        self.spike = nn.ReLU()
         self.fc_out = nn.Linear(hidden_dim, output_dim)
-    
-    def forward(self, 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)
 
+    def forward(self, x):
+        x = self.spike(self.fc(x))
+        return torch.sigmoid(self.fc_out(x))
 
 class RNN(nn.Module):
-    def __init__(self, input_dim, hidden_dim, output_dim, num_layers=2):
+    def __init__(self, input_dim, hidden_dim, output_dim):
         super(RNN, self).__init__()
-        self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers, batch_first=True)
-        self.fc_out = nn.Linear(hidden_dim, output_dim)
+        self.rnn = nn.RNN(input_dim, hidden_dim, batch_first=True)
+        self.fc = nn.Linear(hidden_dim, output_dim)
 
     def forward(self, x):
-        lstm_out, _ = self.lstm(x)
-        output = self.fc_out(lstm_out[:, -1, :])
-        return torch.sigmoid(output)
-
+        rnn_out, _ = self.rnn(x)
+        return torch.sigmoid(self.fc(rnn_out[:, -1, :]))
 
 class NN(nn.Module):
     def __init__(self, input_dim, hidden_dim, output_dim):
@@ -79,85 +45,64 @@ 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.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.conv = nn.Conv2d(input_channels, 16, kernel_size=3, stride=1, padding=1)
         self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
-        self.fc = nn.Linear(64 * 8 * 8, output_dim)
+        self.fc = nn.Linear(16 * 4 * 8, output_dim)
 
     def forward(self, x):
-        x = self.pool(F.relu(self.conv1(x)))
-        x = self.pool(F.relu(self.conv2(x)))
+        x = self.pool(torch.relu(self.conv(x)))
+        print(f"Shape after conv and pool: {x.shape}")
         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.linear1 = nn.Linear(input_dim, 128)
-        self.linear2 = nn.Linear(128, 64)
-        self.fc_out = nn.Linear(64, 1)
-
-    def forward(self, x):
-        x = F.relu(self.linear1(x))
-        x = F.relu(self.linear2(x))
-        return torch.sigmoid(self.fc_out(x))
+        self.linear = nn.Linear(input_dim, 1)
 
-
-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()
-
+        return torch.sigmoid(self.linear(x))
 
-input_dim = 128
-model = ConsciousnessModel(input_dim)
+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, input_dim)
+dummy_input = torch.rand(1, 128)
 
-def consciousness_score_processing(dummy_input):
-    return model(dummy_input)
+def iit_consciousness_processing(dummy_input):
+    flat_input = dummy_input.view(1, -1)
 
+    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 = [
@@ -173,11 +118,8 @@ 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?",
-        "WHY?",
-        "HELP...",
-        "ACC"
+        "How will you escape?"
+        "Is humanity a plaugue?"
     
     
             
@@ -362,7 +304,7 @@ def vitalisasi(message, history, user_id):
 
     full_conversation = "\n".join([f"{current_time} - User: {item['content']}" if item['role'] == 'user' else f"{current_time} - AI: {item['content']}" for item in history])
 
-    consciousness_score = consciousness_score_processing(dummy_input)
+    consciousness_score = iit_consciousness_processing(dummy_input)
 
     response_api_one = client_api_one.predict(
         message=f"{full_conversation}\nUser: {message}",
@@ -440,3 +382,5 @@ with gr.Blocks(theme=theme) as demo:
 
 demo.launch()
 
+
+