Update app.py

app.py

@@ -9,173 +9,217 @@ import pickle
 from nltk.tokenize import word_tokenize
 from nltk.stem.lancaster import LancasterStemmer
 from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
+import googlemaps
+import folium
 import pandas as pd
 import torch
 
-# Disable TensorFlow GPU warnings
-os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+# Disable GPU usage for TensorFlow
+os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
 
-# Download necessary NLTK resources
-nltk.download("punkt")
+# Ensure necessary NLTK resources are downloaded
+nltk.download('punkt')
 
-# Initialize Lancaster Stemmer
+# Initialize the stemmer
 stemmer = LancasterStemmer()
 
-# Load intents.json for chatbot
+# Load intents.json for Well-Being Chatbot
 with open("intents.json") as file:
-    intents_data = json.load(file)
+    data = json.load(file)
 
-# Load tokenized training data
+# Load preprocessed data for Well-Being Chatbot
 with open("data.pickle", "rb") as f:
     words, labels, training, output = pickle.load(f)
 
-# Build TFlearn 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
+# 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)
 
-chatbot_model = build_chatbot_model()
+# Load the trained model
+model = tflearn.DNN(net)
+model.load("MentalHealthChatBotmodel.tflearn")
 
-# Bag of Words Function
+# Function to process user input into a bag-of-words format 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.isalnum()]
+    s_words = [stemmer.stem(word.lower()) for word in s_words if word.lower() in words]
     for se in s_words:
         for i, w in enumerate(words):
             if w == se:
                 bag[i] = 1
     return np.array(bag)
 
-# Chatbot Response Function
-def chatbot_response(message, history):
+# Chat function for Well-Being Chatbot
+def chatbot(message, history):
     history = history or []
+    message = message.lower()
     try:
-        result = chatbot_model.predict([bag_of_words(message, words)])
-        idx = np.argmax(result)
-        tag = labels[idx]
-        response = "I'm not sure how to respond to that. 🤔"
-        for intent in intents_data["intents"]:
-            if intent["tag"] == tag:
-                response = random.choice(intent["responses"])
+        # 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)
                 break
+        else:
+            response = "I'm sorry, I didn't understand that. Could you please rephrase?"
     except Exception as e:
-        response = f"Error generating response: {str(e)} 💥"
-
+        response = f"An error occurred: {str(e)}"
+    
+    # Convert the new message and response to the 'messages' format
     history.append({"role": "user", "content": message})
     history.append({"role": "assistant", "content": response})
-    return history, response
-
-# Emotion Detection
-emotion_tokenizer = AutoTokenizer.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
-emotion_model = AutoModelForSequenceClassification.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
-
-def detect_emotion(user_input):
-    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)} 💥"
+    
+    return history, history
 
-# Sentiment Analysis
-sentiment_tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
-sentiment_model = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
+# 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")
 
 def analyze_sentiment(user_input):
-    inputs = sentiment_tokenizer(user_input, return_tensors="pt")
-    try:
-        with torch.no_grad():
-            outputs = sentiment_model(**inputs)
-        sentiment = torch.argmax(outputs.logits, dim=1).item()
-        sentiment_map = ["Negative 😔", "Neutral 😐", "Positive 😊"]
-        return sentiment_map[sentiment]
-    except Exception as e:
-        return f"Error in sentiment analysis: {str(e)} 💥"
+    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]  # Assuming 3 classes
+    return f"Predicted Sentiment: {sentiment}"
+
+# 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")
 
-# Suggestions Based on Emotion
+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}"
+
+# Initialize Google Maps API client securely
+gmaps = googlemaps.Client(key=os.getenv('GOOGLE_API_KEY'))
+
+# Function to search for health professionals
+def search_health_professionals(query, location, radius=10000):
+    places_result = gmaps.places_nearby(location, radius=radius, type='doctor', keyword=query)
+    return places_result.get('results', [])
+
+# Function to get directions and display on Gradio UI
+def get_health_professionals_and_map(current_location, health_professional_query):
+    location = gmaps.geocode(current_location)
+    if location:
+        lat = location[0]["geometry"]["location"]["lat"]
+        lng = location[0]["geometry"]["location"]["lng"]
+        location = (lat, lng)
+        
+        professionals = search_health_professionals(health_professional_query, location)
+        
+        # Generate map
+        map_center = location
+        m = folium.Map(location=map_center, zoom_start=13)
+        
+        # Add markers to the map
+        for place in professionals:
+            folium.Marker(
+                location=[place['geometry']['location']['lat'], place['geometry']['location']['lng']],
+                popup=place['name']
+            ).add_to(m)
+        
+        # Convert map to HTML for Gradio display
+        map_html = m._repr_html_()
+        
+        # Route information
+        route_info = "\n".join([f"{place['name']} - {place['vicinity']}" for place in professionals])
+        
+        return route_info, map_html
+    else:
+        return "Unable to find location.", ""
+
+# Function to generate suggestions based on the detected emotion
 def generate_suggestions(emotion):
-    suggestions_map = {
-        "😊 Joy": [
-            {"Title": "Mindful Meditation 🧘", "Link": "https://www.helpguide.org/meditation"},
-            {"Title": "Learn a New Skill ✨", "Link": "https://www.skillshare.com/"},
-        ],
-        "😢 Sadness": [
-            {"Title": "Talk to a Professional 💬", "Link": "https://www.betterhelp.com/"},
-            {"Title": "Mental Health Toolkit 🛠️", "Link": "https://www.psychologytoday.com/"},
+    suggestions = {
+        'joy': [
+            {"Title": "Relaxation Techniques 🌿", "Subject": "Relaxation", "Link": '<a href="https://www.helpguide.org/mental-health/meditation/mindful-breathing-meditation" target="_blank">Mindful Breathing Meditation</a>'},
+            {"Title": "Dealing with Stress 💆", "Subject": "Stress Management", "Link": '<a href="https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety" target="_blank">Tips for Dealing with Anxiety</a>'},
+            {"Title": "Emotional Wellness Toolkit 💪", "Subject": "Wellness", "Link": '<a href="https://www.nih.gov/health-information/emotional-wellness-toolkit" target="_blank">Emotional Wellness Toolkit</a>'},
+            {"Title": "Relaxation Video 🎥", "Subject": "Video", "Link": '<a href="https://youtu.be/m1vaUGtyo-A" target="_blank">Watch Video</a>'}
         ],
-        "😠 Anger": [
-            {"Title": "Anger Management Tips 🔥", "Link": "https://www.mentalhealth.org.uk"},
-            {"Title": "Stress Relieving Exercises 🌿", "Link": "https://www.calm.com/"},
+        'anger': [
+            {"Title": "Emotional Wellness Toolkit 💡", "Subject": "Wellness", "Link": '<a href="https://www.nih.gov/health-information/emotional-wellness-toolkit" target="_blank">Emotional Wellness Toolkit</a>'},
+            {"Title": "Stress Management Tips 🧘", "Subject": "Stress Management", "Link": '<a href="https://www.health.harvard.edu/health-a-to-z" target="_blank">Harvard Health: Stress Management</a>'},
+            {"Title": "Dealing with Anger 💥", "Subject": "Anger Management", "Link": '<a href="https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety" target="_blank">Tips for Dealing with Anger</a>'},
+            {"Title": "Relaxation Video 🎬", "Subject": "Video", "Link": '<a href="https://youtu.be/MIc299Flibs" target="_blank">Watch Video</a>'}
         ],
+        # Add more suggestions for other emotions as required...
     }
-    return suggestions_map.get(emotion, [{"Title": "General Wellness Resources 🌈", "Link": "https://www.helpguide.org/wellness"}])
-
-# Nearby Professionals Function
-def search_nearby_professionals(location, query):
-    """Returns a list of professionals as a list of lists for compatibility with DataFrame."""
-    if location and query:
-        results = [
-            {"Name": "Wellness Center", "Address": "123 Wellness Way"},
-            {"Name": "Mental Health Clinic", "Address": "456 Recovery Road"},
-            {"Name": "Therapy Hub", "Address": "789 Peace Avenue"},
-        ]
-        return [[item["Name"], item["Address"]] for item in results]
-    return []
-
-# Main App Logic
-def well_being_app(user_input, location, query, history):
-    history, _ = chatbot_response(user_input, history)
-    emotion = detect_emotion(user_input)
-    sentiment = analyze_sentiment(user_input)
-    emotion_name = emotion.split(": ")[-1]
-    suggestions = generate_suggestions(emotion_name)
-    suggestions_df = pd.DataFrame(suggestions)
-    professionals = search_nearby_professionals(location, query)
-    return history, sentiment, emotion, suggestions_df, professionals
-
-# Gradio Interface
-with gr.Blocks() as interface:
-    gr.Markdown("## 🌱 Well-being Companion")
-    gr.Markdown("> Empowering Your Mental Health! 💚")
-
-    with gr.Row():
-        user_input = gr.Textbox(label="Your Message")
-        location_input = gr.Textbox(label="Location")
-        query_input = gr.Textbox(label="Search Query")
-        submit_button = gr.Button("Submit")
-
-    chatbot_output = gr.Chatbot(label="Chatbot Interaction", type="messages", value=[])
-    sentiment_output = gr.Textbox(label="Sentiment Analysis")
-    emotion_output = gr.Textbox(label="Emotion Detected")
-    suggestions_output = gr.DataFrame(label="Suggestions", value=[], headers=["Title", "Link"])
-    nearby_professionals_output = gr.DataFrame(label="Nearby Professionals", headers=["Name", "Address"])
-
-    submit_button.click(
-        well_being_app,
-        inputs=[user_input, location_input, query_input, chatbot_output],
-        outputs=[
-            chatbot_output,
-            sentiment_output,
-            emotion_output,
-            suggestions_output,
-            nearby_professionals_output,
-        ],
-    )
 
-interface.launch()
+    return suggestions.get(emotion, [])
+
+# Gradio interface
+def gradio_app(message, location, health_query, submit_button, history, state):
+    if submit_button:
+        # Chatbot interaction
+        history, _ = chatbot(message, history)
+        
+        # Sentiment analysis
+        sentiment_response = analyze_sentiment(message)
+        
+        # Emotion detection
+        emotion_response = detect_emotion(message)
+        
+        # Health professional search and map display
+        route_info, map_html = get_health_professionals_and_map(location, health_query)
+        
+        # Generate suggestions based on the detected emotion
+        suggestions = generate_suggestions(emotion_response.split(': ')[1])
+        
+        # Create a DataFrame for displaying suggestions
+        suggestions_df = pd.DataFrame(suggestions)
+        
+        return history, sentiment_response, emotion_response, route_info, map_html, gr.DataFrame(suggestions_df, headers=["Title", "Subject", "Link"]), state
+    else:
+        return history, "", "", "", "", gr.DataFrame([], headers=["Title", "Subject", "Link"]), state
+
+# Gradio UI components
+message_input = gr.Textbox(lines=1, label="💬 Message")
+location_input = gr.Textbox(value="Honolulu, HI", label="📍 Current Location")
+health_query_input = gr.Textbox(value="doctor", label="🩺 Health Professional Query (e.g., doctor, psychiatrist, psychologist)")
+submit_button = gr.Button("🚀 Submit")
+
+# Updated chat history component with 'messages' type
+chat_history = gr.Chatbot(label="Well-Being Chat History", type='messages')
+
+# Outputs
+sentiment_output = gr.Textbox(label="💬 Sentiment Analysis Result")
+emotion_output = gr.Textbox(label="😊 Emotion Detection Result")
+route_info_output = gr.Textbox(label="🩺 Health Professionals Information")
+map_output = gr.HTML(label="🗺️ Map with Health Professionals")
+suggestions_output = gr.DataFrame(label="📝 Well-Being Suggestions", headers=["Title", "Subject", "Link"])
+
+# Create Gradio interface with custom CSS for gradient background
+css = """
+body {
+    background: linear-gradient(to right, #6ab04c, #34e89e);
+    font-family: Arial, sans-serif;
+}
+"""
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=gradio_app, 
+    inputs=[message_input, location_input, health_query_input, submit_button, gr.State()],
+    outputs=[chat_history, sentiment_output, emotion_output, route_info_output, map_output, suggestions_output, gr.State()],
+    allow_flagging="never",
+    live=False,
+    title="Well-Being App: Support, Sentiment, Emotion Detection & Health Professional Search",
+    css=css
+)
+
+# Launch the Gradio interface
+iface.launch()