import gradio as gr
import pandas as pd
import nltk
import numpy as np
import tflearn
import random
import json
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 os
import base64
import torch # Added missing import for torch
# Disable GPU usage for TensorFlow
os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
# Ensure necessary NLTK resources are downloaded
nltk.download('punkt')
# Initialize the stemmer
stemmer = LancasterStemmer()
# Load intents.json for Well-Being Chatbot
with open("intents.json") as file:
data = json.load(file)
# Load preprocessed data for Well-Being 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)
# Load the trained model
model = tflearn.DNN(net)
model.load("MentalHealthChatBotmodel.tflearn")
# 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.lower() in words]
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):
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:
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})
history.append({"role": "assistant", "content": response})
return history, history
# 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 = 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}"
# 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")
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):
try:
location = gmaps.geocode(current_location)
if not location:
return "Location not found. Please try again with a valid 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
except googlemaps.exceptions.HTTPError as e:
return f"Error occurred with Google Maps API: {e}", ""
except Exception as e:
return f"Unexpected error: {str(e)}", ""
# Function to generate suggestions based on the detected emotion
def generate_suggestions(emotion):
suggestions = {
'joy': [
{"Title": "Relaxation Techniques", "Subject": "Relaxation", "Link": 'Mindful Breathing Meditation'},
{"Title": "Dealing with Stress", "Subject": "Stress Management", "Link": 'Tips for Dealing with Anxiety'},
{"Title": "Emotional Wellness Toolkit", "Subject": "Wellness", "Link": 'Emotional Wellness Toolkit'},
{"Title": "Relaxation Video", "Subject": "Video", "Link": 'Watch Video'}
],
'anger': [
{"Title": "Emotional Wellness Toolkit", "Subject": "Wellness", "Link": 'Emotional Wellness Toolkit'},
{"Title": "Stress Management Tips", "Subject": "Stress Management", "Link": 'Harvard Health: Stress Management'},
{"Title": "Dealing with Anger", "Subject": "Anger Management", "Link": 'Tips for Dealing with Anger'},
{"Title": "Relaxation Video", "Subject": "Video", "Link": 'Watch Video'}
],
'fear': [
{"Title": "Mindfulness Practices", "Subject": "Mindfulness", "Link": 'Mindful Breathing Meditation'},
{"Title": "Coping with Anxiety", "Subject": "Anxiety Management", "Link": 'Tips for Dealing with Anxiety'},
{"Title": "Emotional Wellness Toolkit", "Subject": "Wellness", "Link": 'Emotional Wellness Toolkit'},
{"Title": "Relaxation Video", "Subject": "Video", "Link": 'Watch Video'}
]
}
emotion_suggestions = suggestions.get(emotion, [])
return pd.DataFrame(emotion_suggestions)
# Custom CSS styling for Gradio interface
css = """
body {
font-family: 'Arial', sans-serif;
}
.gradio-container {
background-color: #f7f7f7;
}
.gradio-input, .gradio-output {
padding: 10px;
border-radius: 5px;
background-color: #fff;
border: 1px solid #ccc;
}
.gradio-container .gradio-button {
background-color: #4CAF50;
color: white;
border-radius: 5px;
}
.gradio-container .gradio-button:hover {
background-color: #45a049;
}
.gradio-output {
font-size: 16px;
color: #333;
}
.gradio-container h3 {
color: #333;
}
.gradio-output .output {
border-top: 2px solid #ddd;
}
"""
# 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)
# 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)
return sentiment, 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)