Update app.py

app.py

@@ -47,30 +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,
+                "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
             },
-            "memory_load": 0.0,
-            "introspection_level": 0.0
+            "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
+            },
+            "introspection_level": 0.0,
+            "engagement_level": 0.5 # How engaged the model is with the current conversation
         }
 
+        # More dynamic and adaptive goals
         self.goals = [
-            {"goal": "Provide helpful and informative responses", "priority": 0.8, "status": "active"},
-            {"goal": "Learn from interactions and improve conversational abilities", "priority": 0.9, "status": "active"},
-            {"goal": "Maintain a coherent and engaging conversation", "priority": 0.7, "status": "active"}
+            {"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
         ]
 
         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 """
 
-    def update_internal_state(self, emotion_deltas, memory_load_delta, introspection_delta):
-        self.internal_state["emotions"]["valence"] = np.clip(self.internal_state["emotions"]["valence"] + emotion_deltas.get("valence", 0), 0.0, 1.0)
-        self.internal_state["emotions"]["arousal"] = np.clip(self.internal_state["emotions"]["arousal"] + emotion_deltas.get("arousal", 0), 0.0, 1.0)
-        self.internal_state["emotions"]["dominance"] = np.clip(self.internal_state["emotions"]["dominance"] + emotion_deltas.get("dominance", 0), 0.0, 1.0)
-        self.internal_state["memory_load"] = np.clip(self.internal_state["memory_load"] + memory_load_delta, 0.0, 1.0)
+    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
+        if self.internal_state["engagement_level"] > 0.8 and self.goals[4]["status"] == "dormant":
+            self.goals[4]["status"] = "active" # Activate emotional adaptation
 
     def update_knowledge_graph(self, entities, relationships):
         for entity in entities:
@@ -96,25 +121,111 @@ class XylariaChat:
         }
     
     def calculate_coherence(self):
-        return 0.9
+        # Improved coherence calculation considering conversation history and internal state
+        if not self.conversation_history:
+            return 0.95
+
+        coherence_scores = []
+        for i in range(1, len(self.conversation_history)):
+            current_message = self.conversation_history[i]['content']
+            previous_message = self.conversation_history[i-1]['content']
+            similarity_score = util.pytorch_cos_sim(
+                self.embedding_model.encode(current_message, convert_to_tensor=True),
+                self.embedding_model.encode(previous_message, convert_to_tensor=True)
+            ).item()
+            coherence_scores.append(similarity_score)
+
+        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
+        if self.internal_state["emotions"]["frustration"] > 0.5:
+            average_coherence -= 0.15 # Reduce coherence if frustrated
+
+        return np.clip(average_coherence, 0.0, 1.0)
 
     def calculate_relevance(self):
-        return 0.85
-    
+        # More sophisticated relevance calculation using knowledge graph and goal priorities
+        if not self.conversation_history:
+            return 0.9
+
+        last_user_message = self.conversation_history[-1]['content']
+        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
+                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
+
+        return np.clip(relevance_score, 0.0, 1.0)
+
     def detect_bias(self):
-        return 0.1
-    
-    def suggest_strategy_adjustment(self):
-        return "Focus on providing more concise answers."
+        # 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
+
+        # 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:
+            bias_score += 0.1
 
+        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:
+            adjustments.append("Focus on improving coherence by explicitly connecting ideas between turns.")
+        if self.metacognitive_layer["relevance_score"] < 0.7:
+            adjustments.append("Increase relevance by directly addressing user queries and utilizing stored knowledge.")
+        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:
+            adjustments.append("Frustration level is elevated. Prioritize concise and direct responses. Consider asking clarifying questions.")
+        if self.internal_state["emotions"]["curiosity"] > 0.8 and self.internal_state["cognitive_load"]["processing_intensity"] < 0.5:
+            adjustments.append("High curiosity and low processing load. Explore the topic further by asking relevant questions or seeking external information.")
+
+        if not adjustments:
+            return "Current strategy is effective. Continue with the current approach."
+        else:
+            return " ".join(adjustments)
+            
     def introspect(self):
         introspection_report = "Introspection Report:\n"
-        introspection_report += f"  Current Emotional State (VAD): {self.internal_state['emotions']}\n"
-        introspection_report += f"  Memory Load: {self.internal_state['memory_load']:.2f}\n"
+        introspection_report += f"  Current Emotional State:\n"
+        for emotion, value in self.internal_state['emotions'].items():
+            introspection_report += f"    - {emotion.capitalize()}: {value:.2f}\n"
+        introspection_report += f"  Cognitive Load:\n"
+        for load_type, value in self.internal_state['cognitive_load'].items():
+            introspection_report += f"    - {load_type.capitalize()}: {value:.2f}\n"
         introspection_report += f"  Introspection Level: {self.internal_state['introspection_level']:.2f}\n"
+        introspection_report += f"  Engagement Level: {self.internal_state['engagement_level']:.2f}\n"
         introspection_report += "  Current Goals:\n"
         for goal in self.goals:
-            introspection_report += f"    - {goal['goal']} (Priority: {goal['priority']:.2f}, Status: {goal['status']})\n"
+            introspection_report += f"    - {goal['goal']} (Priority: {goal['priority']:.2f}, Status: {goal['status']}, Progress: {goal['progress']:.2f})\n"
         introspection_report += "Metacognitive Layer Report\n"
         introspection_report += f"Coherence Score: {self.metacognitive_layer['coherence_score']}\n"
         introspection_report += f"Relevance Score: {self.metacognitive_layer['relevance_score']}\n"
@@ -123,12 +234,17 @@ 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
 
         valence = self.internal_state["emotions"]["valence"]
         arousal = self.internal_state["emotions"]["arousal"]
+        curiosity = self.internal_state["emotions"]["curiosity"]
+        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
@@ -140,23 +256,60 @@ 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:
+            response = "I'm finding this a bit challenging, but I'll give it another try. " + response
+        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):
-        if "helpful" in user_feedback.lower():
+        # 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 and informative responses":
+                if goal["goal"] == "Provide helpful, informative, and contextually relevant responses":
                     goal["priority"] = min(goal["priority"] + 0.1, 1.0)
-        elif "confusing" in user_feedback.lower():
+                    goal["progress"] = min(goal["progress"] + 0.2, 1.0)
+        elif "confusing" in feedback_lower:
+            for goal in self.goals:
+                if goal["goal"] == "Provide helpful, informative, and contextually relevant responses":
+                    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":
+                    goal["priority"] = min(goal["priority"] + 0.2, 1.0)
+                    goal["progress"] = min(goal["progress"] + 0.1, 1.0)
+        elif "too repetitive" in feedback_lower:
             for goal in self.goals:
-                if goal["goal"] == "Provide helpful and informative responses":
+                if goal["goal"] == "Maintain a coherent, engaging, and empathetic conversation flow":
                     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":
+                    goal["priority"] = min(goal["priority"] + 0.1, 1.0)
+                    goal["progress"] = min(goal["progress"] + 0.1, 1.0)
 
     def store_information(self, key, value):
         new_memory = f"{key}: {value}"
         self.persistent_memory.append(new_memory)
         self.update_memory_embeddings()
-        self.update_internal_state({}, 0.1, 0)
+        self.update_internal_state({}, {"memory_load": 0.1, "processing_intensity": 0.05}, 0, 0.05)
         return f"Stored: {key} = {value}"
 
     def retrieve_information(self, query):
@@ -175,7 +328,7 @@ class XylariaChat:
         top_results = torch.topk(cosine_scores, k=min(3, len(self.persistent_memory)))
 
         relevant_memories = [self.persistent_memory[i] for i in top_results.indices]
-        self.update_internal_state({}, 0, 0.1)
+        self.update_internal_state({}, {"memory_load": 0.05, "processing_intensity": 0.1}, 0.1, 0.05)
         return "\n".join(relevant_memories)
 
     def update_memory_embeddings(self):
@@ -190,14 +343,23 @@ class XylariaChat:
                 "valence": 0.5,
                 "arousal": 0.5,
                 "dominance": 0.5,
+                "curiosity": 0.5,
+                "frustration": 0.0,
+                "confidence": 0.7
             },
-            "memory_load": 0.0,
-            "introspection_level": 0.0
+            "cognitive_load": {
+                "memory_load": 0.0,
+                "processing_intensity": 0.0
+            },
+            "introspection_level": 0.0,
+            "engagement_level": 0.5
         }
         self.goals = [
-            {"goal": "Provide helpful and informative responses", "priority": 0.8, "status": "active"},
-            {"goal": "Learn from interactions and improve conversational abilities", "priority": 0.9, "status": "active"},
-            {"goal": "Maintain a coherent and engaging conversation", "priority": 0.7, "status": "active"}
+            {"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}
         ]
 
         self.knowledge_graph = nx.DiGraph()
@@ -317,11 +479,24 @@ class XylariaChat:
             return f"Error generating response: {str(e)}"
 
     def extract_entities(self, text):
-        return []
+        # 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):
-        return []
-
+        # 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:
+            words = sentence.split()
+            if len(words) >= 3:
+                for i in range(len(words) - 2):
+                    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:
@@ -379,18 +554,40 @@ class XylariaChat:
 
             self.update_goals(message)
 
+            # Update internal state based on user input (more nuanced)
+            emotion_deltas = {}
+            cognitive_load_deltas = {}
+            engagement_delta = 0
+
             if any(word in message.lower() for word in ["sad", "unhappy", "depressed", "down"]):
-                self.update_internal_state({"valence": -0.2, "arousal": 0.1}, 0, 0)
+                emotion_deltas.update({"valence": -0.2, "arousal": 0.1, "confidence": -0.1})
+                engagement_delta = -0.1
             elif any(word in message.lower() for word in ["happy", "good", "great", "excited", "amazing"]):
-                self.update_internal_state({"valence": 0.2, "arousal": 0.2}, 0, 0)
+                emotion_deltas.update({"valence": 0.2, "arousal": 0.2, "confidence": 0.1})
+                engagement_delta = 0.2
             elif any(word in message.lower() for word in ["angry", "mad", "furious", "frustrated"]):
-                self.update_internal_state({"valence": -0.3, "arousal": 0.3, "dominance": -0.2}, 0, 0)
+                emotion_deltas.update({"valence": -0.3, "arousal": 0.3, "dominance": -0.2, "frustration": 0.2})
+                engagement_delta = -0.2
             elif any(word in message.lower() for word in ["scared", "afraid", "fearful", "anxious"]):
-                self.update_internal_state({"valence": -0.2, "arousal": 0.4, "dominance": -0.3}, 0, 0)
+                emotion_deltas.update({"valence": -0.2, "arousal": 0.4, "dominance": -0.3, "confidence": -0.2})
+                engagement_delta = -0.1
             elif any(word in message.lower() for word in ["surprise", "amazed", "astonished"]):
-                self.update_internal_state({"valence": 0.1, "arousal": 0.5, "dominance": 0.1}, 0, 0)
+                emotion_deltas.update({"valence": 0.1, "arousal": 0.5, "dominance": 0.1, "curiosity": 0.3})
+                engagement_delta = 0.3
+            elif any(word in message.lower() for word in ["confused", "uncertain", "unsure"]):
+                cognitive_load_deltas.update({"processing_intensity": 0.2})
+                emotion_deltas.update({"curiosity": 0.2, "confidence": -0.1})
+                engagement_delta = 0.1
             else:
-                self.update_internal_state({"valence": 0.05, "arousal": 0.05}, 0, 0.1)
+                emotion_deltas.update({"valence": 0.05, "arousal": 0.05})
+                engagement_delta = 0.05
+            
+            if "learn" in message.lower() or "explain" in message.lower() or "know more" in message.lower():
+                emotion_deltas.update({"curiosity": 0.3})
+                cognitive_load_deltas.update({"processing_intensity": 0.1})
+                engagement_delta = 0.2
+                
+            self.update_internal_state(emotion_deltas, cognitive_load_deltas, 0.1, engagement_delta)
             
 
             self.conversation_history.append(ChatMessage(role="user", content=message).to_dict())
@@ -399,6 +596,7 @@ 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 {