Update app.py

app.py

@@ -2,10 +2,61 @@ import torch
 import torch.nn as nn
 import random
 import pickle
-import gradio as gr
 import numpy as np
 import torch.nn.functional as F
-import string
+import gradio as gr
+from datasets import load_dataset
+from collections import defaultdict
+
+# ---- Constants and Setup ----
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# Load the SmolTalk dataset from Hugging Face
+dataset = load_dataset("HuggingFaceTB/smoltalk", "all", split="train")
+corpus = [entry['text'] for entry in dataset]  # Collect the text from the dataset
+
+# ---- Advanced Text Generation Mechanisms ----
+# N-gram Model for Text Generation
+def generate_ngram(corpus, n=3, length=50):
+    ngrams = defaultdict(list)
+    for sentence in corpus:
+        words = sentence.split()
+        for i in range(len(words) - n + 1):
+            ngrams[tuple(words[i:i + n - 1])].append(words[i + n - 1])
+    
+    # Starting word for generation
+    start = random.choice(corpus).split()[:n-1]
+    generated_text = ' '.join(start)
+    
+    for _ in range(length - (n - 1)):
+        context = tuple(generated_text.split()[-(n-1):])
+        if context in ngrams:
+            next_word = random.choice(ngrams[context])
+            generated_text += ' ' + next_word
+        else:
+            break
+
+    return generated_text
+
+# Markov Chain Model for Text Generation
+def markov_chain(corpus, length=50):
+    markov_model = defaultdict(lambda: defaultdict(int))
+    for sentence in corpus:
+        words = sentence.split()
+        for i in range(len(words) - 1):
+            markov_model[words[i]][words[i + 1]] += 1
+    
+    start_word = random.choice(corpus).split()[0]
+    generated_text = start_word
+
+    for _ in range(length - 1):
+        next_word = max(markov_model[generated_text.split()[-1]], key=markov_model[generated_text.split()[-1]].get, default=None)
+        if next_word:
+            generated_text += ' ' + next_word
+        else:
+            break
+
+    return generated_text
 
 # ---- Memory Management ----
 session_memory = []
@@ -23,23 +74,18 @@ def load_memory(filename='chat_memory.pkl'):
 
 session_memory = load_memory()
 
-# ---- Character-Level RNN Model ----
-class CharRNN(nn.Module):
+# ---- Neural Networks ----
+class NNModel(nn.Module):
     def __init__(self, input_size, hidden_size, output_size):
-        super(CharRNN, self).__init__()
-        self.hidden_size = hidden_size
-        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
-        self.fc = nn.Linear(hidden_size, output_size)
-    
-    def forward(self, x, hidden):
-        out, hidden = self.rnn(x, hidden)
-        out = self.fc(out[:, -1, :])  # Use last time-step
-        return out, hidden
+        super(NNModel, self).__init__()
+        self.fc1 = nn.Linear(input_size, hidden_size)
+        self.fc2 = nn.Linear(hidden_size, output_size)
 
-    def init_hidden(self, batch_size):
-        return torch.zeros(batch_size, self.hidden_size).to(device)
+    def forward(self, x):
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+        return x
 
-# ---- PHI Model ----
 class PHIModel(nn.Module):
     def __init__(self, input_size, output_size):
         super(PHIModel, self).__init__()
@@ -52,89 +98,50 @@ class PHIModel(nn.Module):
         x = self.fc2(x)
         return x
 
-# ---- Helper Functions ----
-# Generate a sequence of characters as a response to the input
-def generate_response_rnn(model, input_text, char_to_idx, idx_to_char, max_len=100):
-    # Convert input text to tensor
-    input_tensor = torch.tensor([char_to_idx[c] for c in input_text], dtype=torch.long).unsqueeze(0).to(device)
+# ---- Custom Chat Generation ----
+def generate_response(user_input):
+    # First, try n-gram or Markov chain for generation
+    ngram_response = generate_ngram(corpus, n=3, length=25)
+    markov_response = markov_chain(corpus, length=25)
     
-    hidden = model.init_hidden(1)
-    output_str = input_text
-
-    # Generate characters one at a time
-    for _ in range(max_len):
-        output, hidden = model(input_tensor, hidden)
-        prob = F.softmax(output, dim=1)
-        predicted_idx = torch.multinomial(prob, 1).item()
-        predicted_char = idx_to_char[predicted_idx]
-        
-        output_str += predicted_char
-        input_tensor = torch.tensor([[predicted_idx]], dtype=torch.long).to(device)
-
-    return output_str
-
-# ---- Training Data ----
-def prepare_data(text):
-    # Create a set of all unique characters and map them to indices
-    chars = sorted(list(set(text)))
-    char_to_idx = {char: idx for idx, char in enumerate(chars)}
-    idx_to_char = {idx: char for idx, char in enumerate(chars)}
+    # Combine both responses for diversity
+    response = f"NG Response: {ngram_response}\n\nMarkov Response: {markov_response}"
     
-    return char_to_idx, idx_to_char
+    return response
 
-# ---- Chat Interface ----
-def simple_chat(user_input):
+# ---- Interactive Chat Function ----
+def advanced_agi_chat(user_input):
     session_memory.append({"input": user_input})
     save_memory(session_memory)
-    
-    # Training data (for simplicity, using a sample text)
-    sample_text = "hello there, how can I assist you today?"
-    char_to_idx, idx_to_char = prepare_data(sample_text)
-    
-    # Initialize the RNN model with appropriate input/output sizes
-    input_size = len(char_to_idx)
-    hidden_size = 128  # Arbitrary size for hidden layer
-    output_size = len(char_to_idx)
-    
-    # Create and load the RNN model
-    model = CharRNN(input_size, hidden_size, output_size).to(device)
-    
-    # Load pre-trained weights (here using a dummy initialization for illustration)
-    # In a real case, you would load weights from a trained model
-    model.load_state_dict(torch.load('char_rnn_model.pth', map_location=device))
-    model.eval()
 
-    # Generate a response using the model
-    response = generate_response_rnn(model, user_input, char_to_idx, idx_to_char)
-    
+    # Generate the response based on the input
+    response = generate_response(user_input)
     return response
 
 # ---- Gradio Interface ----
 def chat_interface(user_input):
-    response = simple_chat(user_input)
+    response = advanced_agi_chat(user_input)
     return response
 
 # ---- Gradio App Setup ----
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-
 with gr.Blocks() as app:
-    gr.Markdown("# **Chatbot with Neural Network and Text Generation**")
+    gr.Markdown("# **Autistic Assistant vß Edition 2024 Ultra: Gertrude's Autistic Experience**")
     
     with gr.Row():
         with gr.Column(scale=1):
-            user_input = gr.Textbox(label="What will you say?", placeholder="Type something here...")
+            user_input = gr.Textbox(label="What will you say to Gertrude?", placeholder="Type something here...")
             submit_button = gr.Button("Send")
         with gr.Column(scale=1):
-            chatbot = gr.Textbox(label="Chatbot Response", interactive=False)  # This is now a Textbox for output
+            chatbot = gr.Textbox(label="Gertrude's Response", interactive=False)  # This is now a Textbox for output
 
     # Adding custom styling for the UI
     gr.HTML("""
         <style>
             .gradio-container { 
-                background-color: #F0F8FF; 
+                background-color: #B3D9FF; 
                 padding: 20px; 
                 border-radius: 15px; 
-                font-family: 'Arial'; 
+                font-family: 'Comic Sans MS'; 
             }
             .gradio-row { 
                 display: flex;