Update app.py

app.py

@@ -18,6 +18,7 @@ import tflearn
 import tensorflow as tf
 import json
 import pickle
+import random
 
 # Ensure necessary NLTK resources are downloaded
 nltk.download('punkt')
@@ -42,195 +43,121 @@ try:
 except FileNotFoundError:
     raise FileNotFoundError("Error: 'data.pickle' file not found. Ensure it exists and matches the model.")
 
-# Define a PyTorch model with the same architecture as your tflearn model
-class PyTorchModel(nn.Module):
-    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_classes):
-        super(PyTorchModel, self).__init__()
-        self.embedding = nn.Embedding(vocab_size, embedding_dim)
-        self.fc1 = nn.Linear(embedding_dim, hidden_dim)
-        self.relu = nn.ReLU()
-        self.fc2 = nn.Linear(hidden_dim, num_classes)
-
-    def forward(self, x):
-        out = self.embedding(x)
-        out = torch.mean(out, dim=1)
-        out = self.fc1(out)
-        out = self.relu(out)
-        out = self.fc2(out)
-        return out
-
-# Convert the tflearn model to a PyTorch model
-vocab_size = len(words)
-embedding_dim = 128
-hidden_dim = 64
-num_classes = len(labels)
-
-# Load the TensorFlow model
-model_tf = tflearn.DNN(tflearn.input_data(shape=[None, len(training[0])]))
-model_tf.load("MentalHealthChatBotmodel.tflearn")
-
-# Convert the TensorFlow model to a PyTorch model
-pytorch_model = PyTorchModel(vocab_size, embedding_dim, hidden_dim, num_classes)
-
-# Load weights from the TensorFlow model
-layer_names = ['fc1/kernel', 'fc1/bias', 'fc2/kernel', 'fc2/bias']
-
-for layer_name in layer_names:
-    weight_tensor, bias_tensor = model_tf.get_weights(layer_name)
-    pytorch_layer_name = layer_name.replace('/', '_')
-    pytorch_model.state_dict()[f"{pytorch_layer_name}_weight"].copy_(torch.tensor(weight_tensor))
-    pytorch_model.state_dict()[f"{pytorch_layer_name}_bias"].copy_(torch.tensor(bias_tensor))
-
-# Move the model to the CPU
-pytorch_model.cpu()
-
-# Load tokenizer and model for sentiment analysis
+# 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 = nltk.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):
+    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 be 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")
+sentiment_pipeline = pipeline("sentiment-analysis")
 
-# Google Places API endpoint
-url = "https://maps.googleapis.com/maps/api/place/textsearch/json"
-places_details_url = "https://maps.googleapis.com/maps/api/place/details/json"
+def predict_sentiment(text):
+    result = sentiment_pipeline(text)[0]
+    return result['label']
 
-# Google Geocoding API endpoint
-geocoding_url = "https://maps.googleapis.com/maps/api/geocode/json"
+# 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)
 
-# Your actual Google API Key (replace with your key)
-api_key = "AIzaSyCcfJzMFfuv_1LN7JPTJJYw_aS0A_SLeW0"  # Replace with your own Google API key
+def predict_emotion(text):
+    result = emotion_pipeline(text)[0]
+    return result['label']
 
-# Search query for wellness professionals in Hawaii
-query = "therapist OR counselor OR mental health professional OR marriage and family therapist OR psychotherapist OR psychiatrist OR psychologist OR nutritionist OR wellness doctor OR holistic practitioner OR integrative medicine OR chiropractor OR naturopath in Hawaii"
+# Fetching nearby health professionals
+google_places_url = "https://maps.googleapis.com/maps/api/place/textsearch/json"
+google_geocoding_url = "https://maps.googleapis.com/maps/api/geocode/json"
 
-# Function to send a request to Google Places API and fetch places data
-def get_places_data(query, location, radius, api_key, next_page_token=None):
+def get_places_data(query, location, radius, api_key):
     params = {
         "query": query,
         "location": location,
         "radius": radius,
         "key": api_key
     }
+    response = requests.get(google_places_url, params=params)
+    return response.json()
 
-    if next_page_token:
-        params["pagetoken"] = next_page_token
-
-    response = requests.get(url, params=params)
-
-    if response.status_code == 200:
-        return response.json()
-    else:
-        return None
-
-# Function to fetch detailed information for a specific place using its place_id
 def get_place_details(place_id, api_key):
-    details_url = places_details_url
-    params = {
-        "place_id": place_id,
-        "key": api_key
-    }
-    response = requests.get(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 {}
-
-# Function to fetch all places data including pagination
-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', [])
-            if not results:
-                break
-
-            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_reviews_total = place.get("user_reviews_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")
-                if phone_number == "Not available" and website != "Not available":
-                    phone_number, email = scrape_div_for_contact_info(website)
-                else:
-                    email = "Not available"
-
-                if website == "Not available":
-                    website = scrape_div_from_google_maps(name)
-
-                all_results.append([name, address, phone_number, rating, business_status,
-                                    user_reviews_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)
-        else:
-            break
-
-    return all_results
+    details_url = f"https://maps.googleapis.com/maps/api/place/details/json?place_id={place_id}&fields=name,rating,formatted_phone_number&key={api_key}"
+    response = requests.get(details_url)
+    return response.json()
+
+def fetch_nearby_health_professionals(location):
+    api_key = "GOOGLE_API_KEY"  # Replace with your actual Google API key
+    query = "therapist OR counselor OR mental health professional OR marriage and family therapist OR psychotherapist OR psychiatrist OR psychologist OR nutritionist OR wellness doctor OR holistic practitioner OR integrative medicine OR chiropractor OR naturopath"
+    radius = 50000  # 50 km radius
+    
+    response = get_places_data(query, location, radius, api_key)
+    results = response.get('results', [])
+    
+    data = []
+    for place in results:
+        place_id = place['place_id']
+        place_details = get_place_details(place_id, api_key)
+        name = place_details.get('result', {}).get('name', 'N/A')
+        rating = place_details.get('result', {}).get('rating', 'N/A')
+        phone_number = place_details.get('result', {}).get('formatted_phone_number', 'N/A')
+        
+        data.append([name, rating, phone_number])
+    
+    return pd.DataFrame(data, columns=['Name', 'Rating', 'Phone Number'])
 
-# Function to save results to CSV file
+# Save results to CSV
 def save_to_csv(data, filename):
-    with open(filename, mode='w', newline='', encoding='utf-8') as file:
-        writer = csv.writer(file)
-        writer.writerow([
-            "Name", "Address", "Phone", "Rating", "Business Status",
-            "User Reviews Total", "Website", "Types", "Latitude", "Longitude",
-            "Opening Hours", "Reviews", "Email"
-        ])
-        writer.writerows(data)
-    print(f"Data saved to {filename}")
-
-# Geocoding function to convert location text to coordinates
-def geocode_location(address):
-    params = {
-        "address": address,
-        "key": api_key
-    }
-    response = requests.get(geocoding_url, params=params)
+    data.to_csv(filename, index=False)
 
-    if response.status_code == 200:
-        data = response.json()
-        if data['status'] == 'OK':
-            location = data['results'][0]['geometry']['location']
-            return location['lat'], location['lng']
-        else:
-            raise ValueError("Geocoding failed.")
-    else:
-        raise ValueError("Failed to retrieve geocoding data.")
-
-# Main function to execute script
-def main():
-    google_places_data = get_all_places(query, location, radius, api_key)
-    if google_places_data:
-        save_to_csv(google_places_data, "wellness_professionals_hawaii.csv")
-    else:
-        print("No data found.")
-
-# Gradio UI setup
+# Gradio interface
 with gr.Blocks() as demo:
-    # Display header
-    gr.Markdown("# Emotion Detection and Well-Being Suggestions")
+    gr.Markdown("# Mental Health Assistant")
 
     # User input for text (emotion detection)
     user_input_emotion = gr.Textbox(lines=1, label="How are you feeling today?")
@@ -238,32 +165,27 @@ with gr.Blocks() as demo:
 
     # Model prediction for emotion detection
     def predict_emotion(text):
-        inputs = tokenizer_sentiment(text, return_tensors="pt").to('cpu')
-        with torch.no_grad():
-            outputs = pytorch_model(inputs['input_ids'])
-        _, predicted_class = torch.max(outputs, dim=1)
-        emotion = labels[predicted_class.item()]
-        return emotion
+        return predict_emotion(text)
 
     # Show suggestions based on the detected emotion
     def show_suggestions(emotion):
         if emotion == 'joy':
-            return "You're feeling happy! Keep up the great mood!\nUseful Resources:\n[Relaxation Techniques](https://www.helpguide.org/mental-health/meditation/mindful-breathing-meditation)\n[Dealing with Stress](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)\n[Emotional Wellness Toolkit](https://www.nih.gov/health-information/emotional-wellness-toolkit)\n\nRelaxation Videos:\n[Watch on YouTube](https://youtu.be/m1vaUGtyo-A)"
+            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.\nUseful Resources:\n[Emotional Wellness Toolkit](https://www.nih.gov/health-information/emotional-wellness-toolkit)\n[Stress Management Tips](https://www.health.harvard.edu/health-a-to-z)\n[Dealing with Anger](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)\n\nRelaxation Videos:\n[Watch on YouTube](https://youtu.be/MIc299Flibs)"
+            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 a moment to breathe and relax.\nUseful Resources:\n[Mindfulness Practices](https://www.helpguide.org/mental-health/meditation/mindful-breathing-meditation)\n[Coping with Anxiety](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)\n[Emotional Wellness Toolkit](https://www.nih.gov/health-information/emotional-wellness-toolkit)\n\nRelaxation Videos:\n[Watch on YouTube](https://youtu.be/yGKKz185M5o)"
+            return "You're feeling fearful. Take a moment to breathe and relax."
         elif emotion == 'sadness':
-            return "You're feeling sad. It's okay to take a break.\nUseful Resources:\n[Emotional Wellness Toolkit](https://www.nih.gov/health-information/emotional-wellness-toolkit)\n[Dealing with Anxiety](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)\n\nRelaxation Videos:\n[Watch on YouTube](https://youtu.be/-e-4Kx5px_I)"
+            return "You're feeling sad. It's okay to take a break."
         elif emotion == 'surprise':
-            return "You're feeling surprised. It's okay to feel neutral!\nUseful Resources:\n[Managing Stress](https://www.health.harvard.edu/health-a-to-z)\n[Coping Strategies](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)\n\nRelaxation Videos:\n[Watch on YouTube](https://youtu.be/m1vaUGtyo-A)"
+            return "You're feeling surprised. It's okay to feel neutral!"
 
     emotion_output = gr.Textbox(label="Emotion Detected")
     submit_emotion.click(predict_emotion, inputs=user_input_emotion, outputs=emotion_output)
 
     # Button for summary
     def show_summary(emotion):
-        return f"Emotion Detected: {emotion}\nUseful Resources based on your mood:\n{show_suggestions(emotion)}"
+        return f"Emotion Detected: {emotion}"
 
     summary_button = gr.Button("Show Summary")
     summary_output = gr.Textbox(label="Summary")
@@ -307,21 +229,10 @@ with gr.Blocks() as demo:
 
     # Fetch and display nearby health professionals
     def fetch_nearby_health_professionals(location):
-        try:
-            lat, lon = geocode_location(location)
-            query = "therapist OR counselor OR mental health professional OR marriage and family therapist OR psychotherapist OR psychiatrist OR psychologist OR nutritionist OR wellness doctor OR holistic practitioner OR integrative medicine OR chiropractor OR naturopath"
-            radius = 50000  # 50 km radius
-
-            all_results = get_all_places(query, f"{lat},{lon}", radius, api_key)
-            if all_results:
-                df = pd.DataFrame(all_results, columns=["Name", "Address", "Phone", "Rating", "Business Status", "User Reviews Total", "Website", "Types", "Latitude", "Longitude", "Opening Hours", "Reviews", "Email"])
-                return df
-            else:
-                return "No data found."
-        except Exception as e:
-            return str(e)
+        df = fetch_nearby_health_professionals(location)
+        return df
 
-    nearby_health_professionals_table = gr.Dataframe(headers=["Name", "Address", "Phone", "Rating", "Business Status", "User Reviews Total", "Website", "Types", "Latitude", "Longitude", "Opening Hours", "Reviews", "Email"])
+    nearby_health_professionals_table = gr.Dataframe(headers=["Name", "Rating", "Phone Number"])
     submit_location.click(fetch_nearby_health_professionals, inputs=location_input, outputs=nearby_health_professionals_table)
 
     # User input for text (sentiment analysis)
@@ -330,26 +241,18 @@ with gr.Blocks() as demo:
 
     # Prediction button for sentiment analysis
     def predict_sentiment(text):
-        inputs = tokenizer_sentiment(text, 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 sentiment
+        return predict_sentiment(text)
 
     sentiment_output = gr.Textbox(label="Predicted Sentiment")
     submit_sentiment.click(predict_sentiment, inputs=user_input_sentiment, outputs=sentiment_output)
 
     # Button to fetch wellness professionals data
-    fetch_button = gr.Button("Fetch Wellness professionals data")
-    data_output = gr.Dataframe(headers=["Name", "Address", "Phone", "Rating", "Business Status", "User Reviews Total", "Website", "Types", "Latitude", "Longitude", "Opening Hours", "Reviews", "Email"])
+    fetch_button = gr.Button("Fetch Wellness Professionals Data")
+    data_output = gr.Dataframe(headers=["Name", "Rating", "Phone Number"])
 
     def fetch_data():
-        all_results = get_all_places(query, location, radius, api_key)
-        if all_results:
-            return pd.DataFrame(all_results, columns=["Name", "Address", "Phone", "Rating", "Business Status", "User Reviews Total", "Website", "Types", "Latitude", "Longitude", "Opening Hours", "Reviews", "Email"])
-        else:
-            return "No data found."
+        df = fetch_nearby_health_professionals("Hawaii")
+        return df
 
     fetch_button.click(fetch_data, inputs=None, outputs=data_output)