Update app.py

app.py

@@ -10,7 +10,6 @@ from sentence_transformers import SentenceTransformer, util
 import torch
 import numpy as np
 import networkx as nx
-from collections import Counter
 
 @dataclass
 class ChatMessage:
@@ -48,60 +47,55 @@ class XylariaChat:
             "strategy_adjustment": ""
         }
         
+        # Enhanced Internal State with more nuanced emotional and cognitive parameters
         self.internal_state = {
             "emotions": {
-                "valence": 0.5,
-                "arousal": 0.5,
-                "dominance": 0.5,
-                "curiosity": 0.5,
-                "frustration": 0.0,
-                "confidence": 0.7
+                "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
             },
             "cognitive_load": {
-                "memory_load": 0.0,
-                "processing_intensity": 0.0
+                "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
             },
             "introspection_level": 0.0,
-            "engagement_level": 0.5
+            "engagement_level": 0.5 # How engaged the model is with the current conversation
         }
 
+        # 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},
-            {"goal": "Recognize and adapt to user's emotional state and adjust response style accordingly", "priority": 0.7, "status": "dormant", "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
         ]
 
         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 """
-        
-        self.causal_rules_db = {
-            "rain": ["wet roads", "flooding"],
-            "study": ["good grades"],
-            "exercise": ["better health"]
-        }
-        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"
+            self.goals[3]["status"] = "active" # Activate knowledge gap filling
         if self.internal_state["engagement_level"] > 0.8 and self.goals[4]["status"] == "dormant":
-            self.goals[4]["status"] = "active"
+            self.goals[4]["status"] = "active" # Activate emotional adaptation
 
     def update_knowledge_graph(self, entities, relationships):
         for entity in entities:
@@ -127,6 +121,7 @@ class XylariaChat:
         }
     
     def calculate_coherence(self):
+        # Improved coherence calculation considering conversation history and internal state
         if not self.conversation_history:
             return 0.95
 
@@ -142,14 +137,16 @@ 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
+            average_coherence -= 0.1  # Reduce coherence if under heavy processing load
         if self.internal_state["emotions"]["frustration"] > 0.5:
-            average_coherence -= 0.15
+            average_coherence -= 0.15 # Reduce coherence if frustrated
 
         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
 
@@ -157,29 +154,34 @@ 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
+                    relevance_score += goal["priority"] * 0.5 # Boost relevance if aligned with primary goal
                 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
+                        relevance_score += goal["priority"] * 0.3 # Boost relevance if triggering knowledge gap filling
 
         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
+                bias_score += 0.2 # Potential bias if sentiment is strongly positive or negative
 
+        # 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:
@@ -188,6 +190,7 @@ 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:
@@ -197,6 +200,7 @@ 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:
@@ -230,6 +234,7 @@ 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
 
@@ -239,6 +244,7 @@ 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
@@ -250,6 +256,7 @@ 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:
@@ -257,14 +264,17 @@ 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":
@@ -276,6 +286,7 @@ 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":
@@ -287,6 +298,7 @@ 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":
@@ -460,39 +472,6 @@ class XylariaChat:
                 stream=True
             )
             
-            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)
-            
-            belief_updates = Counter()
-            for msg in self.conversation_history:
-                if msg['role'] == 'user':
-                    sentences = nltk.sent_tokenize(msg['content'])
-                    for sentence in sentences:
-                        belief_updates[sentence] += 1
-
-            for statement, count in belief_updates.items():
-                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)
-            
-            if user_input:
-                self.store_information("User Input", user_input)
-
-            if self.internal_state["emotions"]["curiosity"] > 0.8 and "?" in user_input:
-                print("Simulating external knowledge seeking...")
-                simulated_external_info = "This is a placeholder for external information I would have found."
-                self.store_information("External Knowledge", simulated_external_info)
-            
-            for cause, effects in self.causal_rules_db.items():
-                if cause in user_input.lower():
-                    for effect in effects:
-                        if effect in " ".join([msg['content'].lower() for msg in self.conversation_history]).lower():
-                            causal_inference = f"It seems {cause} might be related to {effect}."
-                            self.store_information("Causal Inference", causal_inference)
-            
             return stream
         
         except Exception as e:
@@ -500,11 +479,15 @@ 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:
@@ -514,7 +497,6 @@ 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:
@@ -572,6 +554,7 @@ class XylariaChat:
 
             self.update_goals(message)
 
+            # Update internal state based on user input (more nuanced)
             emotion_deltas = {}
             cognitive_load_deltas = {}
             engagement_delta = 0
@@ -614,7 +597,6 @@ class XylariaChat:
                 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 {
@@ -695,6 +677,7 @@ class XylariaChat:
             flex-direction: column-reverse;
         }
         """
+
         with gr.Blocks(theme='soft', css=custom_css) as demo:
             with gr.Column():
                 chatbot = gr.Chatbot(