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 tempfile | |
| # 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 to get nearby wellness professionals | |
| api_key = "YOUR_GOOGLE_API_KEY" # Replace with your API key | |
| def get_places_data(query, location, radius, api_key, next_page_token=None): | |
| url = "https://maps.googleapis.com/maps/api/place/textsearch/json" | |
| 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_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") | |
| name = place.get("name") | |
| address = place.get("formatted_address") | |
| website = place.get("website", "Not available") | |
| all_results.append([name, address, 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 | |
| google_places_data = get_all_places(query, location, radius, api_key) | |
| if google_places_data: | |
| df = pd.DataFrame(google_places_data, columns=["Name", "Address", "Website"]) | |
| return df | |
| else: | |
| return pd.DataFrame([["No data found.", "", ""]], columns=["Name", "Address", "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 | |
| wellness_results = search_wellness_professionals(location) | |
| # Return the 6 values required by Gradio | |
| 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, Oahu)", placeholder="Your location"), | |
| gr.State() # One state input | |
| ], | |
| outputs=[ | |
| gr.Chatbot(label="Chat History"), | |
| gr.Textbox(label="Sentiment Analysis"), | |
| gr.Textbox(label="Detected Emotion"), | |
| gr.Dataframe(label="Suggestions & Resources"), | |
| gr.File(label="Download Wellness Professionals CSV"), | |
| gr.State() # One state output | |
| ], | |
| allow_flagging="never", | |
| title="Mental Wellbeing App with AI Assistance", | |
| description="This app provides a mental health chatbot, sentiment analysis, emotion detection, and wellness professional search functionality.", | |
| ) | |
| # Launch Gradio interface | |
| if __name__ == "__main__": | |
| iface.launch(debug=True, share=True) # Set share=True to create a public link | |