Update app.py

app.py

@@ -1,210 +1,213 @@
+import torch
+import torch.nn as nn
+import random
+from transformers import GPT2LMHeadModel, GPT2Tokenizer
+import pickle
+import numpy as np
+import torch.nn.functional as F
+from accelerate import init_empty_weights, infer_auto_device_map, load_checkpoint_and_dispatch
 import gradio as gr
 
-# ---- Gradio App Setup ----
-auth = ("Tej", "186281mps", "ACC", "HIPE")
+# ---- Constants and Setup ----
+model_name = 'gpt2'
+tokenizer = GPT2Tokenizer.from_pretrained(model_name)
+model = GPT2LMHeadModel.from_pretrained(model_name)
+model.eval()
+
+# Ensure tokenizer pad token is set
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+tokenizer.clean_up_tokenization_spaces = True
+
+# Set device for model and tensors
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+model.to(device)
+
+# ---- Memory Management ----
+session_memory = []
+
+def save_memory(memory, filename='chat_memory.pkl'):
+    with open(filename, 'wb') as f:
+        pickle.dump(memory, f)
+
+def load_memory(filename='chat_memory.pkl'):
+    try:
+        with open(filename, 'rb') as f:
+            return pickle.load(f)
+    except (FileNotFoundError, EOFError):
+        return []  # Return an empty list if the file is empty or doesn't exist
+
+
+session_memory = load_memory()
+
+# ---- Response Generation ----
+def generate_response(prompt, max_length=512):
+    inputs = tokenizer(prompt, return_tensors='pt', padding=True, truncation=True, max_length=max_length)
+    input_ids = inputs['input_ids'].to(device)
+    attention_mask = inputs['attention_mask'].to(device)
+    pad_token_id = tokenizer.pad_token_id
+
+    with torch.no_grad():
+        output = model.generate(
+            input_ids,
+            attention_mask=attention_mask,
+            max_length=max_length,
+            num_return_sequences=1,
+            no_repeat_ngram_size=2,
+            do_sample=True,
+            temperature=0.9,
+            top_k=50,
+            top_p=0.95,
+            early_stopping=False,
+            pad_token_id=pad_token_id
+        )
 
-# Function to simulate the button click for Pain and Pleasure buttons
-def simulate_button_click(button_type):
-    return gr.update(interactive=True, elem_id="chatbot_output")
-
-# Function to update AI behavior settings dynamically
-def update_ai_settings(temp, max_length, top_p, no_repeat_ngrams, adjust_response_style):
-    # Update AI settings based on user inputs
-    model.config.temperature = temp
-    model.config.max_length = max_length
-    model.config.top_p = top_p
-    model.config.no_repeat_ngram_size = no_repeat_ngrams
-    
-    # Optionally adjust the response style here (e.g., adjust based on a tone or creative behavior)
-    return f"AI Settings Updated: Temperature={temp}, Max Length={max_length}, Top P={top_p}, N-grams={no_repeat_ngrams}"
-
-# Function to simulate theme switching
-def update_theme(theme_color):
-    if theme_color == "Light Blue":
-        background_color = "#ADD8E6"
-        text_color = "#333333"
-    elif theme_color == "Dark Mode":
-        background_color = "#2e2e2e"
-        text_color = "#FFFFFF"
-    elif theme_color == "Purple":
-        background_color = "#9b59b6"
-        text_color = "#FFFFFF"
+    response = tokenizer.decode(output[0], skip_special_tokens=True)
+
+    # Split response into two parts, where the second indent is considered the "inner thoughts"
+    parts = response.split("\n", 1)
+    if len(parts) > 1:
+        before_indent = parts[0].strip()
+        after_indent = "vß Gertrude" + parts[1].strip()
+        final_response = before_indent + '\n' + after_indent
     else:
-        background_color = "#FFFFFF"
-        text_color = "#333333"
-        
-    return gr.update(background_color=background_color, text_color=text_color)
+        final_response = response.strip()
+
+    return final_response
+
+# ---- Interactive Chat Function ----
+def advanced_agi_chat(user_input):
+    session_memory.append({"input": user_input})
+    save_memory(session_memory)
+
+    # Generate the response based on the prompt
+    prompt = f"User: {user_input}\nResponse:"
+    response = generate_response(prompt)
+
+    return response
+
+# ---- Gradio Interface ----
+def chat_interface(user_input):
+    response = advanced_agi_chat(user_input)
+    return response
+
+# ---- RNN Model ----
+class RNNModel(nn.Module):
+    def __init__(self, input_size, hidden_size, output_size):
+        super(RNNModel, 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
+
+    def init_hidden(self, batch_size):
+        return torch.zeros(batch_size, self.hidden_size).to(device)
+
+# ---- CNN Model ----
+class CNNModel(nn.Module):
+    def __init__(self, input_channels, output_size):
+        super(CNNModel, self).__init__()
+        self.conv1 = nn.Conv2d(input_channels, 16, 3)
+        self.conv2 = nn.Conv2d(16, 32, 3)
+        self.fc = nn.Linear(32 * 6 * 6, output_size)  # Assume input size is 28x28
+
+    def forward(self, x):
+        x = F.relu(F.max_pool2d(self.conv1(x), 2))
+        x = F.relu(F.max_pool2d(self.conv2(x), 2))
+        x = x.view(x.size(0), -1)  # Flatten
+        x = self.fc(x)
+        return x
+
+# ---- Neural Network (Feedforward) ----
+class NNModel(nn.Module):
+    def __init__(self, input_size, hidden_size, 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):
+        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__()
+        self.phi = (1 + np.sqrt(5)) / 2  # Golden Ratio
+        self.fc1 = nn.Linear(input_size, int(input_size * self.phi))
+        self.fc2 = nn.Linear(int(input_size * self.phi), output_size)
+
+    def forward(self, x):
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+        return x
+
+# ---- Genetic Algorithm (GA) ----
+def ga_optimization(population, generations, mutation_rate):
+    def fitness_function(individual):
+        return sum(individual)  # Simple fitness: sum of individual genes
+
+    for gen in range(generations):
+        population.sort(key=fitness_function, reverse=True)  # Sort by fitness
+        next_generation = population[:len(population)//2]  # Keep top half
+
+        # Crossover: Create new individuals by combining genes
+        for i in range(len(population) // 2):
+            parent1 = next_generation[i]
+            parent2 = next_generation[len(population)//2 + i]
+            crossover_point = random.randint(1, len(parent1) - 1)
+            child = parent1[:crossover_point] + parent2[crossover_point:]
+            next_generation.append(child)
+
+        # Mutation: Randomly mutate genes
+        for individual in next_generation:
+            if random.random() < mutation_rate:
+                mutation_point = random.randint(0, len(individual) - 1)
+                individual[mutation_point] = random.randint(0, 1)
+
+        population = next_generation  # Update population
+
+    return population[0]  # Return the best individual
+
+# ---- Gradio App Setup ----
+auth = ("Tej", "186281mps", "ACC", "HIPE")
 
 with gr.Blocks() as app:
-    # Header section
     gr.Markdown("# **Autistic Assistant vß Edition 2024 Ultra: Gertrude's Autistic Experience**")
     
-    # User input and response UI layout
-    with gr.Row():
-        with gr.Column(scale=1):
-            user_input = gr.Textbox(
-                label="What will you say to Gertrude?", 
-                placeholder="Type something here...",
-                lines=3,  
-                elem_id="user_input_box" 
-            )
-            submit_button = gr.Button("Send", elem_id="send_button")
-
-        with gr.Column(scale=1):
-            chatbot = gr.Textbox(
-                label="Gertrude's Response", 
-                interactive=False,
-                elem_id="chatbot_output",  
-                lines=8  
-            )
-
-    # Buttons for "Pain" and "Pleasure" with cool animations
     with gr.Row():
         with gr.Column(scale=1):
-            pain_button = gr.Button("Pain", elem_id="pain_button", variant="stop", size="lg")
+            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):
-            pleasure_button = gr.Button("Pleasure", elem_id="pleasure_button", variant="primary", size="lg")
-
-    # Settings Panel: Controls for both AI and UI theme settings
-    with gr.Column(scale=1):
-        gr.Markdown("### Settings Panel")
-
-        # AI behavior settings
-        gr.Markdown("#### AI Response Settings")
-        temperature_slider = gr.Slider(minimum=0.1, maximum=1.5, value=0.9, step=0.1, label="Creativity")
-        max_length_slider = gr.Slider(minimum=50, maximum=1024, value=512, step=10, label="Max Response Length")
-        top_p_slider = gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Mutation")
-        ngram_slider = gr.Slider(minimum=1, maximum=4, value=2, step=1, label="Neural Netwok Layers")
-        
-        # UI Theme settings
-        gr.Markdown("#### UI Theme Settings")
-        theme_selector = gr.Dropdown(
-            choices=["Light Blue", "Dark Mode", "Purple", "Default"], 
-            label="Select Theme",
-            value="Light Blue"
-        )
-
-        response_style_toggle = gr.Checkbox(
-            label="Adjust AI response style (e.g., creativity level)",
-            value=True
-        )
+            chatbot = gr.Textbox(label="Gertrude's Response", interactive=False)  # This is now a Textbox for output
 
-        # Button to update settings
-        update_button = gr.Button("Update Settings")
-    
-    # Custom Styling for Buttons, Background, and Text
+    # Adding custom styling for the UI
     gr.HTML("""
         <style>
-            /* Main Container Styling */
             .gradio-container { 
-                background-color: #ADD8E6; 
-                padding: 20px;
-                border-radius: 20px; 
+                background-color: #B3D9FF; 
+                padding: 20px; 
+                border-radius: 15px; 
                 font-family: 'Comic Sans MS'; 
-                box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
             }
-
-            /* Header Styling */
-            .gradio-markdown {
-                font-size: 28px;
-                font-weight: bold;
-                color: #3366CC;
-                text-align: center;
-                padding-bottom: 20px;
-            }
-
-            /* User Input Box Styling */
-            #user_input_box {
-                background-color: #E8F7FF;
-                border: 2px solid #A3C9F1;
-                border-radius: 10px;
-                padding: 10px;
-            }
-
-            /* Send Button Styling */
-            #send_button {
-                background-color: #4CAF50;
-                color: white;
-                font-size: 18px;
-                border-radius: 10px;
-                width: 100%;
-                padding: 15px;
-            }
-
-            /* Chatbot Output Styling */
-            #chatbot_output {
-                background-color: #FFFFFF;
-                border: 2px solid #A3C9F1;
-                border-radius: 10px;
-                padding: 10px;
-                font-size: 16px;
-                color: #333333;
-                overflow-y: scroll;
-            }
-
-            /* Pain and Pleasure Buttons Styling */
-            #pain_button {
-                background-color: #FF5733;
-                color: white;
-                width: 100%;
-                height: 50px;
-                font-size: 24px;
-                border-radius: 12px;
-                transition: transform 0.3s ease;
-            }
-
-            #pain_button:active {
-                transform: scale(0.95);
-            }
-
-            #pleasure_button {
-                background-color: #4CAF50;
-                color: white;
-                width: 100%;
-                height: 50px;
-                font-size: 24px;
-                border-radius: 12px;
-                transition: transform 0.3s ease;
-            }
-
-            #pleasure_button:active {
-                transform: scale(0.95);
-            }
-
-            /* Custom Animation for Button Clicks */
-            @keyframes pulse {
-                0% {
-                    transform: scale(1);
-                }
-                50% {
-                    transform: scale(1.1);
-                }
-                100% {
-                    transform: scale(1);
-                }
-            }
-
-            .animate__pulse {
-                animation: pulse 0.5s ease;
+            .gradio-row { 
+                display: flex;
+                justify-content: space-between;
             }
         </style>
     """)
 
-    # Interaction Logic
-    def chat_interface(user_input):
-        response = advanced_agi_chat(user_input)
-        return response
-
-    # Now we pass the actual button components as inputs
+    # Setting the button click event
     submit_button.click(chat_interface, inputs=user_input, outputs=chatbot)
-    pain_button.click(simulate_button_click, inputs=pain_button, outputs=chatbot)
-    pleasure_button.click(simulate_button_click, inputs=pleasure_button, outputs=chatbot)
-
-    # Update settings and UI theme
-    update_button.click(update_ai_settings, 
-                        inputs=[temperature_slider, max_length_slider, top_p_slider, ngram_slider, response_style_toggle], 
-                        outputs=chatbot)
-    theme_selector.change(update_theme, inputs=theme_selector, outputs=gr.HTML(""))
 
 # Launch the Gradio app
 app.launch()
+
+