Update app.py

app.py

@@ -1,32 +1,33 @@
-import gradio as gr
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
-import json
-import pickle
-import random
-import pandas as pd
-import requests
 import nltk
-from nltk.stem import LancasterStemmer
 import numpy as np
-import tensorflow as tf
-from bs4 import BeautifulSoup
 import tflearn
+import tensorflow
+import random
+import json
+import pickle
+import gradio as gr
+from nltk.tokenize import word_tokenize
+from nltk.stem.lancaster import LancasterStemmer
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
+import googlemaps
+import folium
+import os
 
-# Download necessary NLTK resources
+# Ensure necessary NLTK resources are downloaded
 nltk.download('punkt')
 
 # Initialize the stemmer
 stemmer = LancasterStemmer()
 
-# Load intents.json
+# Load intents.json for Mental Health Chatbot
 with open("intents.json") as file:
     data = json.load(file)
 
-# Load preprocessed data from pickle
+# Load preprocessed data for Mental Health Chatbot
 with open("data.pickle", "rb") as f:
     words, labels, training, output = pickle.load(f)
 
-# Build the model structure
+# Build the model structure for Mental Health Chatbot
 net = tflearn.input_data(shape=[None, len(training[0])])
 net = tflearn.fully_connected(net, 8)
 net = tflearn.fully_connected(net, 8)
@@ -37,20 +38,10 @@ net = tflearn.regression(net)
 model = tflearn.DNN(net)
 model.load("MentalHealthChatBotmodel.tflearn")
 
-# Sentiment analysis
-tokenizer_sentiment = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
-model_sentiment = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
-sentiment_pipeline = pipeline("sentiment-analysis")
-
-# Emotion detection
-tokenizer_emotion = AutoTokenizer.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
-model_emotion = AutoModelForSequenceClassification.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
-emotion_pipeline = pipeline("text-classification", model=model_emotion, tokenizer=tokenizer_emotion)
-
-# Function to process user input into a bag-of-words format
+# 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 = nltk.word_tokenize(s)
+    s_words = word_tokenize(s)
     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):
@@ -58,108 +49,135 @@ def bag_of_words(s, words):
                 bag[i] = 1
     return np.array(bag)
 
-# Function to generate recommendations based on emotion
-def generate_recommendations(emotion):
-    if emotion == 'joy':
-        return [
-            {"title": "Mindful Breathing Meditation", "link": "https://www.example.com/joy"},
-            {"title": "Dealing with Stress", "link": "https://www.example.com/stress"},
-            {"title": "Emotional Wellness Toolkit", "link": "https://www.example.com/wellness"}
-        ]
-    elif emotion == 'anger':
-        return [
-            {"title": "Anger Management Techniques", "link": "https://www.example.com/anger"},
-            {"title": "Stress Management Tips", "link": "https://www.example.com/stress"},
-            {"title": "Dealing with Anger", "link": "https://www.example.com/dealing_with_anger"}
-        ]
-    # Add more cases for other emotions
-    else:
-        return []
-
-# Function to fetch nearby health professionals
-def fetch_nearby_health_professionals(location):
-    # Placeholder for fetching nearby health professionals
-    # Actual implementation depends on the API used and should replace the placeholder data
-    return pd.DataFrame([
-        {'Name': 'Dr. Jane Smith', 'Address': '123 Wellness St.', 'Phone': '555-1234'},
-        {'Name': 'Dr. John Doe', 'Address': '456 Health Rd.', 'Phone': '555-5678'}
-    ])
-
-# Function to detect emotion and provide suggestions
-def detect_emotion_and_suggest(text):
-    pipe = pipeline("text-classification", model=model_emotion, tokenizer=tokenizer_emotion)
-    result = pipe(text)
-    emotion = result[0]['label']
-
-    # Prepare suggestions based on the detected emotion
-    suggestions = ""
-    relaxation_videos = ""
-    if emotion == 'joy':
-        suggestions = "You're feeling happy! Keep up the great mood!\n\nUseful Resources:\n- Relaxation Techniques: [Link](https://www.example.com/joy)\n- Dealing with Stress: [Link](https://www.example.com/stress)\n- Emotional Wellness Toolkit: [Link](https://www.example.com/wellness)"
-        relaxation_videos = "Relaxation Videos:\n- Watch on YouTube: [Link](https://youtu.be/m1vaUGtyo-A)"
-
-    elif emotion == 'anger':
-        suggestions = "You're feeling angry. It's okay to feel this way. Let's try to calm down.\n\nUseful Resources:\n- Emotional Wellness Toolkit: [Link](https://www.example.com/anger)\n- Stress Management Tips: [Link](https://www.example.com/stress)\n- Dealing with Anger: [Link](https://www.example.com/dealing_with_anger)"
-        relaxation_videos = "Relaxation Videos:\n- Watch on YouTube: [Link](https://youtu.be/MIc299Flibs)"
-
-    elif emotion == 'fear':
-        suggestions = "You're feeling fearful. Take a moment to breathe and relax.\n\nUseful Resources:\n- Mindfulness Practices: [Link](https://www.example.com/fear)\n- Coping with Anxiety: [Link](https://www.example.com/anxiety)\n- Emotional Wellness Toolkit: [Link](https://www.example.com/wellness)"
-        relaxation_videos = "Relaxation Videos:\n- Watch on YouTube: [Link](https://youtu.be/yGKKz185M5o)"
-
-    elif emotion == 'sadness':
-        suggestions = "You're feeling sad. It's okay to take a break.\n\nUseful Resources:\n- Emotional Wellness Toolkit: [Link](https://www.example.com/sadness)\n- Dealing with Anxiety: [Link](https://www.example.com/anxiety)"
-        relaxation_videos = "Relaxation Videos:\n- Watch on YouTube: [Link](https://youtu.be/-e-4Kx5px_I)"
+# Chat function for Mental Health Chatbot
+def chatbot(message, 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)
+                break
+        else:
+            response = "I'm sorry, I didn't understand that. Could you please rephrase?"
+    except Exception as e:
+        response = f"An error occurred: {str(e)}"
+    
+    history.append((message, response))
+    return history, history
+
+
+# Sentiment Analysis using Hugging Face model
+tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
+model_sentiment = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
 
-    elif emotion == 'surprise':
-        suggestions = "You're feeling surprised. It's okay to feel neutral!\n\nUseful Resources:\n- Managing Stress: [Link](https://www.example.com/surprise)\n- Coping Strategies: [Link](https://www.example.com/coping)"
-        relaxation_videos = "Relaxation Videos:\n- Watch on YouTube: [Link](https://youtu.be/m1vaUGtyo-A)"
+def analyze_sentiment(user_input):
+    inputs = tokenizer(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}"
 
-    return emotion, suggestions, relaxation_videos
+# 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")
 
-# Gradio interface for emotion detection and suggestions
+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):
+    route_info = ""
+    m = None  # Default to None
+    try:
+        # Geocode the current location (i.e., convert it to latitude and longitude)
+        geocode_result = gmaps.geocode(current_location)
+        if not geocode_result:
+            route_info = "Could not retrieve location coordinates. Please enter a valid location."
+            return route_info, m
+        
+        location_coords = geocode_result[0]['geometry']['location']
+        lat, lon = location_coords['lat'], location_coords['lng']
+        
+        # Search for health professionals
+        health_professionals = search_health_professionals(health_professional_query, (lat, lon))
+        
+        if health_professionals:
+            route_info = "Health professionals found:\n"
+            m = folium.Map(location=[lat, lon], zoom_start=12)
+            for professional in health_professionals:
+                name = professional['name']
+                vicinity = professional.get('vicinity', 'N/A')
+                rating = professional.get('rating', 'N/A')
+                folium.Marker([professional['geometry']['location']['lat'], professional['geometry']['location']['lng']], 
+                              popup=f"{name}\n{vicinity}\nRating: {rating}").add_to(m)
+                route_info += f"- {name} ({rating} stars): {vicinity}\n"
+        else:
+            route_info = "No health professionals found matching your query."
+            m = folium.Map(location=[lat, lon], zoom_start=12)  # Default map if no professionals are found
+        
+    except Exception as e:
+        route_info = f"Error: {str(e)}"
+        m = folium.Map(location=[20, 0], zoom_start=2)  # Default map if any error occurs
+    
+    return route_info, m._repr_html_()
+
+# Gradio interface
+def gradio_app(message, location, health_query, history):
+    # 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)
+    
+    return history, sentiment_response, emotion_response, route_info, map_html
+
+# 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)")
+
+chat_history = gr.Chatbot(label="Chat History")
+
+# 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")
+
+# Create Gradio interface
 iface = gr.Interface(
-    fn=detect_emotion_and_suggest,
-    inputs="text",
-    outputs=[
-        "text",  # For displaying detected emotion
-        "markdown",  # For displaying suggestions
-        "markdown",  # For displaying relaxation videos
-    ],
-    title="Emotion Detection and Well-Being Suggestions",
-    description="Enter your thoughts below to detect your current emotion and receive personalized well-being suggestions.",
-)
-
-# Function to show a summary of the detected emotion and suggestions
-def show_summary(emotion, suggestions):
-    return f"**Emotion Detected:** {emotion}\n{suggestions}"
-
-# Gradio interface for showing summary
-summary_iface = gr.Interface(
-    fn=show_summary,
-    inputs=[
-        "text",  # For detected emotion
-        "text",  # For suggestions
-    ],
-    outputs="markdown",
-    title="Summary of Emotion and Suggestions",
-    description="Click the button to see a summary of your detected emotion and the suggested well-being resources.",
-)
-
-# Function to fetch and display nearby health professionals
-def fetch_and_display_health_professionals(location):
-    df = fetch_nearby_health_professionals(location)
-    return df
-
-# Gradio interface for fetching nearby health professionals
-health_professionals_iface = gr.Interface(
-    fn=fetch_and_display_health_professionals,
-    inputs="text",
-    outputs="dataframe",
-    title="Find Nearby Health Professionals",
-    description="Enter your location to find nearby health professionals.",
+    fn=gradio_app, 
+    inputs=[message_input, location_input, health_query_input, "state"], 
+    outputs=[chat_history, sentiment_output, emotion_output, route_info_output, map_output],
+    allow_flagging="never",
+    live=True,
+    title="Wellbeing App: Mental Health, Sentiment, Emotion Detection & Health Professional Search"
 )
 
-# Launch the Gradio interfaces
-iface.launch()
-summary_iface.launch()
-health_professionals_iface.launch()
+iface.launch()