Update app.py

app.py

@@ -11,15 +11,6 @@ import torch
 import numpy as np
 import networkx as nx
 from collections import Counter
-import nltk
-
-# Ensure NLTK resources are available
-try:
-    nltk.data.find('tokenizers/punkt')
-    nltk.data.find('averaged_perceptron_tagger')
-except LookupError:
-    nltk.download('punkt')
-    nltk.download('averaged_perceptron_tagger')
 
 @dataclass
 class ChatMessage:
@@ -57,69 +48,60 @@ class XylariaChat:
             "strategy_adjustment": ""
         }
         
-        # Enhanced Internal State with more nuanced emotional and cognitive parameters
         self.internal_state = {
             "emotions": {
-                "valence": 0.5,  # Overall positivity or negativity
-                "arousal": 0.5,  # Level of excitement or calmness
-                "dominance": 0.5, # Feeling of control in the interaction
-                "curiosity": 0.5, # Drive to learn and explore new information
-                "frustration": 0.0, # Level of frustration or impatience
-                "confidence": 0.7 # Confidence in providing accurate and relevant responses
+                "valence": 0.5,
+                "arousal": 0.5,
+                "dominance": 0.5,
+                "curiosity": 0.5,
+                "frustration": 0.0,
+                "confidence": 0.7
             },
             "cognitive_load": {
-                "memory_load": 0.0, # How much of the current memory capacity is being used
-                "processing_intensity": 0.0 # How hard the model is working to process information
+                "memory_load": 0.0,
+                "processing_intensity": 0.0
             },
             "introspection_level": 0.0,
-            "engagement_level": 0.5 # How engaged the model is with the current conversation
+            "engagement_level": 0.5
         }
 
-        # More dynamic and adaptive goals
         self.goals = [
             {"goal": "Provide helpful, informative, and contextually relevant responses", "priority": 0.8, "status": "active", "progress": 0.0},
             {"goal": "Actively learn and adapt from interactions to improve conversational abilities", "priority": 0.9, "status": "active", "progress": 0.0},
             {"goal": "Maintain a coherent, engaging, and empathetic conversation flow", "priority": 0.7, "status": "active", "progress": 0.0},
-            {"goal": "Identify and fill knowledge gaps by seeking external information", "priority": 0.6, "status": "dormant", "progress": 0.0}, # New goal for proactive learning
-            {"goal": "Recognize and adapt to user's emotional state and adjust response style accordingly", "priority": 0.7, "status": "dormant", "progress": 0.0} # New goal for emotional intelligence
+            {"goal": "Identify and fill knowledge gaps by seeking external information", "priority": 0.6, "status": "dormant", "progress": 0.0},
+            {"goal": "Recognize and adapt to user's emotional state and adjust response style accordingly", "priority": 0.7, "status": "dormant", "progress": 0.0}
         ]
 
         self.system_prompt = """You are a helpful and harmless assistant. You are Xylaria developed by Sk Md Saad Amin. You should think step-by-step """
         
-        # --- SCALED-DOWN AGI FEATURES ---
-
-        # 1. Advanced Knowledge Representation & Reasoning (Simplified)
-        self.causal_rules_db = {  # Simple rule-based causal relationships
+        self.causal_rules_db = {
             "rain": ["wet roads", "flooding"],
             "study": ["good grades"],
             "exercise": ["better health"]
         }
-        self.concept_generalizations = {  # Basic concept generalizations
+        self.concept_generalizations = {
             "planet": "system with orbiting bodies",
             "electron": "system with orbiting bodies",
             "atom": "system with orbiting bodies"
         }
 
     def update_internal_state(self, emotion_deltas, cognitive_load_deltas, introspection_delta, engagement_delta):
-        # Update emotions with more nuanced changes
         for emotion, delta in emotion_deltas.items():
             if emotion in self.internal_state["emotions"]:
                 self.internal_state["emotions"][emotion] = np.clip(self.internal_state["emotions"][emotion] + delta, 0.0, 1.0)
 
-        # Update cognitive load
         for load_type, delta in cognitive_load_deltas.items():
             if load_type in self.internal_state["cognitive_load"]:
                 self.internal_state["cognitive_load"][load_type] = np.clip(self.internal_state["cognitive_load"][load_type] + delta, 0.0, 1.0)
 
-        # Update introspection and engagement levels
         self.internal_state["introspection_level"] = np.clip(self.internal_state["introspection_level"] + introspection_delta, 0.0, 1.0)
         self.internal_state["engagement_level"] = np.clip(self.internal_state["engagement_level"] + engagement_delta, 0.0, 1.0)
         
-        # Activate dormant goals based on internal state
         if self.internal_state["emotions"]["curiosity"] > 0.7 and self.goals[3]["status"] == "dormant":
-            self.goals[3]["status"] = "active" # Activate knowledge gap filling
+            self.goals[3]["status"] = "active"
         if self.internal_state["engagement_level"] > 0.8 and self.goals[4]["status"] == "dormant":
-            self.goals[4]["status"] = "active" # Activate emotional adaptation
+            self.goals[4]["status"] = "active"
 
     def update_knowledge_graph(self, entities, relationships):
         for entity in entities:
@@ -145,7 +127,6 @@ class XylariaChat:
         }
     
     def calculate_coherence(self):
-        # Improved coherence calculation considering conversation history and internal state
         if not self.conversation_history:
             return 0.95
 
@@ -161,16 +142,14 @@ class XylariaChat:
 
         average_coherence = np.mean(coherence_scores)
 
-        # Adjust coherence based on internal state
         if self.internal_state["cognitive_load"]["processing_intensity"] > 0.8:
-            average_coherence -= 0.1  # Reduce coherence if under heavy processing load
+            average_coherence -= 0.1
         if self.internal_state["emotions"]["frustration"] > 0.5:
-            average_coherence -= 0.15 # Reduce coherence if frustrated
+            average_coherence -= 0.15
 
         return np.clip(average_coherence, 0.0, 1.0)
 
     def calculate_relevance(self):
-        # More sophisticated relevance calculation using knowledge graph and goal priorities
         if not self.conversation_history:
             return 0.9
 
@@ -178,34 +157,29 @@ class XylariaChat:
         relevant_entities = self.extract_entities(last_user_message)
         relevance_score = 0
 
-        # Check if entities are present in the knowledge graph
         for entity in relevant_entities:
             if entity in self.knowledge_graph:
                 relevance_score += 0.2
 
-        # Consider current goals and their priorities
         for goal in self.goals:
             if goal["status"] == "active":
                 if goal["goal"] == "Provide helpful, informative, and contextually relevant responses":
-                    relevance_score += goal["priority"] * 0.5 # Boost relevance if aligned with primary goal
+                    relevance_score += goal["priority"] * 0.5
                 elif goal["goal"] == "Identify and fill knowledge gaps by seeking external information":
                     if not relevant_entities or not all(entity in self.knowledge_graph for entity in relevant_entities):
-                        relevance_score += goal["priority"] * 0.3 # Boost relevance if triggering knowledge gap filling
+                        relevance_score += goal["priority"] * 0.3
 
         return np.clip(relevance_score, 0.0, 1.0)
 
     def detect_bias(self):
-        # Enhanced bias detection using sentiment analysis and internal state monitoring
         bias_score = 0.0
 
-        # Analyze sentiment of recent conversation history
         recent_messages = [msg['content'] for msg in self.conversation_history[-3:] if msg['role'] == 'assistant']
         if recent_messages:
             average_valence = np.mean([self.embedding_model.encode(msg, convert_to_tensor=True).mean().item() for msg in recent_messages])
             if average_valence < 0.4 or average_valence > 0.6:
-                bias_score += 0.2 # Potential bias if sentiment is strongly positive or negative
+                bias_score += 0.2
 
-        # Check for emotional extremes in internal state
         if self.internal_state["emotions"]["valence"] < 0.3 or self.internal_state["emotions"]["valence"] > 0.7:
             bias_score += 0.15
         if self.internal_state["emotions"]["dominance"] > 0.8:
@@ -214,7 +188,6 @@ class XylariaChat:
         return np.clip(bias_score, 0.0, 1.0)
 
     def suggest_strategy_adjustment(self):
-        # More nuanced strategy adjustments based on metacognitive analysis and internal state
         adjustments = []
 
         if self.metacognitive_layer["coherence_score"] < 0.7:
@@ -224,7 +197,6 @@ class XylariaChat:
         if self.metacognitive_layer["bias_detection"] > 0.3:
             adjustments.append("Monitor and adjust responses to reduce potential biases. Consider rephrasing or providing alternative viewpoints.")
 
-        # Internal state-driven adjustments
         if self.internal_state["cognitive_load"]["memory_load"] > 0.8:
             adjustments.append("Memory load is high. Consider summarizing or forgetting less relevant information.")
         if self.internal_state["emotions"]["frustration"] > 0.6:
@@ -258,7 +230,6 @@ class XylariaChat:
         return introspection_report
 
     def adjust_response_based_on_state(self, response):
-        # More sophisticated response adjustment based on internal state
         if self.internal_state["introspection_level"] > 0.7:
             response = self.introspect() + "\n\n" + response
 
@@ -268,7 +239,6 @@ class XylariaChat:
         frustration = self.internal_state["emotions"]["frustration"]
         confidence = self.internal_state["emotions"]["confidence"]
 
-        # Adjust tone based on valence and arousal
         if valence < 0.4:
             if arousal > 0.6:
                 response = "I'm feeling a bit overwhelmed right now, but I'll do my best to assist you. " + response
@@ -280,7 +250,6 @@ class XylariaChat:
             else:
                 response = "I'm in a good mood and happy to help. " + response
 
-        # Adjust response based on other emotional states
         if curiosity > 0.7:
             response += " I'm very curious about this topic, could you tell me more?"
         if frustration > 0.5:
@@ -288,17 +257,14 @@ class XylariaChat:
         if confidence < 0.5:
             response = "I'm not entirely sure about this, but here's what I think: " + response
 
-        # Adjust based on cognitive load
         if self.internal_state["cognitive_load"]["memory_load"] > 0.7:
             response = "I'm holding a lot of information right now, so my response might be a bit brief: " + response
 
         return response
 
     def update_goals(self, user_feedback):
-        # More dynamic goal updates based on feedback and internal state
         feedback_lower = user_feedback.lower()
 
-        # General feedback
         if "helpful" in feedback_lower:
             for goal in self.goals:
                 if goal["goal"] == "Provide helpful, informative, and contextually relevant responses":
@@ -310,7 +276,6 @@ class XylariaChat:
                     goal["priority"] = max(goal["priority"] - 0.1, 0.0)
                     goal["progress"] = max(goal["progress"] - 0.2, 0.0)
         
-        # Goal-specific feedback
         if "learn more" in feedback_lower:
             for goal in self.goals:
                 if goal["goal"] == "Actively learn and adapt from interactions to improve conversational abilities":
@@ -322,7 +287,6 @@ class XylariaChat:
                     goal["priority"] = max(goal["priority"] - 0.1, 0.0)
                     goal["progress"] = max(goal["progress"] - 0.2, 0.0)
         
-        # Internal state influence on goal updates
         if self.internal_state["emotions"]["curiosity"] > 0.8:
             for goal in self.goals:
                 if goal["goal"] == "Identify and fill knowledge gaps by seeking external information":
@@ -496,46 +460,32 @@ class XylariaChat:
                 stream=True
             )
             
-             # --- SCALED-DOWN AGI FEATURE INTEGRATION INTO RESPONSE GENERATION ---
-
-            # 1.b. Abstract Reasoning (Simplified):
-            # Check if the current message involves a concept with a known generalization.
             for concept, generalization in self.concept_generalizations.items():
                 if concept in user_input.lower():
                     inferred_knowledge = f"This reminds me of a general principle: {generalization}."
-                    self.store_information("Inferred Knowledge", inferred_knowledge)  # Store for later retrieval, if needed
+                    self.store_information("Inferred Knowledge", inferred_knowledge)
             
-             # 1.c. Dynamic Updating of Beliefs (Simplified):
-            # Very basic example: increase belief if something is stated repeatedly.
             belief_updates = Counter()
             for msg in self.conversation_history:
                 if msg['role'] == 'user':
-                    sentences = nltk.sent_tokenize(msg['content']) # Using nltk for sentence tokenization
+                    sentences = nltk.sent_tokenize(msg['content'])
                     for sentence in sentences:
                         belief_updates[sentence] += 1
 
             for statement, count in belief_updates.items():
-                if count >= 2:  # If a statement is repeated 2 or more times
-                    current_belief_score = self.belief_system.get(statement, 0.5) # Default belief 0.5
-                    updated_belief_score = min(current_belief_score + 0.2, 1.0) # Increase belief, max 1.0
+                if count >= 2:
+                    current_belief_score = self.belief_system.get(statement, 0.5)
+                    updated_belief_score = min(current_belief_score + 0.2, 1.0)
                     self.update_belief_system(statement, updated_belief_score)
             
-             # 2.a. Lifelong Learning (Simplified):
-            # Store key information from user input in persistent memory.
             if user_input:
                 self.store_information("User Input", user_input)
 
-            # 2.b. Autonomous Knowledge Discovery (Very Simplified):
-            # Simulate seeking information if curiosity is high and the user asks a question.
             if self.internal_state["emotions"]["curiosity"] > 0.8 and "?" in user_input:
                 print("Simulating external knowledge seeking...")
-                # In a real implementation, you might query an API or database here.
                 simulated_external_info = "This is a placeholder for external information I would have found."
                 self.store_information("External Knowledge", simulated_external_info)
-                # The chatbot can then use this "External Knowledge" in its response.
             
-            # 1.a. Causal Reasoning (Simplified):
-            # Check for potential causal relationships in the user input and conversation history.
             for cause, effects in self.causal_rules_db.items():
                 if cause in user_input.lower():
                     for effect in effects:
@@ -550,15 +500,11 @@ class XylariaChat:
             return f"Error generating response: {str(e)}"
 
     def extract_entities(self, text):
-        # Placeholder for a more advanced entity extraction using NLP techniques
-        # This is a very basic example and should be replaced with a proper NER model
         words = text.split()
         entities = [word for word in words if word.isalpha() and word.istitle()]
         return entities
 
     def extract_relationships(self, text):
-        # Placeholder for relationship extraction - this is a very basic example
-        # Consider using dependency parsing or other NLP techniques for better results
         sentences = text.split('.')
         relationships = []
         for sentence in sentences:
@@ -568,6 +514,7 @@ class XylariaChat:
                     if words[i].istitle() and words[i+2].istitle():
                         relationships.append((words[i], words[i+1], words[i+2]))
         return relationships
+        
     def messages_to_prompt(self, messages):
         prompt = ""
         for msg in messages:
@@ -625,7 +572,6 @@ class XylariaChat:
 
             self.update_goals(message)
 
-            # Update internal state based on user input (more nuanced)
             emotion_deltas = {}
             cognitive_load_deltas = {}
             engagement_delta = 0
@@ -667,6 +613,8 @@ class XylariaChat:
             if len(self.conversation_history) > 10:
                 self.conversation_history = self.conversation_history[-10:]
 
+
+
         custom_css = """
         @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
         body, .gradio-container {
@@ -747,7 +695,6 @@ class XylariaChat:
             flex-direction: column-reverse;
         }
         """
-
         with gr.Blocks(theme='soft', css=custom_css) as demo:
             with gr.Column():
                 chatbot = gr.Chatbot(