Update app.py

app.py

@@ -12,16 +12,10 @@ from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipe
 import googlemaps
 import folium
 import torch
-import pandas as pd
-from sklearn.tree import DecisionTreeClassifier
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.naive_bayes import GaussianNB
-from sklearn.metrics import accuracy_score
-from sklearn.preprocessing import LabelEncoder
 
 # Suppress TensorFlow warnings
-os.environ["CUDA_VISIBLE_DEVICES"] = "-1"  # No GPU available, use CPU only
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"    # Suppress TensorFlow logging
+os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
 
 # Download necessary NLTK resources
 nltk.download("punkt")
@@ -52,77 +46,9 @@ model_emotion = AutoModelForSequenceClassification.from_pretrained("j-hartmann/e
 # Google Maps API Client
 gmaps = googlemaps.Client(key=os.getenv("GOOGLE_API_KEY"))
 
-# Disease Prediction Code
-def load_data():
-    try:
-        df = pd.read_csv("Training.csv")
-        tr = pd.read_csv("Testing.csv")
-    except FileNotFoundError:
-        raise RuntimeError("Data files not found. Please ensure `Training.csv` and `Testing.csv` are uploaded correctly.")
-
-    # Encode diseases in a dictionary
-    disease_dict = {
-        'Fungal infection': 0, 'Allergy': 1, 'GERD': 2, 'Chronic cholestasis': 3, 'Drug Reaction': 4,
-        'Peptic ulcer disease': 5, 'AIDS': 6, 'Diabetes': 7, 'Gastroenteritis': 8, 'Bronchial Asthma': 9,
-        'Hypertension': 10, 'Migraine': 11, 'Cervical spondylosis': 12, 'Paralysis (brain hemorrhage)': 13,
-        'Jaundice': 14, 'Malaria': 15, 'Chicken pox': 16, 'Dengue': 17, 'Typhoid': 18,
-        'Hepatitis A': 19, 'Hepatitis B': 20, 'Hepatitis C': 21, 'Hepatitis D': 22, 'Hepatitis E': 23,
-        'Alcoholic hepatitis': 24, 'Tuberculosis': 25, 'Common Cold': 26, 'Pneumonia': 27,
-        'Heart attack': 28, 'Varicose veins': 29, 'Hypothyroidism': 30, 'Hyperthyroidism': 31,
-        'Hypoglycemia': 32, 'Osteoarthritis': 33, 'Arthritis': 34,
-        '(vertigo) Paroxysmal Positional Vertigo': 35, 'Acne': 36, 'Urinary tract infection': 37,
-        'Psoriasis': 38, 'Impetigo': 39
-    }
-
-    # Replace prognosis values with numerical categories
-    df.replace({'prognosis': disease_dict}, inplace=True)
-    df['prognosis'] = df['prognosis'].astype(int)
-
-    tr.replace({'prognosis': disease_dict}, inplace=True)
-    tr['prognosis'] = tr['prognosis'].astype(int)
-
-    return df, tr, disease_dict
-
-df, tr, disease_dict = load_data()
-l1 = list(df.columns[:-1])  # All columns except prognosis
-X = df[l1]
-y = df['prognosis']
-X_test = tr[l1]
-y_test = tr['prognosis']
-
-# Encode the target variable with LabelEncoder if still in string format
-le = LabelEncoder()
-y_encoded = le.fit_transform(y)
-
-def train_models():
-    models = {
-        "Decision Tree": DecisionTreeClassifier(),
-        "Random Forest": RandomForestClassifier(),
-        "Naive Bayes": GaussianNB()
-    }
-    trained_models = {}
-    for model_name, model_obj in models.items():
-        model_obj.fit(X, y_encoded)
-        acc = accuracy_score(y_test, model_obj.predict(X_test))
-        trained_models[model_name] = (model_obj, acc)
-    return trained_models
-
-trained_models = train_models()
-
-def predict_disease(model, symptoms):
-    input_test = np.zeros(len(l1))
-    for symptom in symptoms:
-        if symptom in l1:
-            input_test[l1.index(symptom)] = 1
-    prediction = model.predict([input_test])[0]
-    confidence = model.predict_proba([input_test])[0][prediction] if hasattr(model, 'predict_proba') else None
-    return {
-        "disease": list(disease_dict.keys())[list(disease_dict.values()).index(prediction)],
-        "confidence": confidence
-    }
-
-# Helper Functions (for chatbot)
+# Helper Functions
 def bag_of_words(s, words):
+    """Convert user input to bag-of-words vector."""
     bag = [0] * len(words)
     s_words = word_tokenize(s)
     s_words = [stemmer.stem(word.lower()) for word in s_words if word.isalnum()]
@@ -133,17 +59,23 @@ def bag_of_words(s, words):
     return np.array(bag)
 
 def generate_chatbot_response(message, history):
+    """Generate chatbot response and maintain conversation history."""
     history = history or []
     try:
         result = chatbot_model.predict([bag_of_words(message, words)])
         tag = labels[np.argmax(result)]
-        response = next((random.choice(intent["responses"]) for intent in intents_data["intents"] if intent["tag"] == tag), "I'm sorry, I didn't understand that. 🤔")
+        response = "I'm sorry, I didn't understand that. 🤔"
+        for intent in intents_data["intents"]:
+            if intent["tag"] == tag:
+                response = random.choice(intent["responses"])
+                break
     except Exception as e:
         response = f"Error: {e}"
     history.append((message, response))
     return history, response
 
 def analyze_sentiment(user_input):
+    """Analyze sentiment and map to emojis."""
     inputs = tokenizer_sentiment(user_input, return_tensors="pt")
     with torch.no_grad():
         outputs = model_sentiment(**inputs)
@@ -152,6 +84,7 @@ def analyze_sentiment(user_input):
     return f"Sentiment: {sentiment_map[sentiment_class]}"
 
 def detect_emotion(user_input):
+    """Detect emotions based on input."""
     pipe = pipeline("text-classification", model=model_emotion, tokenizer=tokenizer_emotion)
     result = pipe(user_input)
     emotion = result[0]["label"].lower().strip()
@@ -166,20 +99,52 @@ def detect_emotion(user_input):
     return emotion_map.get(emotion, "Unknown 🤔"), emotion
 
 def generate_suggestions(emotion):
+    """Return relevant suggestions based on detected emotions."""
     emotion_key = emotion.lower()
     suggestions = {
-        # Define suggestions based on the detected emotion
+        "joy": [
+            ["Relaxation Techniques", "https://www.helpguide.org/mental-health/meditation/mindful-breathing-meditation"],
+            ["Dealing with Stress", "https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety"],
+            ["Emotional Wellness Toolkit", "https://www.nih.gov/health-information/emotional-wellness-toolkit"],
+            ["Relaxation Video", "https://youtu.be/m1vaUGtyo-A"],
+        ],
+        "anger": [
+            ["Emotional Wellness Toolkit", "https://www.nih.gov/health-information/emotional-wellness-toolkit"],
+            ["Stress Management Tips", "https://www.health.harvard.edu/health-a-to-z"],
+            ["Dealing with Anger", "https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety"],
+            ["Relaxation Video", "https://youtu.be/MIc299Flibs"],
+        ],
+        "fear": [
+            ["Mindfulness Practices", "https://www.helpguide.org/mental-health/meditation/mindful-breathing-meditation"],
+            ["Coping with Anxiety", "https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety"],
+            ["Emotional Wellness Toolkit", "https://www.nih.gov/health-information/emotional-wellness-toolkit"],
+            ["Relaxation Video", "https://youtu.be/yGKKz185M5o"],
+        ],
+        "sadness": [
+            ["Emotional Wellness Toolkit", "https://www.nih.gov/health-information/emotional-wellness-toolkit"],
+            ["Dealing with Anxiety", "https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety"],
+            ["Relaxation Video", "https://youtu.be/-e-4Kx5px_I"],
+        ],
+        "surprise": [
+            ["Managing Stress", "https://www.health.harvard.edu/health-a-to-z"],
+            ["Coping Strategies", "https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety"],
+            ["Relaxation Video", "https://youtu.be/m1vaUGtyo-A"],
+        ],
     }
     
+    # Format the output to include HTML anchor tags
     formatted_suggestions = [
         [title, f'<a href="{link}" target="_blank">{link}</a>'] for title, link in suggestions.get(emotion_key, [["No specific suggestions available.", "#"]])
     ]
+
     return formatted_suggestions
 
 def get_health_professionals_and_map(location, query):
+    """Search nearby healthcare professionals using Google Maps API."""
     try:
         if not location or not query:
-            return [], ""
+            return [], ""  # Return empty list if inputs are missing
+
         geo_location = gmaps.geocode(location)
         if geo_location:
             lat, lng = geo_location[0]["geometry"]["location"].values()
@@ -187,92 +152,130 @@ def get_health_professionals_and_map(location, query):
             professionals = []
             map_ = folium.Map(location=(lat, lng), zoom_start=13)
             for place in places_result:
+                # Use a list of values to append each professional
                 professionals.append([place['name'], place.get('vicinity', 'No address provided')])
                 folium.Marker(
                     location=[place["geometry"]["location"]["lat"], place["geometry"]["location"]["lng"]],
                     popup=f"{place['name']}"
                 ).add_to(map_)
             return professionals, map_._repr_html_()
-        return [], ""
+
+        return [], ""  # Return empty list if no professionals found
     except Exception as e:
-        return [], ""
+        return [], ""  # Return empty list on exception
 
 # Main Application Logic
-def app_function(user_input, location, query, symptoms, history):
+def app_function(user_input, location, query, history):
     chatbot_history, _ = generate_chatbot_response(user_input, history)
     sentiment_result = analyze_sentiment(user_input)
     emotion_result, cleaned_emotion = detect_emotion(user_input)
     suggestions = generate_suggestions(cleaned_emotion)
     professionals, map_html = get_health_professionals_and_map(location, query)
-    
-    # Disease prediction logic
-    symptoms_selected = [s for s in symptoms if s != "None"]
-    if len(symptoms_selected) < 3:
-        disease_results = ["Please select at least 3 symptoms for accurate prediction."]
-    else:
-        results = []
-        for model_name, (model, acc) in trained_models.items():
-            prediction_info = predict_disease(model, symptoms_selected)
-            predicted_disease = prediction_info["disease"]
-            confidence_score = prediction_info["confidence"]
-            
-            result = f"{model_name} Prediction: Predicted Disease: **{predicted_disease}**"
-            if confidence_score is not None:
-                result += f" (Confidence: {confidence_score:.2f})"
-            result += f" (Accuracy: {acc * 100:.2f}%)"
-            
-            results.append(result)
-        disease_results = results
-
-    return (
-        chatbot_history, 
-        sentiment_result, 
-        emotion_result, 
-        suggestions, 
-        professionals, 
-        map_html,
-        disease_results
-    )
+    return chatbot_history, sentiment_result, emotion_result, suggestions, professionals, map_html
 
 # CSS Styling
 custom_css = """
-/* Your custom CSS styles go here */
+body {
+    font-family: 'Roboto', sans-serif;
+    background-color: #3c6487; /* Set the background color */
+    color: white;
+}
+
+h1 {
+    background: #ffffff;
+    color: #000000;
+    border-radius: 8px;
+    padding: 10px;
+    font-weight: bold;
+    text-align: center;
+    font-size: 2.5rem;
+}
+
+textarea, input {
+    background: transparent;
+    color: black;
+    border: 2px solid orange;
+    padding: 8px;
+    font-size: 1rem;
+    caret-color: black;
+    outline: none;
+    border-radius: 8px;
+}
+
+textarea:focus, input:focus {
+    background: transparent;
+    color: black;
+    border: 2px solid orange;
+    outline: none;
+}
+
+textarea:hover, input:hover {
+    background: transparent;
+    color: black;
+    border: 2px solid orange;
+}
+
+.df-container {
+    background: white;
+    color: black;
+    border: 2px solid orange;
+    border-radius: 10px;
+    padding: 10px;
+    font-size: 14px;
+    max-height: 400px;
+    height: auto;
+    overflow-y: auto;
+}
+
+#suggestions-title {
+    text-align: center !important; /* Ensure the centering is applied */
+    font-weight: bold !important; /* Ensure bold is applied */
+    color: white !important; /* Ensure color is applied */
+    font-size: 4.2rem !important; /* Ensure font size is applied */
+    margin-bottom: 20px !important; /* Ensure margin is applied */
+}
+
+/* Style for the submit button */
+.gr-button {
+    background-color: #ae1c93;  /* Set the background color to #ae1c93 */
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1), 0 2px 4px rgba(0, 0, 0, 0.06);
+    transition: background-color 0.3s ease;
+}
+
+.gr-button:hover {
+    background-color: #8f167b;
+}
+
+.gr-button:active {
+    background-color: #7f156b;
+}
 """
 
 # Gradio Application
 with gr.Blocks(css=custom_css) as app:
     gr.HTML("<h1>🌟 Well-Being Companion</h1>")
-    
     with gr.Row():
         user_input = gr.Textbox(label="Please Enter Your Message Here")
-        location = gr.Textbox(label="Your Current Location Here")
-        query = gr.Textbox(label="Search Health Professionals Nearby")
+        location = gr.Textbox(label="Please Enter Your Current Location Here")
+        query = gr.Textbox(label="Please Enter Which Health Professional You Want To Search Nearby")
         
-    with gr.Row():
-        symptom1 = gr.Dropdown(choices=["None"] + l1, label="Symptom 1")
-        symptom2 = gr.Dropdown(choices=["None"] + l1, label="Symptom 2")
-        symptom3 = gr.Dropdown(choices=["None"] + l1, label="Symptom 3")
-        symptom4 = gr.Dropdown(choices=["None"] + l1, label="Symptom 4")
-        symptom5 = gr.Dropdown(choices=["None"] + l1, label="Symptom 5")
-
     submit = gr.Button(value="Submit", variant="primary")
 
     chatbot = gr.Chatbot(label="Chat History")
     sentiment = gr.Textbox(label="Detected Sentiment")
     emotion = gr.Textbox(label="Detected Emotion")
     
+    # Adding Suggestions Title with Styled Markdown (Centered and Bold)
     gr.Markdown("Suggestions", elem_id="suggestions-title")
     
-    suggestions = gr.DataFrame(headers=["Title", "Link"])  # Suggestions DataFrame
-    professionals = gr.DataFrame(label="Nearby Health Professionals", headers=["Name", "Address"])  # Professionals DataFrame
+    suggestions = gr.DataFrame(headers=["Title", "Link"])  # Table for suggestions
+    professionals = gr.DataFrame(label="Nearby Health Professionals", headers=["Name", "Address"])  # Changed to DataFrame
     map_html = gr.HTML(label="Interactive Map")
-    disease_predictions = gr.Textbox(label="Disease Predictions")  # For Disease Prediction Results
 
     submit.click(
         app_function,
-        inputs=[user_input, location, query, [symptom1, symptom2, symptom3, symptom4, symptom5], chatbot],
-        outputs=[chatbot, sentiment, emotion, suggestions, professionals, map_html, disease_predictions],
+        inputs=[user_input, location, query, chatbot],
+        outputs=[chatbot, sentiment, emotion, suggestions, professionals, map_html],
     )
 
-# Launch the Gradio application
 app.launch()