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 re | |
| from bs4 import BeautifulSoup | |
| import time | |
| import pandas as pd | |
| from selenium import webdriver | |
| from selenium.webdriver.chrome.options import Options | |
| import chromedriver_autoinstaller | |
| 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 | |
| def chat(message, history, state): | |
| 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?" | |
| history.append((message, response)) | |
| # Update state to move to the next feature | |
| state['step'] = 2 # Move to sentiment analysis | |
| except Exception as e: | |
| response = f"An error occurred: {str(e)}" | |
| return history, history, state | |
| # Load pre-trained model and tokenizer for sentiment analysis | |
| tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment") | |
| sentiment_model = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment") | |
| # Function for sentiment analysis | |
| def analyze_sentiment(text, state): | |
| inputs = tokenizer(text, return_tensors="pt") | |
| with torch.no_grad(): | |
| outputs = sentiment_model(**inputs) | |
| predicted_class = torch.argmax(outputs.logits, dim=1).item() | |
| sentiment = ["Negative", "Neutral", "Positive"][predicted_class] | |
| # Update state to move to the next feature | |
| state['step'] = 3 # Move to emotion detection and suggestions | |
| return sentiment, state | |
| # Load pre-trained model and tokenizer for emotion detection | |
| emotion_tokenizer = AutoTokenizer.from_pretrained("j-hartmann/emotion-english-distilroberta-base") | |
| emotion_model = AutoModelForSequenceClassification.from_pretrained("j-hartmann/emotion-english-distilroberta-base") | |
| # Function for emotion detection | |
| def detect_emotion(text, state): | |
| pipe = pipeline("text-classification", model=emotion_model, tokenizer=emotion_tokenizer) | |
| result = pipe(text) | |
| emotion = result[0]['label'] | |
| # Provide suggestions based on emotion | |
| suggestions = provide_suggestions(emotion) | |
| # Update state to move to the next feature | |
| state['step'] = 4 # Move to wellness professional search | |
| return emotion, suggestions, state | |
| # Suggestions based on detected emotion | |
| def provide_suggestions(emotion): | |
| if emotion == 'joy': | |
| return "You're feeling happy! Keep up the great mood!" | |
| elif emotion == 'anger': | |
| return "You're feeling angry. It's okay to feel this way. Let's try to calm down." | |
| elif emotion == 'fear': | |
| return "You're feeling fearful. Take deep breaths, everything will be okay." | |
| elif emotion == 'sadness': | |
| return "You're feeling sad. It's okay, things will get better. You're not alone." | |
| else: | |
| return "Sorry, no suggestions available for this emotion." | |
| # Function to find wellness professionals | |
| def find_wellness_professionals(location, state): | |
| query = "therapist OR counselor OR mental health professional OR marriage and family therapist OR psychotherapist OR psychiatrist OR psychologist in " + location | |
| api_key = "YOUR_GOOGLE_API_KEY" # Replace with your own API key | |
| location_coords = "21.3,-157.8" # Default to Oahu, Hawaii | |
| radius = 50000 # 50 km radius | |
| google_places_data = get_all_places(query, location_coords, radius, api_key) | |
| if google_places_data: | |
| df = pd.DataFrame(google_places_data, columns=[ | |
| "Name", "Address", "Phone", "Rating", "Business Status", | |
| "User Ratings Total", "Website", "Types", "Latitude", "Longitude", | |
| "Opening Hours", "Reviews", "Email" | |
| ]) | |
| return df, state | |
| else: | |
| return pd.DataFrame(), state | |
| # The functions for scraping websites and fetching details | |
| 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") | |
| rating = place.get("rating", "Not available") | |
| business_status = place.get("business_status", "Not available") | |
| user_ratings_total = place.get("user_ratings_total", "Not available") | |
| website = place.get("website", "Not available") | |
| types = ", ".join(place.get("types", [])) | |
| location = place.get("geometry", {}).get("location", {}) | |
| latitude = location.get("lat", "Not available") | |
| longitude = location.get("lng", "Not available") | |
| details = get_place_details(place_id, api_key) | |
| phone_number = details.get("phone_number", "Not available") | |
| email = details.get("email", "Not available") | |
| all_results.append([name, address, phone_number, rating, business_status, | |
| user_ratings_total, website, types, latitude, longitude, | |
| details.get("opening_hours", "Not available"), | |
| details.get("reviews", "Not available"), email]) | |
| next_page_token = data.get('next_page_token') | |
| if not next_page_token: | |
| break | |
| time.sleep(2) | |
| return all_results | |
| # Gradio interface | |
| with gr.Blocks() as demo: | |
| gr.Markdown("# Wellbeing Support System") | |
| state = gr.State({"step": 1}) # Track the flow step | |
| with gr.Tab("Chatbot"): | |
| chatbot = gr.Chatbot() | |
| msg = gr.Textbox() | |
| clear = gr.Button("Clear") | |
| msg.submit(chat, inputs=[msg, chatbot, state], outputs=[chatbot, chatbot, state]) | |
| clear.click(lambda: None, None, chatbot) | |
| with gr.Tab("Sentiment Analysis"): | |
| sentiment_output = gr.Textbox(label="Sentiment:") | |
| text_input = gr.Textbox(label="Enter text to analyze sentiment:") | |
| analyze_button = gr.Button("Analyze Sentiment") | |
| analyze_button.click(analyze_sentiment, inputs=[text_input, state], outputs=[sentiment_output, state]) | |
| with gr.Tab("Emotion Detection & Suggestions"): | |
| emotion_input = gr.Textbox(label="How are you feeling today?", value="Enter your thoughts here...") | |
| detect_button = gr.Button("Detect Emotion") | |
| emotion_output = gr.Textbox(label="Detected Emotion:") | |
| suggestions_output = gr.Textbox(label="Suggestions:") | |
| detect_button.click(detect_emotion, inputs=[emotion_input, state], outputs=[emotion_output, suggestions_output, state]) | |
| with gr.Tab("Find Local Wellness Professionals"): | |
| location_input = gr.Textbox(label="Enter your location:", value="Hawaii") | |
| search_button = gr.Button("Search") | |
| results_output = gr.Dataframe(label="Search Results") | |
| search_button.click(find_wellness_professionals, inputs=[location_input, state], outputs=[results_output, state]) | |
| demo.launch() | |