Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import nltk | |
| import numpy as np | |
| import tflearn | |
| import random | |
| import json | |
| import pickle | |
| import torch | |
| from nltk.tokenize import word_tokenize | |
| from nltk.stem.lancaster import LancasterStemmer | |
| from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline | |
| import requests | |
| import pandas as pd | |
| import os | |
| # Ensure necessary NLTK resources are downloaded | |
| nltk.download('punkt') | |
| # Initialize the stemmer | |
| stemmer = LancasterStemmer() | |
| # Load intents.json | |
| try: | |
| with open("intents.json") as file: | |
| data = json.load(file) | |
| except FileNotFoundError: | |
| raise FileNotFoundError("Error: 'intents.json' file not found. Ensure it exists in the current directory.") | |
| # Load preprocessed data from pickle | |
| try: | |
| with open("data.pickle", "rb") as f: | |
| words, labels, training, output = pickle.load(f) | |
| except FileNotFoundError: | |
| raise FileNotFoundError("Error: 'data.pickle' file not found. Ensure it exists and matches the model.") | |
| # Build the model structure | |
| 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) | |
| try: | |
| model.load("MentalHealthChatBotmodel.tflearn") | |
| except FileNotFoundError: | |
| raise FileNotFoundError("Error: Trained model file 'MentalHealthChatBotmodel.tflearn' not found.") | |
| # Function to process user input into a bag-of-words format | |
| 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 (Chatbot) | |
| def chat(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 | |
| 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 | |
| tokenizer_emotion = AutoTokenizer.from_pretrained("j-hartmann/emotion-english-distilroberta-base") | |
| model_emotion = AutoModelForSequenceClassification.from_pretrained("j-hartmann/emotion-english-distilroberta-base") | |
| pipe = pipeline("text-classification", model=model_emotion, tokenizer=tokenizer_emotion) | |
| def detect_emotion(user_input): | |
| result = pipe(user_input) | |
| emotion = result[0]['label'] | |
| return emotion | |
| def provide_suggestions(emotion): | |
| suggestions = pd.DataFrame(columns=["Subject", "Article URL", "Video URL"]) | |
| if emotion == 'joy': | |
| suggestions = suggestions.append({ | |
| "Subject": "Relaxation Techniques", | |
| "Article URL": "https://www.helpguide.org/mental-health/meditation/mindful-breathing-meditation", | |
| "Video URL": "https://youtu.be/m1vaUGtyo-A" | |
| }, ignore_index=True) | |
| suggestions = suggestions.append({ | |
| "Subject": "Dealing with Stress", | |
| "Article URL": "https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety", | |
| "Video URL": "https://youtu.be/MIc299Flibs" | |
| }, ignore_index=True) | |
| elif emotion == 'anger': | |
| suggestions = suggestions.append({ | |
| "Subject": "Managing Anger", | |
| "Article URL": "https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety", | |
| "Video URL": "https://youtu.be/MIc299Flibs" | |
| }, ignore_index=True) | |
| elif emotion == 'fear': | |
| suggestions = suggestions.append({ | |
| "Subject": "Coping with Anxiety", | |
| "Article URL": "https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety", | |
| "Video URL": "https://youtu.be/yGKKz185M5o" | |
| }, ignore_index=True) | |
| elif emotion == 'sadness': | |
| suggestions = suggestions.append({ | |
| "Subject": "Dealing with Sadness", | |
| "Article URL": "https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety", | |
| "Video URL": "https://youtu.be/-e-4Kx5px_I" | |
| }, ignore_index=True) | |
| elif emotion == 'surprise': | |
| suggestions = suggestions.append({ | |
| "Subject": "Managing Stress", | |
| "Article URL": "https://www.health.harvard.edu/health-a-to-z", | |
| "Video URL": "https://youtu.be/m1vaUGtyo-A" | |
| }, ignore_index=True) | |
| return suggestions | |
| # Google Places API integration | |
| api_key = os.environ.get("GOOGLE_API_KEY") # Get API key from environment variable | |
| url = "https://maps.googleapis.com/maps/api/place/textsearch/json" | |
| places_details_url = "https://maps.googleapis.com/maps/api/place/details/json" | |
| def get_places_data(query, location, radius, api_key, next_page_token=None): | |
| params = { | |
| "query": query, | |
| "location": location, | |
| "radius": radius, | |
| "key": api_key | |
| } | |
| if next_page_token: | |
| params["pagetoken"] = next_page_token | |
| response = requests.get(url, params=params) | |
| return response.json() if response.status_code == 200 else None | |
| def get_place_details(place_id, api_key): | |
| params = { | |
| "place_id": place_id, | |
| "key": api_key | |
| } | |
| response = requests.get(places_details_url, params=params) | |
| if response.status_code == 200: | |
| details_data = response.json().get("result", {}) | |
| return { | |
| "opening_hours": details_data.get("opening_hours", {}).get("weekday_text", "Not available"), | |
| "reviews": details_data.get("reviews", "Not available"), | |
| "phone_number": details_data.get("formatted_phone_number", "Not available"), | |
| "website": details_data.get("website", "Not available") | |
| } | |
| else: | |
| return {} | |
| def get_all_places(query, location, radius, api_key): | |
| all_results = [] | |
| next_page_token = None | |
| while True: | |
| data = get_places_data(query, location, radius, api_key, next_page_token) | |
| if data: | |
| results = data.get('results', []) | |
| for place in results: | |
| place_id = place.get("place_id", "N/A") # Handle missing place_id | |
| name = place.get("name", "N/A") # Handle missing name | |
| address = place.get("formatted_address", "N/A") # Handle missing address | |
| website = place.get("website", "Not available") | |
| details = get_place_details(place_id, api_key) if place_id != "N/A" else {} #Avoid error if place_id is missing | |
| phone_number = details.get("phone_number", "Not available") | |
| all_results.append([name, address, phone_number, website]) | |
| next_page_token = data.get('next_page_token') | |
| if not next_page_token: | |
| break | |
| else: | |
| break | |
| return all_results | |
| def search_wellness_professionals(location): | |
| query = "therapist OR counselor OR mental health professional" | |
| radius = 50000 | |
| try: | |
| google_places_data = get_all_places(query, location, radius, api_key) | |
| if google_places_data: | |
| df = pd.DataFrame(google_places_data, columns=["Name", "Address", "Phone", "Website"]) | |
| return df | |
| else: | |
| return pd.DataFrame([["No data found.", "", "", ""]], columns=["Name", "Address", "Phone", "Website"]) | |
| except Exception as e: | |
| return pd.DataFrame([["Error fetching data: " + str(e), "", "", ""]], columns=["Name", "Address", "Phone", "Website"]) | |
| # Gradio Interface | |
| def gradio_interface(message, location, state): | |
| history = state or [] # If state is None, initialize it as an empty list | |
| # Stage 1: Mental Health Chatbot | |
| history, _ = chat(message, history) | |
| # Stage 2: Sentiment Analysis | |
| sentiment = analyze_sentiment(message) | |
| # Stage 3: Emotion Detection and Suggestions | |
| emotion = detect_emotion(message) | |
| suggestions = provide_suggestions(emotion) | |
| # Stage 4: Search for Wellness Professionals | |
| try: | |
| wellness_results = search_wellness_professionals(location) | |
| except Exception as e: | |
| wellness_results = pd.DataFrame([["Error: " + str(e), "", "", ""]], columns=["Name", "Address", "Phone", "Website"]) | |
| # Return the results in a tabular form within the Gradio interface | |
| return history, sentiment, emotion, suggestions, wellness_results, history # Last 'history' is for state | |
| # Gradio interface setup | |
| iface = gr.Interface( | |
| fn=gradio_interface, | |
| inputs=[ | |
| gr.Textbox(label="Enter your message", placeholder="How are you feeling today?"), | |
| gr.Textbox(label="Enter your location (e.g., 'Hawaii, USA')", placeholder="Enter your location"), | |
| gr.State() # To maintain state (chat history) | |
| ], | |
| outputs=[ | |
| gr.Chatbot(label="Chatbot Responses"), | |
| gr.Textbox(label="Sentiment Analysis"), | |
| gr.Textbox(label="Emotion Detected"), | |
| gr.DataFrame(label="Suggested Articles & Videos"), | |
| gr.DataFrame(label="Nearby Wellness Professionals"), | |
| gr.State() # To maintain state (chat history) | |
| ], | |
| live=True, | |
| title="Mental Health Chatbot with Wellness Professional Search", | |
| description="This chatbot provides mental health support with sentiment analysis, emotion detection, suggestions, and a list of nearby wellness professionals." | |
| ) | |
| # Check for API key; if not found, print an error message | |
| if api_key is None: | |
| print("Error: GOOGLE_MAPS_API_KEY environment variable not set. Please set this environment variable with your Google Maps API key.") | |
| # Launch the interface | |
| iface.launch(debug=True, share=True) | |