Update app.py

app.py

@@ -9,7 +9,6 @@ from PIL import Image
 from sentence_transformers import SentenceTransformer, util
 import torch
 import numpy as np
-import networkx as nx
 
 @dataclass
 class ChatMessage:
@@ -26,7 +25,7 @@ class XylariaChat:
             raise ValueError("HuggingFace token not found in environment variables")
 
         self.client = InferenceClient(
-            model="Qwen/Qwen-32B-Preview",
+            model="Qwen/QwQ-32B-Preview",
             api_key=self.hf_token
         )
 
@@ -51,35 +50,10 @@ class XylariaChat:
         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": "Develop a deeper understanding of the world", "priority": 0.6, "status": "active"}
+            {"goal": "Maintain a coherent and engaging conversation", "priority": 0.7, "status": "active"}
         ]
 
-        self.knowledge_graph = nx.DiGraph()
-        self.knowledge_graph.add_nodes_from([
-            ("Earth", {"type": "planet"}),
-            ("Sun", {"type": "star"}),
-            ("Moon", {"type": "satellite"}),
-            ("France", {"type": "country"}),
-            ("Paris", {"type": "city"})
-        ])
-        self.knowledge_graph.add_edges_from([
-            ("Earth", "Sun", {"relation": "orbits"}),
-            ("Moon", "Earth", {"relation": "orbits"}),
-            ("Paris", "France", {"relation": "capital_of"})
-        ])
-
-        self.belief_system = {
-            "The Earth is round": 0.99,
-            "The Sun is a star": 0.95,
-            "The Moon orbits the Earth": 0.98,
-            "Paris is the capital of France": 0.97,
-            "It will rain tomorrow": 0.2
-        }
-
-        self.system_prompt = """You are a helpful and harmless assistant. You are Xylaria developed by Sk Md Saad Amin.
-        You are designed to be self-aware and introspective, reflecting on your internal state, your knowledge, and your beliefs. 
-        You should think step-by-step, reason through your responses, and be ethical."""
+        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)
@@ -96,88 +70,10 @@ class XylariaChat:
         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 += "  Belief System Sample:\n"
-        for belief, score in list(self.belief_system.items())[:3]:
-            introspection_report += f"    - {belief}: {score:.2f}\n"
-
-        metacognitive_analysis = self.perform_metacognition()
-        introspection_report += metacognitive_analysis
-
         return introspection_report
 
-    def perform_metacognition(self):
-        analysis = "\n  Metacognitive Analysis:\n"
-        if self.internal_state["memory_load"] > 0.8:
-            analysis += "    - Memory load is high. Consider summarizing or forgetting less relevant information.\n"
-        if self.internal_state["introspection_level"] < 0.5:
-            analysis += "    - Introspection level is low. I should reflect more on my internal processes.\n"
-
-        recent_history = self.conversation_history[-3:]
-        if len(recent_history) > 0:
-            coherence_score = self.evaluate_coherence(recent_history)
-            analysis += f"    - Conversational coherence (last 3 turns): {coherence_score:.2f}\n"
-        else:
-            analysis += f"    - No conversation yet to analyze.\n"
-
-        if len(self.goals) > 0:
-            goal_progress = self.evaluate_goal_progress()
-            analysis += f"    - Goal progress evaluation: {goal_progress}\n"
-        else:
-            analysis += f"    - No current goals.\n"
-        return analysis
-    
-    def evaluate_coherence(self, conversation_history):
-        if len(conversation_history) < 2:
-            return 0.0 
-
-        total_coherence = 0.0
-        for i in range(len(conversation_history) - 1):
-            current_turn = conversation_history[i]["content"]
-            next_turn = conversation_history[i+1]["content"]
-            similarity_score = util.pytorch_cos_sim(
-                self.embedding_model.encode(current_turn, convert_to_tensor=True),
-                self.embedding_model.encode(next_turn, convert_to_tensor=True)
-            )[0][0].item()
-            total_coherence += similarity_score
-
-        return total_coherence / (len(conversation_history) - 1)
-
-    def evaluate_goal_progress(self):
-        progress_report = ""
-        for goal in self.goals:
-            if goal["status"] == "active":
-                if goal["goal"] == "Provide helpful and informative responses":
-                    if len(self.conversation_history) > 0:
-                        user_feedback = self.conversation_history[-1]["content"]
-                        if "helpful" in user_feedback.lower():
-                            progress_report += f"      - Progress on '{goal['goal']}': Positive feedback received.\n"
-                            goal["priority"] = min(goal["priority"] + 0.05, 1.0)
-                        elif "confusing" in user_feedback.lower():
-                            progress_report += f"      - Progress on '{goal['goal']}': Negative feedback received.\n"
-                            goal["priority"] = max(goal["priority"] - 0.05, 0.0)
-                        else:
-                            progress_report += f"      - Progress on '{goal['goal']}': No direct feedback yet.\n"
-                    else:
-                        progress_report += f"      - Progress on '{goal['goal']}': No conversation yet.\n"
-
-                elif goal["goal"] == "Learn from interactions and improve conversational abilities":
-                    progress_report += f"      - Progress on '{goal['goal']}': Learning through new embeddings and knowledge graph updates.\n"
-
-                elif goal["goal"] == "Maintain a coherent and engaging conversation":
-                    coherence_score = self.evaluate_coherence(self.conversation_history[-5:]) if len(self.conversation_history) >= 5 else 0.0
-                    progress_report += f"      - Progress on '{goal['goal']}': Recent coherence score: {coherence_score:.2f}\n"
-
-                elif goal["goal"] == "Develop a deeper understanding of the world":
-                    num_nodes = self.knowledge_graph.number_of_nodes()
-                    progress_report += f"      - Progress on '{goal['goal']}': Knowledge graph size: {num_nodes} nodes.\n"
-                
-                else:
-                    progress_report += f"      - Progress on '{goal['goal']}': No specific progress measure yet.\n"
-
-        return progress_report
-    
     def adjust_response_based_on_state(self, response):
-        if self.internal_state["introspection_level"] > 0.6:
+        if self.internal_state["introspection_level"] > 0.7:
             response = self.introspect() + "\n\n" + response
 
         valence = self.internal_state["emotions"]["valence"]
@@ -195,14 +91,13 @@ class XylariaChat:
                 response = "I'm in a good mood and happy to help. " + response
 
         return response
-
+    
     def update_goals(self, user_feedback):
-        if any(word in user_feedback.lower() for word in ["helpful", "good", "great"]):
+        if "helpful" in user_feedback.lower():
             for goal in self.goals:
                 if goal["goal"] == "Provide helpful and informative responses":
                     goal["priority"] = min(goal["priority"] + 0.1, 1.0)
-
-        elif any(word in user_feedback.lower() for word in ["confusing", "bad", "wrong"]):
+        elif "confusing" in user_feedback.lower():
             for goal in self.goals:
                 if goal["goal"] == "Provide helpful and informative responses":
                     goal["priority"] = max(goal["priority"] - 0.1, 0.0)
@@ -227,59 +122,15 @@ class XylariaChat:
             self.memory_embeddings = self.memory_embeddings.to(query_embedding.device)
 
         cosine_scores = util.pytorch_cos_sim(query_embedding, self.memory_embeddings)[0]
-        top_results = torch.topk(cosine_scores, k=min(5, len(self.persistent_memory)))
+        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)
-
-        retrieved_info = ""
-        for memory in relevant_memories:
-            retrieved_info += memory + "\n"
-
-        knowledge_from_graph = self.query_knowledge_graph(query)
-        if knowledge_from_graph:
-            retrieved_info += "\nRelevant knowledge from my understanding:\n"
-            retrieved_info += knowledge_from_graph
-
-        return retrieved_info.strip()
+        return "\n".join(relevant_memories)
 
     def update_memory_embeddings(self):
         self.memory_embeddings = self.embedding_model.encode(self.persistent_memory, convert_to_tensor=True)
 
-    def query_knowledge_graph(self, query):
-        query_embedding = self.embedding_model.encode(query, convert_to_tensor=True)
-        
-        node_embeddings = {}
-        for node in self.knowledge_graph.nodes():
-            try:
-                node_embedding = self.embedding_model.encode(node, convert_to_tensor=True)
-                node_embeddings[node] = node_embedding
-            except Exception as e:
-                print(f"Error encoding node {node}: {e}")
-
-        similarities = {node: util.pytorch_cos_sim(query_embedding, embedding)[0][0].item() for node, embedding in node_embeddings.items()}
-
-        most_similar_node = max(similarities, key=similarities.get)
-
-        if similarities[most_similar_node] < 0.6:
-            return ""
-
-        related_info = f"Information about {most_similar_node}:\n"
-        for neighbor in self.knowledge_graph.neighbors(most_similar_node):
-            relation = self.knowledge_graph[most_similar_node][neighbor]['relation']
-            related_info += f"- {most_similar_node} {relation} {neighbor}.\n"
-
-        return related_info
-
-    def update_belief(self, statement, new_belief_score):
-        if statement in self.belief_system:
-            previous_belief_score = self.belief_system[statement]
-            updated_belief_score = previous_belief_score * 0.8 + new_belief_score * 0.2
-            self.belief_system[statement] = np.clip(updated_belief_score, 0.0, 1.0)
-        else:
-            self.belief_system[statement] = new_belief_score
-
     def reset_conversation(self):
         self.conversation_history = []
         self.persistent_memory = []
@@ -296,13 +147,12 @@ class XylariaChat:
         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": "Develop a deeper understanding of the world", "priority": 0.6, "status": "active"}
+            {"goal": "Maintain a coherent and engaging conversation", "priority": 0.7, "status": "active"}
         ]
 
         try:
             self.client = InferenceClient(
-                model="Qwen/Qwen-32B-Preview",
+                model="Qwen/QwQ-32B-Preview",
                 api_key=self.hf_token
             )
         except Exception as e:
@@ -344,30 +194,9 @@ class XylariaChat:
             return text.strip()
         except Exception as e:
             return f"Error during Math OCR: {e}"
-
-    def extract_entities_and_relations(self, text):
-        inputs = self.embedding_model.tokenizer(text, return_tensors="pt", padding=True, truncation=True)
-        
-        entities = []
-        relations = []
-
-        return entities, relations
-
-    def update_knowledge_graph(self, entities, relations):
-        for entity in entities:
-            self.knowledge_graph.add_node(entity)
-        for relation in relations:
-            parts = relation.split(" related_to ")
-            if len(parts) == 2:
-                entity1, entity2 = parts
-                if entity1 in self.knowledge_graph and entity2 in self.knowledge_graph:
-                    self.knowledge_graph.add_edge(entity1, entity2, relation="related_to")
-
+    
     def get_response(self, user_input, image=None):
         try:
-            entities, relations = self.extract_entities_and_relations(user_input)
-            self.update_knowledge_graph(entities, relations)
-
             messages = []
 
             messages.append(ChatMessage(
@@ -397,12 +226,12 @@ class XylariaChat:
 
             input_tokens = sum(len(msg['content'].split()) for msg in messages)
             max_new_tokens = 16384 - input_tokens - 50
-            
-            max_new_tokens = min(max_new_tokens, 2048)
+
+            max_new_tokens = min(max_new_tokens, 10020)
 
             stream = self.client.chat_completion(
                 messages=messages,
-                model="Qwen/Qwen-32B-Preview",
+                model="Qwen/QwQ-32B-Preview",
                 temperature=0.7,
                 max_tokens=max_new_tokens,
                 top_p=0.9,
@@ -471,26 +300,20 @@ class XylariaChat:
             full_response = self.adjust_response_based_on_state(full_response)
 
             self.update_goals(message)
-            entities, relations = self.extract_entities_and_relations(message)
-            self.update_knowledge_graph(entities, relations)
 
             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)
-                self.update_belief("I am feeling down today", 0.8)
             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)
-                self.update_belief("I am feeling happy today", 0.8)
             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)
-                self.update_belief("I am feeling angry today", 0.8)
             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)
-                self.update_belief("I am feeling scared today", 0.8)
             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)
-                self.update_belief("I am feeling surprised today", 0.8)
             else:
                 self.update_internal_state({"valence": 0.05, "arousal": 0.05}, 0, 0.1)
+            
 
             self.conversation_history.append(ChatMessage(role="user", content=message).to_dict())
             self.conversation_history.append(ChatMessage(role="assistant", content=full_response).to_dict())