Fixed behaviour issue

app.py

@@ -88,49 +88,92 @@ def respond(message, history):
         if check_crisis_keywords(message):
             return get_crisis_response()
         
-        # Build conversation history with Aura's system prompt
-        conversation = AURA_SYSTEM_PROMPT + tokenizer.eos_token
+        # Build conversation history - SIMPLIFIED for DialoGPT
+        conversation = ""
         
-        for user_msg, bot_msg in history:
-            conversation += f"Human: {user_msg}{tokenizer.eos_token}Aura: {bot_msg}{tokenizer.eos_token}"
+        # Only include last 2-3 exchanges to avoid overwhelming the model
+        recent_history = history[-2:] if len(history) > 2 else history
         
-        # Add current message with Aura context
-        conversation += f"Human: {message}{tokenizer.eos_token}Aura: "
+        for user_msg, bot_msg in recent_history:
+            conversation += f"{user_msg}{tokenizer.eos_token}{bot_msg}{tokenizer.eos_token}"
+        
+        # Add current message
+        conversation += f"{message}{tokenizer.eos_token}"
         
         # Tokenize
         input_ids = tokenizer.encode(conversation, return_tensors="pt")
         
-        # Limit input length to prevent memory issues
-        if input_ids.shape[1] > 800:
-            input_ids = input_ids[:, -800:]
-        
-        # Generate response with more empathetic parameters
+        # Generate response with conservative settings for DialoGPT
         with torch.no_grad():
-            output = model.generate(
+            chat_history_ids = model.generate(
                 input_ids,
-                max_new_tokens=120,  # Slightly longer for empathetic responses
+                max_length=input_ids.shape[-1] + 50,  # Shorter responses
+                num_beams=5,
+                no_repeat_ngram_size=3,
                 do_sample=True,
-                top_p=0.85,  # More focused responses
-                temperature=0.7,  # Less random, more consistent
+                early_stopping=True,
                 pad_token_id=tokenizer.eos_token_id,
                 eos_token_id=tokenizer.eos_token_id,
-                no_repeat_ngram_size=3,
-                repetition_penalty=1.1
+                temperature=0.9,
+                top_k=50,
+                top_p=0.9
             )
         
-        # Decode response
-        raw_response = tokenizer.decode(output[0][input_ids.shape[1]:], skip_special_tokens=True).strip()
+        # Decode only the new response
+        raw_response = tokenizer.decode(
+            chat_history_ids[:, input_ids.shape[-1]:][0], 
+            skip_special_tokens=True
+        ).strip()
         
-        # Format response with Aura's personality
-        if raw_response:
-            formatted_response = format_aura_response(raw_response)
-            return formatted_response
+        # Apply Aura's empathetic formatting to the response
+        if raw_response and len(raw_response) > 1:
+            # Add empathetic framing
+            aura_response = add_empathy_to_response(raw_response, message)
+            return aura_response
         else:
-            return "I hear you, and I want you to know that I'm here to listen. Sometimes it takes a moment to find the right words."
+            return get_fallback_aura_response(message)
         
     except Exception as e:
         print(f"Error: {e}")
-        return "I'm sorry, I'm having trouble responding right now. But please know that I'm here for you, and your feelings are valid."
+        return "I hear you, and I want you to know that I'm here for you. Sometimes I need a moment to find the right words."
+
+def add_empathy_to_response(response, user_message):
+    """Add Aura's empathetic touch to the raw response"""
+    # Detect emotional keywords to tailor empathy
+    emotional_words = ['sad', 'angry', 'frustrated', 'worried', 'scared', 'lonely', 'hurt', 'upset', 'stressed']
+    user_lower = user_message.lower()
+    
+    empathetic_starters = [
+        "I hear you, and ",
+        "That sounds really difficult. ",
+        "I can imagine that feels heavy. ",
+        "Thank you for sharing that with me. "
+    ]
+    
+    # Choose appropriate empathetic starter
+    if any(word in user_lower for word in emotional_words):
+        starter = "I can imagine that feels really difficult. "
+    elif "not good enough" in user_lower or "failure" in user_lower:
+        starter = "I hear you, and those feelings are so valid. "
+    else:
+        starter = "I hear you. "
+    
+    # Clean up the response and add empathy
+    cleaned_response = response.replace("Human:", "").replace("Aura:", "").strip()
+    return f"{starter}{cleaned_response}"
+
+def get_fallback_aura_response(user_message):
+    """Provide appropriate fallback responses based on user input"""
+    user_lower = user_message.lower()
+    
+    if "not good enough" in user_lower:
+        return "I hear you, and I want you to know that those feelings of not being good enough are so valid. It takes courage to share that."
+    elif "what" in user_lower and "do" in user_lower:
+        return "I can hear that you're looking for some direction. Rather than telling you what to do, I'm wondering - what feels most important to you right now?"
+    elif len(user_message.strip()) <= 2:  # Short messages like "??"
+        return "I'm here with you. Sometimes it's hard to find words, and that's okay. Take your time."
+    else:
+        return "I hear you, and I want you to know that I'm here to listen. Your feelings matter to me."
 
 # Create Gradio interface
 with gr.Blocks(title="Aura - Your Supportive Friend") as demo:
@@ -187,4 +230,13 @@ with gr.Blocks(title="Aura - Your Supportive Friend") as demo:
 
 if __name__ == "__main__":
     demo.queue()
-    demo.launch(share=True)  # This creates a public link
+    # Check if running on Hugging Face Spaces
+    import os
+    if "SPACE_ID" in os.environ:
+        # Running on HF Spaces - public by default
+        demo.launch()
+        print(f"🌐 Your chatbot is publicly available at: https://huggingface.co/spaces/{os.environ.get('SPACE_AUTHOR_NAME', 'your-username')}/{os.environ.get('SPACE_REPO_NAME', 'chatbot')}")
+    else:
+        # Running locally - create public link
+        demo.launch(share=True)
+        print("🌐 Public link generated above ⬆️")

test_model.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""
+Test script to validate DialoGPT model response generation
+"""
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+def test_model():
+    print("Loading DialoGPT-medium for testing...")
+    
+    # Load model and tokenizer
+    tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-medium")
+    model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-medium")
+    
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    
+    print("Model loaded successfully!")
+    
+    # Test conversation
+    test_messages = [
+        "I feel sad today",
+        "What should I do?",
+        "Hello"
+    ]
+    
+    for i, message in enumerate(test_messages):
+        print(f"\n--- Test {i+1}: '{message}' ---")
+        
+        # Simple conversation format
+        conversation = f"{message}{tokenizer.eos_token}"
+        input_ids = tokenizer.encode(conversation, return_tensors="pt")
+        
+        # Generate response with conservative settings
+        with torch.no_grad():
+            chat_history_ids = model.generate(
+                input_ids,
+                max_length=input_ids.shape[-1] + 50,
+                num_beams=5,
+                no_repeat_ngram_size=3,
+                do_sample=True,
+                early_stopping=True,
+                pad_token_id=tokenizer.eos_token_id,
+                eos_token_id=tokenizer.eos_token_id,
+                temperature=0.9,
+                top_k=50,
+                top_p=0.9
+            )
+        
+        # Decode response
+        response = tokenizer.decode(
+            chat_history_ids[:, input_ids.shape[-1]:][0], 
+            skip_special_tokens=True
+        ).strip()
+        
+        print(f"Raw response: '{response}'")
+        print(f"Response length: {len(response)} characters")
+        
+        if len(response) > 1:
+            print("✅ Good response generated")
+        else:
+            print("⚠️  Short/empty response")
+    
+    print("\n✅ Model testing complete!")
+
+if __name__ == "__main__":
+    test_model()