Update app.py

app.py

@@ -1,26 +1,22 @@
-#INFERENCE NLP+EMOTION DETECTION CV+TTS+THREAT DETECTION CV
+#INFERENCE NLP+EMOTION DETECTION CV+TTS+Memory Management
 import spaces
 
 import gradio as gr
 from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
 import torch
 from deepface import DeepFace
-import threading
 import time
 from transformers import AutoProcessor, DiaForConditionalGeneration
 import numpy as np
-import supervision as sv
-import requests
-from PIL import Image
-import os
-from rfdetr import RFDETRNano
+import chromadb
+from langchain_community.vectorstores import Chroma
+from collections import defaultdict
+from sklearn.cluster import DBSCAN
 
-# Model setup
 model_name = "IniNLP247/Kenko-mental-health-llama-3-model"
 
-print("🔄 Loading Kenko Mental Health Model...")
+print("Loading Kenko Mental Health Model...")
 
-# Load tokenizer and model
 tokenizer = AutoTokenizer.from_pretrained(model_name)
 if tokenizer.pad_token is None:
     tokenizer.pad_token = tokenizer.eos_token
@@ -31,7 +27,6 @@ model = AutoModelForCausalLM.from_pretrained(
     device_map="auto"
 )
 
-# Create pipeline for easier inference
 pipe = pipeline(
     "text-generation",
     model=model,
@@ -44,51 +39,31 @@ pipe = pipeline(
     pad_token_id=tokenizer.pad_token_id
 )
 
-print("✅ Model loaded successfully!")
+print("Model loaded successfully!")
+
 
-#Loading of TTS
 print("Loading Dia TTS Model...")
 tts_device = "cuda:0" if torch.cuda.is_available() else "cpu"
 tts_model = "nari-labs/Dia-1.6B-0626"
 tts_processor = AutoProcessor.from_pretrained(tts_model)
 tts_model = DiaForConditionalGeneration.from_pretrained(tts_model, torch_dtype=torch.float16).to(tts_device)
-print("✅ Dia TTS Model loaded successfully!")
+print("Dia TTS Model loaded successfully!")
 
-THREAT_CLASSES = {
-    1: "Gun",
-    2: "Explosive",
-    3: "Grenade",
-    4: "Knife"
-}
+print("Initializing Memory Components...")
+chroma_client = chromadb.Client()
+embedding_model = SentenceTransformer("all-MiniLM-L6-v2")
 
-#Loading Threat Detection Model
-print("Loading Threat Detection Model...")
-threat_weights_url = "https://huggingface.co/Subh775/Threat-Detection-RF-DETR/resolve/main/checkpoint_best_total.pth"
-threat_weights_filename = "checkpoint_best_total.pth"
-
-# Download weights if not already present
-if not os.path.exists(threat_weights_filename):
-    print(f"Downloading weights from {threat_weights_url}")
-    response = requests.get(threat_weights_url, stream=True)
-    response.raise_for_status()
-    with open(threat_weights_filename, 'wb') as f:
-        for chunk in response.iter_content(chunk_size=8192):
-            f.write(chunk)
-    print("Download complete.")
-
-threat_model = RFDETRNano(resolution=640, pretrain_weights=threat_weights_filename)
-#threat_model.optimize_for_inference()
-
-print("✅ Threat Detection Model loaded successfully!")
-
-#Global Variables For Threat Detection
-current_threat_state = {
-    "threat_detected": [],
-    "threat_count": 0,
-    "last_update": None
-}
+def embed_function(texts):
+    if isinstance(texts, str):
+        texts = [texts]
+    return embedding_model.encode(texts).tolist()
+
+global_vector_store = Chroma(
+    client=chroma_client,
+    embedding_function=embed_function
+)
+print("Memory components initialized!")
 
-# Global variable to store current emotion state
 current_emotion_state = {
     "dominant": "neutral",
     "confidence": 0.0,
@@ -96,8 +71,359 @@ current_emotion_state = {
     "last_update": None
 }
 
+
+class AdvancedMemorySystem:
+    """
+    Multi-tier memory system inspired by human memory:
+    - Working Memory: Current conversation (high priority)
+    - Short-term Memory: Recent session with decay
+    - Long-term Memory: Semantic clusters of important themes
+    - Emotional Memory: Affective associations and patterns
+    """
+
+    def __init__(self, embedding_model, vector_store):
+        self.embedding_model = embedding_model
+        self.vector_store = vector_store
+
+        # Working memory - immediate context
+        self.working_memory = []
+
+        # Short-term memory with temporal decay
+        self.short_term_memory = []  # (timestamp, text, embedding, importance_score)
+
+        # Long-term semantic clusters
+        self.semantic_clusters = defaultdict(list)  # {cluster_id: [memories]}
+
+        # Emotional memory graph
+        self.emotional_memory = {
+            "emotion_transitions": [],  # Track emotional journey
+            "trigger_patterns": defaultdict(list),  # What triggers what emotion
+            "coping_effectiveness": {}  # Track which strategies work
+        }
+
+        # Meta-cognitive tracking
+        self.conversation_themes = []
+        self.user_model = {
+            "communication_style": None,
+            "recurring_concerns": [],
+            "progress_indicators": [],
+            "relational_patterns": []
+        }
+
+    def calculate_importance(self, text, emotion, user_engagement):
+        """Calculate memory importance using multiple factors"""
+        importance = 0.5  # Base importance
+
+        # Emotional weight
+        high_intensity_emotions = ["fear", "angry", "sad", "surprise"]
+        if emotion in high_intensity_emotions:
+            importance += 0.3
+
+        # Engagement weight
+        if len(text.split()) > 30:  # Longer, detailed message
+            importance += 0.2
+
+        # Therapeutic keywords
+        therapeutic_keywords = [
+            "trauma", "suicide", "self-harm", "abuse", "panic",
+            "breakthrough", "progress", "better", "worse", "relationship"
+        ]
+        if any(kw in text.lower() for kw in therapeutic_keywords):
+            importance += 0.3
+
+        return min(importance, 1.0)
+
+    def add_to_working_memory(self, user_msg, bot_msg, emotion, timestamp):
+        """Add to immediate working memory (sliding window)"""
+        self.working_memory.append({
+            "user": user_msg,
+            "bot": bot_msg,
+            "emotion": emotion,
+            "timestamp": timestamp
+        })
+
+        # Keep only last 5 exchanges in working memory
+        if len(self.working_memory) > 5:
+            # Consolidate oldest to short-term before removing
+            oldest = self.working_memory.pop(0)
+            self._consolidate_to_short_term(oldest)
+
+    def _consolidate_to_short_term(self, memory_item):
+        """Move from working to short-term memory with importance scoring"""
+        text = f"User: {memory_item['user']}\nKenko: {memory_item['bot']}"
+        embedding = self.embedding_model.encode(text)
+
+        # Calculate importance
+        importance = self.calculate_importance(
+            memory_item['user'],
+            memory_item['emotion'],
+            len(memory_item['user'].split())
+        )
+
+        self.short_term_memory.append({
+            "text": text,
+            "embedding": embedding,
+            "importance": importance,
+            "timestamp": memory_item['timestamp'],
+            "emotion": memory_item['emotion']
+        })
+
+        # Add to vector store with importance weighting
+        try:
+            self.vector_store.add_texts(
+                texts=[text],
+                metadatas=[{"importance": importance, "timestamp": memory_item['timestamp']}]
+            )
+        except Exception as e:
+            print(f"Vector store error: {e}")
+
+    def apply_temporal_decay(self, current_time):
+        """Apply decay to short-term memories over time"""
+        decay_rate = 0.01  # Decay 1% per time unit (adjusted for slower decay)
+
+        for memory in self.short_term_memory:
+            time_elapsed = (current_time - memory['timestamp']) / 60  # Convert to minutes
+            decay_factor = np.exp(-decay_rate * time_elapsed)
+            memory['importance'] *= decay_factor
+
+            # If importance drops below threshold, cluster into long-term
+            if memory['importance'] < 0.15:
+                self._consolidate_to_long_term(memory)
+
+    def _consolidate_to_long_term(self, memory):
+        """Cluster similar memories into semantic long-term memory"""
+        # Get embeddings of all long-term memories
+        if not self.semantic_clusters:
+            self.semantic_clusters[0] = [memory]
+            self.short_term_memory.remove(memory)
+            return
+
+        # Find semantic cluster using cosine similarity
+        best_cluster = 0
+        best_similarity = -1
+
+        for cluster_id, cluster_memories in self.semantic_clusters.items():
+            # Compare with cluster centroid
+            cluster_embeddings = [m['embedding'] for m in cluster_memories]
+            centroid = np.mean(cluster_embeddings, axis=0)
+
+            similarity = np.dot(memory['embedding'], centroid) / (
+                np.linalg.norm(memory['embedding']) * np.linalg.norm(centroid)
+            )
+
+            if similarity > best_similarity:
+                best_similarity = similarity
+                best_cluster = cluster_id
+
+        # Add to cluster if similar enough, else create new cluster
+        if best_similarity > 0.7:
+            self.semantic_clusters[best_cluster].append(memory)
+        else:
+            new_cluster_id = max(self.semantic_clusters.keys()) + 1
+            self.semantic_clusters[new_cluster_id] = [memory]
+
+        # Remove from short-term
+        if memory in self.short_term_memory:
+            self.short_term_memory.remove(memory)
+
+    def track_emotional_transition(self, prev_emotion, current_emotion, context):
+        """Track emotional state transitions for pattern recognition"""
+        self.emotional_memory["emotion_transitions"].append({
+            "from": prev_emotion,
+            "to": current_emotion,
+            "context": context,
+            "timestamp": time.time()
+        })
+
+        # Analyze if certain topics trigger emotional shifts
+        if prev_emotion != current_emotion:
+            self.emotional_memory["trigger_patterns"][current_emotion].append(context)
+
+    def analyze_conversation_themes(self):
+        """Use topic modeling on conversation to identify recurring themes"""
+        if len(self.short_term_memory) < 3:
+            return []
+
+        # Simple keyword extraction
+        all_text = " ".join([m['text'] for m in self.short_term_memory])
+
+        # Extract key phrases
+        words = all_text.lower().split()
+        word_freq = defaultdict(int)
+
+        stopwords = {"the", "a", "is", "in", "and", "to", "of", "i", "my", "me", "you", "that", "it"}
+        for word in words:
+            if word not in stopwords and len(word) > 4:
+                word_freq[word] += 1
+
+        # Get top themes
+        themes = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:5]
+        self.conversation_themes = [theme[0] for theme in themes]
+
+        return self.conversation_themes
+
+    def retrieve_contextual_memory(self, query, current_emotion):
+        """Advanced retrieval using multiple memory tiers"""
+        context = {
+            "working": [],
+            "short_term": [],
+            "long_term": [],
+            "emotional": [],
+            "themes": []
+        }
+
+        # 1. Working memory (full recent conversation)
+        context["working"] = self.working_memory[-3:]  # Last 3 exchanges
+
+        # 2. Short-term memory (importance-weighted retrieval)
+        if self.short_term_memory:
+            query_embedding = self.embedding_model.encode(query)
+
+            scored_memories = []
+            for memory in self.short_term_memory:
+                # Semantic similarity
+                similarity = np.dot(query_embedding, memory['embedding']) / (
+                    np.linalg.norm(query_embedding) * np.linalg.norm(memory['embedding'])
+                )
+
+                # Boost by importance score
+                final_score = similarity * memory['importance']
+
+                # Emotional congruence bonus
+                if memory['emotion'] == current_emotion:
+                    final_score *= 1.2
+
+                scored_memories.append((final_score, memory))
+
+            # Get top 3 short-term memories
+            scored_memories.sort(reverse=True, key=lambda x: x[0])
+            context["short_term"] = [m[1] for m in scored_memories[:3]]
+
+        # 3. Long-term memory (semantic clusters)
+        if self.semantic_clusters:
+            query_embedding = self.embedding_model.encode(query)
+            best_cluster_id = None
+            best_cluster_score = -1
+
+            for cluster_id, cluster_memories in self.semantic_clusters.items():
+                cluster_embeddings = [m['embedding'] for m in cluster_memories]
+                centroid = np.mean(cluster_embeddings, axis=0)
+
+                similarity = np.dot(query_embedding, centroid) / (
+                    np.linalg.norm(query_embedding) * np.linalg.norm(centroid)
+                )
+
+                if similarity > best_cluster_score:
+                    best_cluster_score = similarity
+                    best_cluster_id = cluster_id
+
+            if best_cluster_id is not None and best_cluster_score > 0.6:
+                # Return summary of cluster
+                cluster = self.semantic_clusters[best_cluster_id]
+                context["long_term"] = cluster[:2]  # Top 2 from cluster
+
+        # 4. Emotional memory patterns
+        if current_emotion in self.emotional_memory["trigger_patterns"]:
+            triggers = self.emotional_memory["trigger_patterns"][current_emotion]
+            context["emotional"] = triggers[-2:]  # Recent triggers for this emotion
+
+        # 5. Conversation themes
+        context["themes"] = self.analyze_conversation_themes()
+
+        return context
+
+    def update_user_model(self, message, emotion):
+        """Build a psychological profile of the user over time"""
+        # Communication style detection
+        if len(message.split()) > 50:
+            style = "detailed"
+        elif len(message.split()) < 10:
+            style = "concise"
+        else:
+            style = "moderate"
+
+        self.user_model["communication_style"] = style
+
+        # Track recurring concerns
+        concern_keywords = {
+            "anxiety": ["anxious", "worried", "panic", "nervous", "anxiety"],
+            "depression": ["sad", "depressed", "hopeless", "empty", "depression"],
+            "relationships": ["partner", "relationship", "friend", "family"],
+            "work_stress": ["work", "job", "career", "boss", "stress"]
+        }
+
+        for concern, keywords in concern_keywords.items():
+            if any(kw in message.lower() for kw in keywords):
+                if concern not in self.user_model["recurring_concerns"]:
+                    self.user_model["recurring_concerns"].append(concern)
+
+    def generate_memory_context_string(self, contextual_memory):
+        """Format retrieved memories into prompt context"""
+        context_parts = []
+
+        # Working memory (recent conversation)
+        if contextual_memory["working"]:
+            recent = "\n".join([
+                f"User: {m['user']}\nKenko: {m['bot']}"
+                for m in contextual_memory["working"]
+            ])
+            context_parts.append(f"### Recent Conversation:\n{recent}")
+
+        # Important short-term memories
+        if contextual_memory["short_term"]:
+            important = "\n".join([m['text'] for m in contextual_memory["short_term"]])
+            context_parts.append(f"### Important Recent Context:\n{important}")
+
+        # Long-term thematic memories
+        if contextual_memory["long_term"]:
+            longterm = "\n".join([m['text'] for m in contextual_memory["long_term"]])
+            context_parts.append(f"### Related Past Discussions:\n{longterm}")
+
+        # Emotional patterns
+        if contextual_memory["emotional"]:
+            emotional = ", ".join(contextual_memory["emotional"][:3])
+            context_parts.append(f"### Emotional Pattern: Previously triggered by: {emotional}")
+
+        # Conversation themes
+        if contextual_memory["themes"]:
+            themes = ", ".join(contextual_memory["themes"])
+            context_parts.append(f"### Session Themes: {themes}")
+
+        # User model insights
+        if self.user_model["recurring_concerns"]:
+            concerns = ", ".join(self.user_model["recurring_concerns"])
+            context_parts.append(f"### Recurring Concerns: {concerns}")
+
+        return "\n\n".join(context_parts)
+
+    def reset(self):
+        """Reset all memory tiers"""
+        self.working_memory = []
+        self.short_term_memory = []
+        self.semantic_clusters = defaultdict(list)
+        self.emotional_memory = {
+            "emotion_transitions": [],
+            "trigger_patterns": defaultdict(list),
+            "coping_effectiveness": {}
+        }
+        self.conversation_themes = []
+        self.user_model = {
+            "communication_style": None,
+            "recurring_concerns": [],
+            "progress_indicators": [],
+            "relational_patterns": []
+        }
+
+
+# Initialize the advanced memory system
+print("🔄 Initializing Advanced Memory System...")
+advanced_memory = AdvancedMemorySystem(embedding_model, global_vector_store)
+print("✅ Advanced Memory System initialized!")
+
+# Track previous emotion for transition analysis
+previous_emotion = "neutral"
+
 def update_emotion_status():
-    """Update emotion status text"""
     if current_emotion_state["last_update"] is None:
         return "*Waiting for emotion data...*"
 
@@ -109,22 +435,7 @@ def update_emotion_status():
     confidence = current_emotion_state["confidence"]
     return f"**Current Emotion:** {dominant.capitalize()} ({confidence:.1f}% confidence)\n*Last updated: {int(elapsed)}s ago*"
 
-def update_threat_status():
-    """Update threat status text"""
-    if current_threat_state["last_update"] is None:
-        return "*Monitoring for threats...*"
-
-    elapsed = time.time() - current_threat_state["last_update"]
-
-    threats = current_threat_state["threat_detected"]
-    if threats:
-        threat_list = ", ".join([t["type"] for t in threats])
-        return f"**⚠️ ALERT:** {threat_list} detected\n*Last updated: {int(elapsed)}s ago*"
-    else:
-        return f"**✅ Safe:** No threats detected\n*Last updated: {int(elapsed)}s ago*"
-
 def analyze_emotion(image):
-    """Analyze emotion from webcam image"""
     global current_emotion_state
 
     try:
@@ -145,7 +456,6 @@ def analyze_emotion(image):
             emotions = result['emotion']
             dominant = result['dominant_emotion']
 
-        # Update global emotion state
         current_emotion_state = {
             "dominant": dominant,
             "confidence": emotions[dominant],
@@ -153,10 +463,9 @@ def analyze_emotion(image):
             "last_update": time.time()
         }
 
-        # Format for display - REMOVE the % symbol and keep as numbers
         output = {}
         for emotion, score in sorted(emotions.items(), key=lambda x: x[1], reverse=True):
-            output[emotion.capitalize()] = score  # Just the number, no formatting
+            output[emotion.capitalize()] = score 
 
         return output
 
@@ -169,7 +478,6 @@ def get_emotion_context():
     if current_emotion_state["last_update"] is None:
         return ""
 
-    # Check if emotion data is recent (within last 60 seconds)
     if time.time() - current_emotion_state["last_update"] > 60:
         return ""
 
@@ -182,28 +490,21 @@ def get_emotion_context():
 def chat_with_kenko(message, history):
     """Chat function for Gradio interface with emotion awareness"""
 
-    # Build conversation context
     conversation = ""
     for user_msg, bot_msg in history:
         conversation += f"User: {user_msg}\nKenko: {bot_msg}\n\n"
 
-    # Get emotion context
     emotion_context = get_emotion_context()
 
-    # Get threat context
     threat_context = get_threat_context()
 
-    # Create prompt in instruction format with emotion awareness
     prompt = f"""### Instruction:
 You are Kenko, a compassionate mental health therapist. Provide empathetic, helpful, and professional responses to support the user's mental wellbeing.
 {emotion_context}{threat_context}
-
 {conversation}User: {message}
-
 ### Response:
 """
 
-    # Generate response
     try:
         response = pipe(prompt)[0]['generated_text']
         return response.strip()
@@ -216,23 +517,19 @@ def generate_tts(text):
 
         print(f"[TTS] Generating speech for {len(text)} chars: '{text[:50]}...'")
 
-        # Prepare inputs for Dia TTS
         inputs = tts_processor(text=text, return_tensors="pt", padding=True)
         inputs = {k: v.to(tts_device) for k, v in inputs.items()}
 
         print(f"[TTS] Inputs prepared, generating audio codes...")
 
-        # Generate audio codes
         with torch.no_grad():
             generated_ids = tts_model.generate(**inputs, max_length=2500)
 
         print(f"[TTS] Audio codes generated, shape: {generated_ids.shape}")
         print(f"[TTS] Decoding codes to waveform...")
 
-        # Decode the audio codes to waveform using the processor's batch_decode
         audio_values = tts_processor.batch_decode(generated_ids, return_tensors="pt")
 
-        # Extract the audio waveform
         if isinstance(audio_values, dict) and 'audio_values' in audio_values:
             audio_arr = audio_values['audio_values'][0].cpu().numpy()
         elif isinstance(audio_values, torch.Tensor):
@@ -242,93 +539,24 @@ def generate_tts(text):
         else:
             audio_arr = np.array(audio_values).squeeze()
 
-        # Ensure float32
         audio_arr = audio_arr.astype(np.float32)
 
-        # Dia uses 44.1kHz sample rate
         sample_rate = 44100
 
-        print(f"✅ [TTS] Audio decoded: {len(audio_arr)} samples at {sample_rate}Hz = {len(audio_arr)/sample_rate:.2f} seconds")
+        print(f"[TTS] Audio decoded: {len(audio_arr)} samples at {sample_rate}Hz = {len(audio_arr)/sample_rate:.2f} seconds")
 
         if len(audio_arr) == 0:
-            print("❌ Decoded audio is empty!")
+            print("Decoded audio is empty!")
             return None
 
         return (sample_rate, audio_arr)
 
     except Exception as e:
-        print(f"❌ TTS generation error: {str(e)}")
+        print(f"TTS generation error: {str(e)}")
         import traceback
         traceback.print_exc()
         return None
 
-def threat_detection(image):
-    """Threat detection function for webcam"""
-    global current_threat_state
-
-    try:
-        if image is None:
-            return {}
-
-        # Convert numpy array to PIL Image if needed
-        if isinstance(image, np.ndarray):
-            image = Image.fromarray(image)
-
-        # Run Threat Detection
-        detections = threat_model.predict(image, threshold=0.3)  # Lower threshold for testing
-
-        # Parse detections - detections.class_id and detections.confidence are ARRAYS
-        threat_found = []
-        if detections is not None and len(detections.class_id) > 0:
-            for class_id, confidence in zip(detections.class_id, detections.confidence):
-                class_id = int(class_id)
-                confidence = float(confidence)
-                
-                if class_id in THREAT_CLASSES:
-                    threat_name = THREAT_CLASSES[class_id]
-                    threat_found.append({"type": threat_name, "confidence": confidence})
-                    print(f"🚨 THREAT DETECTED: {threat_name} - {confidence:.2%}")
-
-        # Update global threat state
-        current_threat_state = {
-            "threat_detected": threat_found,
-            "threat_count": len(threat_found),
-            "last_update": time.time()
-        }
-
-        # Format for display
-        if threat_found:
-            output = {}
-            for threat in threat_found:
-                output[threat["type"]] = threat["confidence"] * 100
-            return output
-        else:
-            return {"No threats detected": 100.0}
-
-    except Exception as e:
-        print(f"Threat detection error: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return {}
-
-
-def get_threat_context():
-  """Get current threat as context string for the model"""
-  if current_threat_state["last_update"] is None:
-    return ""
-
-  #Check if threat data is recent (within last 60 seconds)
-  if time.time() - current_threat_state["last_update"] > 60:
-    return ""
-
-  threats = current_threat_state["threat_detected"]
-
-  if threats:
-    threat_list = ", ".join([f"{t['type']} ({t['confidence']*100:.1f}% confidence)" for t in threats])
-    return f"\n[User currently holds a potential threat: {threat_list}]"
-
-  return ""
-
 # Custom CSS for a calming interface
 css = """
 .gradio-container {
@@ -342,7 +570,6 @@ css = """
 }
 """
 
-# Create Gradio interface
 with gr.Blocks(
     title="Kenko - Mental Health Assistant",
     theme=gr.themes.Soft(),
@@ -350,16 +577,13 @@ with gr.Blocks(
 ) as demo:
 
     gr.Markdown("""
-    # 🧠💚 Kenko - Your Emotion-Aware Mental Health Assistant
-
+    # 💚 Kenko - Your Emotion-Aware Mental Health Assistant
     Welcome! I'm Kenko, an AI mental health therapist enhanced with real-time emotion detection.
     Allow webcam access to enable emotion-aware responses that adapt to how you're feeling.
-
     *Please remember: I'm an AI assistant and cannot replace professional mental health care. In crisis situations, please contact emergency services or a mental health professional.*
     """)
 
     with gr.Row():
-        # Left column: Chat interface
         with gr.Column(scale=2):
             chatbot = gr.Chatbot(
                 height=500,
@@ -389,7 +613,6 @@ with gr.Blocks(
                 clear_btn = gr.Button("🗑️ Clear Chat", scale=1, variant="secondary")
                 examples_btn = gr.Button("💡 Example Topics", scale=1, variant="secondary")
 
-        # Right column: Emotion detection
         with gr.Column(scale=1):
             gr.Markdown("### 📸 Emotion Detection")
             gr.Markdown("*Your emotional state helps me provide more personalized support*")
@@ -408,17 +631,7 @@ with gr.Blocks(
 
             emotion_status = gr.Markdown("*Waiting for emotion data...*")
 
-            #Threat detection output
-            gr.Markdown("### Threat Detection")
-            threat_output = gr.Label(
-                num_top_classes=4,
-                label="Detected Threats"
-            )
-
-            threat_status = gr.Markdown("*Monitoring for threats...")
-
-
-    # Example prompts
+    
     with gr.Row(visible=False) as examples_row:
         gr.Examples(
             examples=[
@@ -444,19 +657,16 @@ with gr.Blocks(
         - Relationship and communication advice
         - Mindfulness and self-care suggestions
         - Building healthy habits and routines
-
         **Emotion Detection Feature:**
         - Real-time facial emotion analysis
         - Adapts responses based on your current emotional state
         - Updates automatically every 30 seconds
         - Completely optional - works without webcam too
-
         **Important Notes:**
         - I'm an AI trained to provide mental health support
         - For immediate crisis support, contact emergency services (911) or crisis hotlines
         - Consider professional therapy for ongoing mental health needs
         - I don't diagnose conditions or prescribe medications
-
         **Privacy:** Your conversations and emotion data are not stored or shared.
         """)
     @spaces.GPU
@@ -485,35 +695,27 @@ with gr.Blocks(
         return gr.Row(visible=True)
 
 
-    # Event handlers
+
     submit = msg.submit(fn=respond, inputs=[msg, chatbot], outputs=[msg, chatbot, audio_output])
     send = send_btn.click(fn=respond, inputs=[msg, chatbot], outputs=[msg, chatbot, audio_output])
     clear_btn.click(lambda: [], None, outputs=[chatbot, audio_output])
     examples_btn.click(toggle_examples, outputs=examples_row)
 
-    # Emotion detection with streaming (analyzes continuously)
+
     webcam_input.stream(
     analyze_emotion,
     inputs=webcam_input,
     outputs=emotion_output,
-    stream_every=1,  # Update every 1 second instead of 30
-    time_limit=60   # Keep processing for 60 seconds
+    stream_every=1, 
+    time_limit=60   
 )
 
-    timer = gr.Timer(value=5)  # Update every 5 seconds
+    timer = gr.Timer(value=5)
+
 
-    # Threat detection with streaming
-    webcam_input.stream(
-        threat_detection, # Corrected function name
-        inputs=webcam_input, # Corrected inputs
-        outputs=threat_output,
-        stream_every=2,
-        time_limit=60
-)
-    # Add to timer tick
     timer.tick(
-    fn=lambda: (update_emotion_status(), update_threat_status()),
-    outputs=[emotion_status, threat_status]
+    fn=lambda: (update_emotion_status()),
+    outputs=[emotion_status]
 )