Update app.py

app.py

@@ -1,5 +1,5 @@
+import os
 import gradio as gr
-import pandas as pd
 import nltk
 import numpy as np
 import tflearn
@@ -11,216 +11,179 @@ from nltk.stem.lancaster import LancasterStemmer
 from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
 import googlemaps
 import folium
-import os
-import base64
-import torch  # Added missing import for torch
-from PIL import Image
+import pandas as pd
+import torch
 
-# Disable GPU usage for TensorFlow
+# Disable GPU usage for TensorFlow for compatibility
 os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
 
-# Ensure necessary NLTK resources are downloaded
+# Download necessary NLTK resources
 nltk.download('punkt')
 
-# Initialize the stemmer
+# Initialize Lancaster Stemmer
 stemmer = LancasterStemmer()
 
-# Load intents.json for Well-Being Chatbot
+# Load intents.json for Chatbot
 with open("intents.json") as file:
-    data = json.load(file)
+    intents_data = json.load(file)
 
-# Load preprocessed data for Well-Being Chatbot
+# Load tokenized data for Chatbot
 with open("data.pickle", "rb") as f:
     words, labels, training, output = pickle.load(f)
 
-# Build the model structure for Well-Being Chatbot
-net = tflearn.input_data(shape=[None, len(training[0])])
-net = tflearn.fully_connected(net, 8)
-net = tflearn.fully_connected(net, 8)
-net = tflearn.fully_connected(net, len(output[0]), activation="softmax")
-net = tflearn.regression(net)
+# Build Chatbot Model
+def build_chatbot_model():
+    net = tflearn.input_data(shape=[None, len(training[0])])
+    net = tflearn.fully_connected(net, 8)
+    net = tflearn.fully_connected(net, 8)
+    net = tflearn.fully_connected(net, len(output[0]), activation="softmax")
+    net = tflearn.regression(net)
+    model = tflearn.DNN(net)
+    model.load("MentalHealthChatBotmodel.tflearn")
+    return model
 
-# Load the trained model
-model = tflearn.DNN(net)
-model.load("MentalHealthChatBotmodel.tflearn")
+chatbot_model = build_chatbot_model()
 
-# Function to process user input into a bag-of-words format for Chatbot
+# Bag of Words Function for Chatbot
 def bag_of_words(s, words):
     bag = [0 for _ in range(len(words))]
     s_words = word_tokenize(s)
-    s_words = [stemmer.stem(word.lower()) for word in s_words if word.lower() in words]
+    s_words = [stemmer.stem(word.lower()) for word in s_words if word.isalnum()]
     for se in s_words:
         for i, w in enumerate(words):
             if w == se:
                 bag[i] = 1
     return np.array(bag)
 
-# Chat function for Well-Being Chatbot
-def chatbot(message, history):
+# Chatbot Response Function
+def chatbot_response(message, history):
+    """Respond to user input and update chat history."""
     history = history or []
-    message = message.lower()
     try:
-        # Predict the tag
-        results = model.predict([bag_of_words(message, words)])
-        results_index = np.argmax(results)
-        tag = labels[results_index]
-        # Match tag with intent and choose a random response
-        for tg in data["intents"]:
-            if tg['tag'] == tag:
-                responses = tg['responses']
-                response = random.choice(responses)
+        result = chatbot_model.predict([bag_of_words(message, words)])
+        result_index = np.argmax(result)
+        tag = labels[result_index]
+
+        response = "I didn't understand that. 🤔 Try rephrasing your question."
+        for intent in intents_data["intents"]:
+            if intent["tag"] == tag:
+                response = f"🤖 {random.choice(intent['responses'])}"
                 break
-        else:
-            response = "I'm sorry, I didn't understand that. Could you please rephrase?"
     except Exception as e:
-        print(f"Error in chatbot: {e}")  # For debugging
-        response = f"An error occurred: {str(e)}"
-    # Convert the new message and response to the 'messages' format
-    history.append({"role": "user", "content": message})
+        response = f"Error generating response: {str(e)} 💥"
+
+    history.append({"role": "user", "content": f"💬 {message}"})
     history.append({"role": "assistant", "content": response})
-    return history, history
+    return history, response
 
-# Sentiment Analysis using Hugging Face model
-tokenizer_sentiment = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
-model_sentiment = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
+# Emotion Detection with Transformers
+emotion_tokenizer = AutoTokenizer.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
+emotion_model = AutoModelForSequenceClassification.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
 
-def analyze_sentiment(user_input):
-    inputs = tokenizer_sentiment(user_input, return_tensors="pt")
-    with torch.no_grad():
-        outputs = model_sentiment(**inputs)
-        predicted_class = torch.argmax(outputs.logits, dim=1).item()
-        sentiment = ["Negative", "Neutral", "Positive"][predicted_class]
-        return f"Predicted Sentiment: {sentiment}"
+def detect_emotion(user_input):
+    """Detect emotion using a pre-trained model and return label with an emoji."""
+    pipe = pipeline("text-classification", model=emotion_model, tokenizer=emotion_tokenizer)
+    try:
+        result = pipe(user_input)
+        emotion = result[0]["label"]
+        emotion_map = {
+            "joy": "😊 Joy",
+            "anger": "😠 Anger",
+            "sadness": "😢 Sadness",
+            "fear": "😨 Fear",
+            "surprise": "😲 Surprise",
+            "neutral": "😐 Neutral",
+        }
+        return emotion_map.get(emotion, "Unknown Emotion 🤔")
+    except Exception as e:
+        return f"Error detecting emotion: {str(e)} 💥"
 
-# Emotion Detection using Hugging Face model
-tokenizer_emotion = AutoTokenizer.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
-model_emotion = AutoModelForSequenceClassification.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
+# Sentiment Analysis
+sentiment_tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
+sentiment_model = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
 
-def detect_emotion(user_input):
-    pipe = pipeline("text-classification", model=model_emotion, tokenizer=tokenizer_emotion)
-    result = pipe(user_input)
-    emotion = result[0]['label']
-    return f"Emotion Detected: {emotion}"
+def analyze_sentiment(user_input):
+    """Analyze sentiment of user input."""
+    inputs = sentiment_tokenizer(user_input, return_tensors="pt")
+    try:
+        with torch.no_grad():
+            outputs = sentiment_model(**inputs)
+        sentiment_class = torch.argmax(outputs.logits, dim=1).item()
+        sentiment_map = ["Negative 😔", "Neutral 😐", "Positive 😊"]
+        return f"Sentiment: {sentiment_map[sentiment_class]}"
+    except Exception as e:
+        return f"Error in sentiment analysis: {str(e)} 💥"
 
-# Function to generate suggestions based on detected emotion
+# Generate Suggestions Based on Emotion
 def generate_suggestions(emotion):
     suggestions = {
-        'joy': ["Stay positive! Keep up the good mood.", "Try some relaxing activities like meditation."],
-        'anger': ["It's okay to be angry, try to breathe and relax.", "Exercise can help release tension."],
-        'fear': ["Take deep breaths, you are in control.", "Try mindfulness exercises to calm your mind."],
-        'sadness': ["Take a break, it's okay to feel down sometimes.", "Consider reaching out to a friend or loved one."],
-        'surprise': ["Take a moment to reflect, things might seem overwhelming.", "Practice mindfulness to regain balance."],
-        'disgust': ["It's okay to feel disgust, try to identify the cause.", "Taking a short walk might help clear your mind."]
+        "😊 Joy": [
+            {"Title": "Meditation Techniques", "Link": "https://www.helpguide.org/mental-health/meditation/mindful-breathing-meditation"},
+            {"Title": "Learn Something New", "Link": "https://www.edx.org/"},
+        ],
+        "😢 Sadness": [
+            {"Title": "Emotional Wellness Toolkit", "Link": "https://www.nih.gov/health-information/emotional-wellness-toolkit"},
+            {"Title": "Relaxation Videos", "Link": "https://youtu.be/-e-4Kx5px_I"},
+        ],
+        "😠 Anger": [
+            {"Title": "Dealing with Anger", "Link": "https://www.helpguide.org/articles/anger/anger-management.htm"},
+            {"Title": "Stress Reducing Tips", "Link": "https://www.webmd.com/stress-management"},
+        ],
     }
-    return pd.DataFrame(suggestions.get(emotion, ["Stay positive!"]))
-
-# Function to get nearby health professionals and create a map
-def get_health_professionals_and_map(location, health_professional_query):
-    # Use Google Maps API to get health professionals (example setup)
-    gmaps = googlemaps.Client(key="YOUR_GOOGLE_API_KEY")
-    places = gmaps.places(query=health_professional_query, location=location)
+    return suggestions.get(emotion, [{"Title": "General Tips", "Link": "https://www.psychologytoday.com/"}])
+
+# Gradio Interface Main Function
+def well_being_app(user_input, location, query, history):
+    """Main app combining chatbot, emotion detection, sentiment, suggestions, and map."""
+    # Chatbot Interaction
+    history, chatbot_reply = chatbot_response(user_input, history)
+
+    # Emotion Detection
+    emotion = detect_emotion(user_input)
+
+    # Sentiment Analysis
+    sentiment = analyze_sentiment(user_input)
+
+    # Suggestions Based on Emotion
+    emotion_label = emotion.split(": ")[-1]
+    suggestions = generate_suggestions(emotion_label)
+    suggestions_df = pd.DataFrame(suggestions)
+
+    # Return Outputs
+    return (
+        history,
+        sentiment,
+        emotion,
+        suggestions_df
+    )
+
+# Gradio Interface UI
+with gr.Blocks() as app:
+    with gr.Row():
+        gr.Markdown("# 🌼 Well-Being Support Application")
+
+    with gr.Row():
+        user_input = gr.Textbox(lines=2, placeholder="Type your message here...", label="Your Message")
+        location = gr.Textbox(value="Honolulu, HI", label="Your Location")
+        query = gr.Textbox(value="Counselor", label="Health Professional (Doctor, Therapist, etc.)")
     
-    if places['status'] == 'OK':
-        results = places['results']
-        route_info = "\n".join([place['name'] for place in results])
-        map_html = create_map(results)
-        return route_info, map_html
-    return "No professionals found.", None
-
-def create_map(places):
-    m = folium.Map(location=[places[0]['geometry']['location']['lat'], places[0]['geometry']['location']['lng']], zoom_start=13)
-    for place in places:
-        folium.Marker([place['geometry']['location']['lat'], place['geometry']['location']['lng']], 
-                      popup=place['name']).add_to(m)
-    map_html = m._repr_html_()
-    return map_html
-
-# Custom CSS styling for Gradio interface
-css = """
-    body {
-        font-family: 'Roboto', sans-serif;
-    }
-    .gradio-container {
-        background-color: #f0f0f0;
-        font-size: 16px;
-    }
-    .gradio-input, .gradio-output {
-        padding: 15px;
-        border-radius: 10px;
-        background-color: #ffffff;
-        border: 2px solid #ccc;
-    }
-    .gradio-container .gradio-button {
-        background-color: #007BFF;
-        color: white;
-        border-radius: 5px;
-        padding: 10px 15px;
-    }
-    .gradio-container .gradio-button:hover {
-        background-color: #0056b3;
-    }
-    .gradio-container h3 {
-        color: #333;
-    }
-    .gradio-output .output {
-        border-top: 3px solid #ddd;
-        padding-top: 10px;
-    }
-    .gradio-input input {
-        color: #333;
-    }
-    .gradio-input textarea {
-        color: #333;
-    }
-"""
-
-# Gradio interface components
-def gradio_app(message, current_location, health_professional_query, history):
-    # Detect sentiment and emotion
-    sentiment = analyze_sentiment(message)
-    emotion = detect_emotion(message)
+    with gr.Row():
+        submit_button = gr.Button(value="Submit", label="Submit")
     
-    # Generate suggestions based on emotion
-    suggestions_df = generate_suggestions(emotion)
-    
-    # Get health professionals details and map
-    route_info, map_html = get_health_professionals_and_map(current_location, health_professional_query)
-    
-    # Add emoticon for emotion
-    emotion_emoticons = {
-        'joy': '😊',
-        'anger': '😡',
-        'fear': '😨',
-        'sadness': '😢',
-        'surprise': '😲',
-        'disgust': '🤢'
-    }
-    emotion_icon = emotion_emoticons.get(emotion, '🙂')
+    with gr.Row():
+        chatbot = gr.Chatbot(label="Chat History")
+        sentiment_output = gr.Textbox(label="Sentiment Analysis")
+        emotion_output = gr.Textbox(label="Emotion Detected")
     
-    return sentiment, f"{emotion_icon} {emotion}", suggestions_df, route_info, map_html, history
-
-# Gradio interface setup
-iface = gr.Interface(
-    fn=gradio_app,
-    inputs=[
-        gr.Textbox(lines=2, placeholder="Enter your message..."),
-        gr.Textbox(lines=2, placeholder="Enter your current location..."),
-        gr.Textbox(lines=2, placeholder="Enter health professional query..."),
-        gr.State(value=[])
-    ],
-    outputs=[
-        gr.Textbox(label="Sentiment Analysis"),
-        gr.Textbox(label="Detected Emotion"),
-        gr.Dataframe(label="Suggestions"),
-        gr.Textbox(label="Nearby Health Professionals"),
-        gr.HTML(label="Map of Health Professionals"),
-        gr.State(value=[])
-    ],
-    live=True,
-    allow_flagging="never",
-    theme="huggingface",
-    css=css  # Apply custom CSS styling
-)
-
-# Launch Gradio interface
-iface.launch(share=True)
+    with gr.Row():
+        suggestions_output = gr.DataFrame(label="Suggestions Based on Mood")
+
+    # Connect inputs and outputs
+    submit_button.click(
+        well_being_app,
+        inputs=[user_input, location, query, chatbot],
+        outputs=[chatbot, sentiment_output, emotion_output, suggestions_output],
+    )
+
+# Launch the app
+app.launch()