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
-import time
 
 @dataclass
 class ChatMessage:
@@ -48,61 +47,67 @@ 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 """
 
     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):
-        # Optimize: Add nodes and edges in batches
-        self.knowledge_graph.add_nodes_from(entities)
-        self.knowledge_graph.add_edges_from([(s, o, {"relation": p}) for s, p, o in relationships])
+        for entity in entities:
+            self.knowledge_graph.add_node(entity)
+        for relationship in relationships:
+            subject, predicate, object_ = relationship
+            self.knowledge_graph.add_edge(subject, object_, relation=predicate)
 
     def update_belief_system(self, statement, belief_score):
-        # Optimize: Potentially use a more efficient data structure if this grows large
         self.belief_system[statement] = belief_score
 
     def run_metacognitive_layer(self):
-        # Optimize: Calculate these only when necessary, not every turn
         coherence_score = self.calculate_coherence()
         relevance_score = self.calculate_relevance()
         bias_score = self.detect_bias()
@@ -116,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
 
@@ -123,24 +129,24 @@ class XylariaChat:
         for i in range(1, len(self.conversation_history)):
             current_message = self.conversation_history[i]['content']
             previous_message = self.conversation_history[i-1]['content']
-
-            # Optimize: Encode in batches if possible
-            current_embedding = self.embedding_model.encode(current_message, convert_to_tensor=True, show_progress_bar=False)
-            previous_embedding = self.embedding_model.encode(previous_message, convert_to_tensor=True, show_progress_bar=False)
-
-            similarity_score = util.pytorch_cos_sim(current_embedding, previous_embedding).item()
+            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
+            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
 
@@ -148,31 +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:
-            # Optimize: Batch encoding
-            recent_embeddings = self.embedding_model.encode(recent_messages, convert_to_tensor=True, show_progress_bar=False)
-            average_valence = recent_embeddings.mean(axis=0).mean().item() 
+            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:
@@ -181,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:
@@ -190,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:
@@ -203,7 +214,6 @@ class XylariaChat:
             return " ".join(adjustments)
             
     def introspect(self):
-        # Optimize: Potentially reduce the frequency of detailed introspection
         introspection_report = "Introspection Report:\n"
         introspection_report += f"  Current Emotional State:\n"
         for emotion, value in self.internal_state['emotions'].items():
@@ -224,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
 
@@ -233,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
@@ -244,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:
@@ -251,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":
@@ -270,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":
@@ -281,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":
@@ -298,7 +316,7 @@ class XylariaChat:
         if not self.persistent_memory:
             return "No information found in memory."
 
-        query_embedding = self.embedding_model.encode(query, convert_to_tensor=True, show_progress_bar=False)
+        query_embedding = self.embedding_model.encode(query, convert_to_tensor=True)
 
         if self.memory_embeddings is None:
             self.update_memory_embeddings()
@@ -306,7 +324,6 @@ class XylariaChat:
         if self.memory_embeddings.device != query_embedding.device:
             self.memory_embeddings = self.memory_embeddings.to(query_embedding.device)
 
-        # Optimize: Use faster similarity calculation if possible
         cosine_scores = util.pytorch_cos_sim(query_embedding, self.memory_embeddings)[0]
         top_results = torch.topk(cosine_scores, k=min(3, len(self.persistent_memory)))
 
@@ -315,8 +332,7 @@ class XylariaChat:
         return "\n".join(relevant_memories)
 
     def update_memory_embeddings(self):
-        # Optimize: Encode memory in batches
-        self.memory_embeddings = self.embedding_model.encode(self.persistent_memory, convert_to_tensor=True, show_progress_bar=False)
+        self.memory_embeddings = self.embedding_model.encode(self.persistent_memory, convert_to_tensor=True)
 
     def reset_conversation(self):
         self.conversation_history = []
@@ -377,7 +393,6 @@ class XylariaChat:
             else:
                 data = image.read()
 
-            # Optimize: Consider caching or reusing requests session
             response = requests.post(
                 self.image_api_url,
                 headers=self.image_api_headers,
@@ -396,7 +411,6 @@ class XylariaChat:
     def perform_math_ocr(self, image_path):
         try:
             img = Image.open(image_path)
-            # Optimize: Consider resizing or preprocessing the image for faster OCR
             text = pytesseract.image_to_string(img)
             return text.strip()
         except Exception as e:
@@ -405,39 +419,49 @@ class XylariaChat:
     def get_response(self, user_input, image=None):
         try:
             messages = []
-            messages.append(ChatMessage(role="system", content=self.system_prompt).to_dict())
 
-            # Optimize: Retrieve only if the user query suggests it's needed
+            messages.append(ChatMessage(
+                role="system",
+                content=self.system_prompt
+            ).to_dict())
+
             relevant_memory = self.retrieve_information(user_input)
             if relevant_memory and relevant_memory != "No information found in memory.":
                 memory_context = "Remembered Information:\n" + relevant_memory
-                messages.append(ChatMessage(role="system", content=memory_context).to_dict())
+                messages.append(ChatMessage(
+                    role="system",
+                    content=memory_context
+                ).to_dict())
 
-            messages.extend(self.conversation_history)
+            for msg in self.conversation_history:
+                messages.append(msg)
 
             if image:
                 image_caption = self.caption_image(image)
                 user_input = f"description of an image: {image_caption}\n\nUser's message about it: {user_input}"
 
-            messages.append(ChatMessage(role="user", content=user_input).to_dict())
-
-            # Optimize: Extract entities and relationships only if necessary
+            messages.append(ChatMessage(
+                role="user",
+                content=user_input
+            ).to_dict())
+            
             entities = []
             relationships = []
+
             for message in messages:
                 if message['role'] == 'user':
                     extracted_entities = self.extract_entities(message['content'])
                     extracted_relationships = self.extract_relationships(message['content'])
                     entities.extend(extracted_entities)
                     relationships.extend(extracted_relationships)
-
+            
             self.update_knowledge_graph(entities, relationships)
             self.run_metacognitive_layer()
 
-            # Optimize: Dynamically adjust max_new_tokens based on context length
             input_tokens = sum(len(msg['content'].split()) for msg in messages)
-            max_new_tokens = max(0, 4096 - input_tokens - 50)  # Reduce context window for QwQ-32B-Preview
-            max_new_tokens = min(max_new_tokens, 2048)
+            max_new_tokens = 16384 - input_tokens - 50
+
+            max_new_tokens = min(max_new_tokens, 10020)
 
             stream = self.client.chat_completion(
                 messages=messages,
@@ -455,13 +479,15 @@ class XylariaChat:
             return f"Error generating response: {str(e)}"
 
     def extract_entities(self, text):
-        # Basic entity extraction (consider using a more advanced NER model if performance allows)
+        # 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):
-        # Basic relationship extraction
+        # 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:
@@ -471,17 +497,27 @@ 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:
+            if msg["role"] == "system":
+                prompt += f"<|system|>\n{msg['content']}<|end|>\n"
+            elif msg["role"] == "user":
+                prompt += f"<|user|>\n{msg['content']}<|end|>\n"
+            elif msg["role"] == "assistant":
+                prompt += f"<|assistant|>\n{msg['content']}<|end|>\n"
+        prompt += "<|assistant|>\n"
+        return prompt
 
     def create_interface(self):
         def streaming_response(message, chat_history, image_filepath, math_ocr_image_path):
-            start_time = time.time()
-
+            
             ocr_text = ""
             if math_ocr_image_path:
                 ocr_text = self.perform_math_ocr(math_ocr_image_path)
                 if ocr_text.startswith("Error"):
                     updated_history = chat_history + [[message, ocr_text]]
-                    yield "", updated_history, None, None, gr.Textbox(f"Time taken: {time.time() - start_time:.2f} seconds", visible=True)
+                    yield "", updated_history, None, None
                     return
                 else:
                     message = f"Math OCR Result: {ocr_text}\n\nUser's message: {message}"
@@ -490,10 +526,11 @@ class XylariaChat:
                 response_stream = self.get_response(message, image_filepath)
             else:
                 response_stream = self.get_response(message)
+                
 
             if isinstance(response_stream, str):
                 updated_history = chat_history + [[message, response_stream]]
-                yield "", updated_history, None, None, gr.Textbox(f"Time taken: {time.time() - start_time:.2f} seconds", visible=True)
+                yield "", updated_history, None, None
                 return
 
             full_response = ""
@@ -506,24 +543,18 @@ class XylariaChat:
                         full_response += chunk_content
                         
                         updated_history[-1][1] = full_response
-                        yield "", updated_history, None, None, gr.Textbox(f"Time taken: {time.time() - start_time:.2f} seconds", visible=True)
-
-                        # Check for timeout (e.g., 3 seconds)
-                        if time.time() - start_time > 3:
-                            print("Response generation timed out.")
-                            updated_history[-1][1] += " (Response timed out)"
-                            yield "", updated_history, None, None, gr.Textbox(f"Time taken: {time.time() - start_time:.2f} seconds", visible=True)
-                            return
-
+                        yield "", updated_history, None, None
             except Exception as e:
                 print(f"Streaming error: {e}")
                 updated_history[-1][1] = f"Error during response: {e}"
-                yield "", updated_history, None, None, gr.Textbox(f"Time taken: {time.time() - start_time:.2f} seconds", visible=True)
+                yield "", updated_history, None, None
                 return
 
             full_response = self.adjust_response_based_on_state(full_response)
+
             self.update_goals(message)
 
+            # Update internal state based on user input (more nuanced)
             emotion_deltas = {}
             cognitive_load_deltas = {}
             engagement_delta = 0
@@ -558,12 +589,13 @@ class XylariaChat:
                 
             self.update_internal_state(emotion_deltas, cognitive_load_deltas, 0.1, engagement_delta)
             
+
             self.conversation_history.append(ChatMessage(role="user", content=message).to_dict())
             self.conversation_history.append(ChatMessage(role="assistant", content=full_response).to_dict())
 
-            # Optimize: Reduce history length
-            if len(self.conversation_history) > 6:
-                self.conversation_history = self.conversation_history[-6:]
+            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');