Update app.py

app.py

@@ -2,6 +2,8 @@ import os
 import gradio as gr
 import nltk
 import numpy as np
+import tflearn
+import random
 import json
 import pickle
 from nltk.tokenize import word_tokenize
@@ -10,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")
@@ -32,18 +28,14 @@ with open("intents.json") as file:
 with open("data.pickle", "rb") as f:
     words, labels, training, output = pickle.load(f)
 
-# Build the chatbot model using Keras
-def build_chatbot_model(input_shape, output_shape):
-    model = keras.Sequential()
-    model.add(layers.Input(shape=(input_shape,)))
-    model.add(layers.Dense(8, activation='relu'))
-    model.add(layers.Dense(len(output_shape), activation='softmax'))
-    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
-    return model
-
-# Build and train the chatbot model
-chatbot_model = build_chatbot_model(len(training[0]), len(output[0]))
-chatbot_model.fit(training, output, epochs=100)  # Ensure training data is prepared accordingly
+# Build the chatbot model
+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)
+chatbot_model = tflearn.DNN(net)
+chatbot_model.load("MentalHealthChatBotmodel.tflearn")
 
 # Hugging Face sentiment and emotion models
 tokenizer_sentiment = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
@@ -54,148 +46,23 @@ 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 as e:
-        raise RuntimeError("Data files not found. Please ensure `Training.csv` and `Testing.csv` are uploaded correctly.") from e
-
-    # Encode diseases
-    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, 
-        'Dimorphic hemorrhoids (piles)': 28, 
-        'Heart attack': 29, 
-        'Varicose veins': 30, 
-        'Hypothyroidism': 31, 
-        'Hyperthyroidism': 32,
-        'Hypoglycemia': 33, 
-        'Osteoarthritis': 34, 
-        'Arthritis': 35,
-        '(vertigo) Paroxysmal Positional Vertigo': 36, 
-        'Acne': 37, 
-        'Urinary tract infection': 38,
-        'Psoriasis': 39, 
-        'Impetigo': 40
-    }
-
-    # Replace prognosis values with numerical categories
-    df.replace({'prognosis': disease_dict}, inplace=True)
-
-    # Check unique values in prognosis for debugging
-    print("Unique values in prognosis after mapping:", df['prognosis'].unique())
-
-    # Ensure prognosis is purely numerical after mapping
-    if df['prognosis'].dtype == 'object':
-        raise ValueError(f"The prognosis contains unmapped values: {df['prognosis'].unique()}")
-
-    df['prognosis'] = df['prognosis'].astype(int)
-    df = df.infer_objects()
-
-    # Similar process for the testing data
-    tr.replace({'prognosis': disease_dict}, inplace=True)
-    print("Unique values in prognosis for testing data after mapping:", tr['prognosis'].unique())
-    
-    if tr['prognosis'].dtype == 'object':
-        raise ValueError(f"Testing data prognosis contains unmapped values: {tr['prognosis'].unique()}")
-
-    tr['prognosis'] = tr['prognosis'].astype(int)
-    tr = tr.infer_objects()
-
-    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(X, y_encoded, X_test, y_test):
-    models = {
-        "Decision Tree": DecisionTreeClassifier(),
-        "Random Forest": RandomForestClassifier(),
-        "Naive Bayes": GaussianNB()
-    }
-    trained_models = {}
-    for model_name, model_obj in models.items():
-        try:
-            model_obj.fit(X, y_encoded)  # Fit the model
-            acc = accuracy_score(y_test, model_obj.predict(X_test))
-            trained_models[model_name] = (model_obj, acc)
-        except Exception as e:
-            print(f"Failed to train {model_name}: {e}")
-    return trained_models
-
-trained_models = train_models(X, y_encoded, X_test, y_test)
-
-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
-    }
-
-def disease_prediction_interface(symptoms):
-    symptoms_selected = [s for s in symptoms if s != "None"]
-    
-    if len(symptoms_selected) < 3:
-        return ["Please select at least 3 symptoms for accurate prediction."]
-    
-    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)
-
-    return results
-
-# Helper Functions (for chatbot)
+# Disease dictionary to map disease names to numerical values
+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, 'Dimorphic hemorrhoids(piles)': 28,
+    'Heart attack': 29, 'Varicose veins': 30, 'Hypothyroidism': 31, 'Hyperthyroidism': 32,
+    'Hypoglycemia': 33, 'Osteoarthritis': 34, 'Arthritis': 35,
+    '(vertigo) Paroxysmal Positional Vertigo': 36, 'Acne': 37, 'Urinary tract infection': 38,
+    'Psoriasis': 39, 'Impetigo': 40
+}
+
+# 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()]
@@ -206,17 +73,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)
@@ -225,6 +98,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()
@@ -238,6 +112,17 @@ def detect_emotion(user_input):
     }
     return emotion_map.get(emotion, "Unknown 🤔"), emotion
 
+def disease_prediction(user_input):
+    """Predict disease based on input symptoms."""
+    # Here, we simulate disease prediction logic
+    symptoms = user_input.lower().split()
+    disease_probabilities = [random.random() for _ in disease_dict]  # Placeholder for prediction model
+    
+    # Select the highest probability (for demonstration)
+    disease_index = np.argmax(disease_probabilities)
+    disease_name = list(disease_dict.keys())[disease_index]
+    return disease_name
+
 def generate_suggestions(emotion):
     """Return relevant suggestions based on detected emotions."""
     emotion_key = emotion.lower()
@@ -271,10 +156,12 @@ def generate_suggestions(emotion):
             ["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):
@@ -290,100 +177,133 @@ 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:
-        print(f"Failed to fetch healthcare professionals: {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_results = disease_prediction_interface(symptoms)
-    
-    return (
-        chatbot_history,
-        sentiment_result,
-        emotion_result,
-        suggestions,
-        professionals,
-        map_html,
-        disease_results
-    )
+    disease_result = disease_prediction(user_input)  # Get disease prediction
+    return chatbot_history, sentiment_result, emotion_result, suggestions, professionals, map_html, disease_result
+
+# CSS Styling
+custom_css = """
+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="Please Enter Your Current Location Here")
+        query = gr.Textbox(label="Please Enter Which Health Professional You Want To Search Nearby")
+        
+    submit = gr.Button(value="Submit", variant="primary")
 
-# Disease Prediction Interface
-def disease_app_function(name, symptom1, symptom2, symptom3, symptom4, symptom5):
-    if not name.strip():
-        return "Please enter the patient's name."
+    chatbot = gr.Chatbot(label="Chat History")
+    sentiment = gr.Textbox(label="Detected Sentiment")
+    emotion = gr.Textbox(label="Detected Emotion")
     
-    symptoms_selected = [s for s in [symptom1, symptom2, symptom3, symptom4, symptom5] if s != "None"]
+    # Adding Suggestions Title with Styled Markdown (Centered and Bold)
+    gr.Markdown("Suggestions", elem_id="suggestions-title")
     
-    if len(symptoms_selected) < 3:
-        return "Please select at least 3 symptoms for accurate prediction."
-
-    results = []
-    for model_name, (model, acc) in trained_models.items():
-        prediction = predict_disease(model, symptoms_selected)
-        result = f"{model_name} Prediction: Predicted Disease: **{prediction}**"
-        result += f" (Accuracy: {acc * 100:.2f}%)"
-        results.append(result)
+    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")
     
-    return "\n\n".join(results)
+    disease = gr.Textbox(label="Predicted Disease")  # Display disease prediction
 
-# Gradio Interface Setup
-with gr.Blocks() as app:
-    gr.HTML("<h1>🌟 Well-Being Companion</h1>")
-    
-    with gr.Tab("Mental Health Companion"):
-        with gr.Row():
-            user_input = gr.Textbox(label="Please Enter Your Message Here", placeholder="Type your message...")
-            location = gr.Textbox(label="Your Current Location Here", placeholder="Enter location...")
-            query = gr.Textbox(label="Search Health Professionals Nearby", placeholder="What are you looking for...")
-            
-        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_chatbot = gr.Button(value="Submit", variant="primary")
-        chatbot = gr.Chatbot(label="Chat History")
-        sentiment = gr.Textbox(label="Detected Sentiment")
-        emotion = gr.Textbox(label="Detected Emotion")
-        
-        suggestions = gr.DataFrame(headers=["Title", "Link"])  
-        professionals = gr.DataFrame(label="Nearby Health Professionals", headers=["Name", "Address"])  
-        map_html = gr.HTML(label="Interactive Map")
-        disease_predictions = gr.Textbox(label="Disease Predictions")  
-
-        submit_chatbot.click(
-            app_function,
-            inputs=[user_input, location, query, [symptom1, symptom2, symptom3, symptom4, symptom5], chatbot],
-            outputs=[chatbot, sentiment, emotion, suggestions, professionals, map_html, disease_predictions],
-        )
-
-    with gr.Tab("Disease Prediction"):
-        name_box = gr.Textbox(label="Name of Patient", placeholder="Enter patient's name")
-        symptom_choices = [gr.Dropdown(choices=["None"] + l1, label=f"Symptom {i+1}") for i in range(5)]
-        submit_disease = gr.Button(value="Submit", variant="primary")
-
-        disease_output = gr.Textbox(label="Predicted Disease", placeholder="Prediction will appear here")
-
-        submit_disease.click(
-            disease_app_function,
-            inputs=[name_box] + symptom_choices,
-            outputs=disease_output
-        )
-
-# Launch the Gradio application
-app.launch()
+    submit.click(
+        app_function,
+        inputs=[user_input, location, query, chatbot],
+        outputs=[chatbot, sentiment, emotion, suggestions, professionals, map_html, disease],
+    )
+
+app.launch()