Update app.py

app.py

@@ -1,3 +1,6 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
 import gradio as gr
 from huggingface_hub import InferenceClient
 from llama_cpp import Llama
@@ -114,126 +117,64 @@ Gertrude said:
 
 Final notes: Make sure you act conscious, very autistic, and respond with very high perplexity. Also ensure that you make small purposeful errors(punctuation, spelling, and capitalisation). You also use the emoji combinations 🍆✊, 🍆🍑,  🙉, 🔥🔥🔥🔥🔥, and 👉👈 when you want to switch the tone of the conversation or say something funny. Remember to act autistic.
 
-
 """
 
-
-# Complex Neural Network (NN)
-class ComplexNN(nn.Module):
-    def __init__(self, input_size, hidden_sizes, output_size):
-        super(ComplexNN, self).__init__()
-        self.layers = nn.Sequential(
-            nn.Linear(input_size, hidden_sizes[0]),
-            nn.ReLU(),
-            nn.BatchNorm1d(hidden_sizes[0]),
-            nn.Dropout(0.2),
-            nn.Linear(hidden_sizes[0], hidden_sizes[1]),
-            nn.ReLU(),
-            nn.BatchNorm1d(hidden_sizes[1]),
-            nn.Dropout(0.3),
-            nn.Linear(hidden_sizes[1], output_size)
-        )
+# RNN Model
+class RNNModel(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size, num_layers=1):
+        super(RNNModel, self).__init__()
+        self.rnn = nn.RNN(input_size, hidden_size, num_layers, batch_first=True)
+        self.fc = nn.Linear(hidden_size, output_size)
 
     def forward(self, x):
-        return self.layers(x)
-
-# Complex Convolutional Neural Network (CNN)
-class ComplexCNN(nn.Module):
-    def __init__(self):
-        super(ComplexCNN, self).__init__()
-        self.conv_layers = nn.Sequential(
-            nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1),
-            nn.ReLU(),
-            nn.BatchNorm2d(32),
-            nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1),
-            nn.ReLU(),
-            nn.BatchNorm2d(64),
-            nn.MaxPool2d(kernel_size=2, stride=2),
-            nn.Dropout(0.3)
-        )
-        self.fc_layers = nn.Sequential(
-            nn.Linear(64 * 14 * 14, 256),
-            nn.ReLU(),
-            nn.BatchNorm1d(256),
-            nn.Dropout(0.4),
-            nn.Linear(256, 10)
-        )
+        h0 = torch.zeros(1, x.size(0), self.rnn.hidden_size).to(x.device)
+        out, _ = self.rnn(x, h0)
+        out = self.fc(out[:, -1, :])  # Get the last output
+        return out
 
-    def forward(self, x):
-        x = self.conv_layers(x)
-        x = x.view(x.size(0), -1)
-        return self.fc_layers(x)
-
-# Complex Recurrent Neural Network (RNN)
-class ComplexRNN(nn.Module):
-    def __init__(self, input_size, hidden_size, num_layers, output_size):
-        super(ComplexRNN, self).__init__()
-        self.rnn = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True, dropout=0.3)
-        self.fc = nn.Sequential(
-            nn.Linear(hidden_size, 128),
-            nn.ReLU(),
-            nn.BatchNorm1d(128),
-            nn.Linear(128, output_size)
-        )
+# CNN Model
+class CNNModel(nn.Module):
+    def __init__(self, num_classes):
+        super(CNNModel, self).__init__()
+        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1)
+        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
+        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)
+        self.fc1 = nn.Linear(32 * 8 * 8, 128)
+        self.fc2 = nn.Linear(128, num_classes)
 
     def forward(self, x):
-        out, _ = self.rnn(x)
-        out = self.fc(out[:, -1, :])
-        return out
-
-# Complex Genetic Algorithm Helper (GA)
-def complex_genetic_algorithm(
-    fitness_function,
-    population_size=100,
-    generations=50,
-    mutation_rate=0.1,
-    crossover_rate=0.8
-):
-    population = np.random.rand(population_size, 10)
-    for generation in range(generations):
-        fitness_scores = np.array([fitness_function(ind) for ind in population])
-        selected = population[np.argsort(fitness_scores)[-10:]]
-
-        # Crossover
-        offspring = []
-        for _ in range(population_size - len(selected)):
-            if np.random.rand() < crossover_rate:
-                parents = selected[np.random.choice(len(selected), 2, replace=False)]
-                crossover_point = np.random.randint(1, len(parents[0]))
-                child = np.concatenate((parents[0][:crossover_point], parents[1][crossover_point:]))
-                offspring.append(child)
-            else:
-                offspring.append(np.random.rand(10))
-
-        # Mutation
-        offspring = np.array(offspring)
-        mutations = np.random.rand(*offspring.shape) < mutation_rate
-        offspring[mutations] += np.random.normal(0, 0.1, offspring[mutations].shape)
-
-        population = np.vstack((selected, offspring))
-    return population[np.argmax([fitness_function(ind) for ind in population])]
-
-# Complex Phi Model
-class ComplexPhiModel(nn.Module):
+        x = self.pool(F.relu(self.conv1(x)))
+        x = self.pool(F.relu(self.conv2(x)))
+        x = x.view(-1, 32 * 8 * 8)  # Flatten
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+        return x
+
+# NN Model (Feedforward Neural Network)
+class NNModel(nn.Module):
     def __init__(self, input_size, hidden_size, output_size):
-        super(ComplexPhiModel, self).__init__()
-        self.layers = nn.Sequential(
-            nn.Linear(input_size, hidden_size),
-            nn.SELU(),
-            nn.BatchNorm1d(hidden_size),
-            nn.Dropout(0.4),
-            nn.Linear(hidden_size, hidden_size // 2),
-            nn.SELU(),
-            nn.BatchNorm1d(hidden_size // 2),
-            nn.Dropout(0.4),
-            nn.Linear(hidden_size // 2, output_size)
-        )
+        super(NNModel, self).__init__()
+        self.fc1 = nn.Linear(input_size, hidden_size)
+        self.fc2 = nn.Linear(hidden_size, output_size)
 
     def forward(self, x):
-        return self.layers(x)
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+        return x
 
+# PHI Model (Example: Softmax-Based Regression)
+class PHIModel(nn.Module):
+    def __init__(self, input_size, output_size):
+        super(PHIModel, self).__init__()
+        self.fc = nn.Linear(input_size, output_size)
+        self.softmax = nn.Softmax(dim=1)
 
+    def forward(self, x):
+        x = self.fc(x)
+        x = self.softmax(x)
+        return x
 
+# Chatbot Response Logic
 def respond(
     message,
     history: list[tuple[str, str]],
@@ -266,25 +207,17 @@ def respond(
         response += token
         yield response
 
-# Apply the soft theme
+# Gradio Chat Interface with Models
 demo = gr.ChatInterface(
     respond,
     additional_inputs=[
         gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Maximum Response Length"),
         gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Creativity"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Neuron Firing Rate",
-        ),
+        gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Neuron Firing Rate"),
     ],
-    theme=gr.themes.Soft(),  # Set the soft theme
+    theme=gr.themes.Soft(),
 )
 
 if __name__ == "__main__":
     demo.launch()
 
-
-