Update app.py

app.py

@@ -1,190 +1,40 @@
-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
-
-# ---- 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
-        )
-
-    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:
-        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 ----
 import gradio as gr
 
 # ---- Gradio App Setup ----
 auth = ("Tej", "186281mps", "ACC", "HIPE")
 
+# Function to simulate the button click for Pain and Pleasure buttons
 def simulate_button_click(button_type):
-    # Just simulate the click animation and do nothing else
     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"
+    else:
+        background_color = "#FFFFFF"
+        text_color = "#333333"
+        
+    return gr.update(background_color=background_color, text_color=text_color)
+
 with gr.Blocks() as app:
     # Header section
     gr.Markdown("# **Autistic Assistant vß Edition 2024 Ultra: Gertrude's Autistic Experience**")
@@ -195,8 +45,8 @@ with gr.Blocks() as app:
             user_input = gr.Textbox(
                 label="What will you say to Gertrude?", 
                 placeholder="Type something here...",
-                lines=3,  # Multiline input box for more comfortable typing
-                elem_id="user_input_box"  # Custom ID for styling
+                lines=3,  
+                elem_id="user_input_box" 
             )
             submit_button = gr.Button("Send", elem_id="send_button")
 
@@ -204,8 +54,8 @@ with gr.Blocks() as app:
             chatbot = gr.Textbox(
                 label="Gertrude's Response", 
                 interactive=False,
-                elem_id="chatbot_output",  # Custom ID for styling
-                lines=8  # Display more text for longer responses
+                elem_id="chatbot_output",  
+                lines=8  
             )
 
     # Buttons for "Pain" and "Pleasure" with cool animations
@@ -215,12 +65,39 @@ with gr.Blocks() as app:
         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
+        )
+
+        # Button to update settings
+        update_button = gr.Button("Update Settings")
+    
     # Custom Styling for Buttons, Background, and Text
     gr.HTML("""
         <style>
             /* Main Container Styling */
             .gradio-container { 
-                background-color: #F0F8FF; 
+                background-color: #ADD8E6; 
                 padding: 20px;
                 border-radius: 20px; 
                 font-family: 'Comic Sans MS'; 
@@ -323,5 +200,11 @@ with gr.Blocks() as app:
     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()