app.py

import os
import gradio as gr
import nltk
import numpy as np
import json
import pickle
from nltk.tokenize import word_tokenize
from nltk.stem.lancaster import LancasterStemmer
from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
import googlemaps
import folium
import torch
import pandas as pd
from tensorflow import keras
from tensorflow.keras import layers
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

# Download necessary NLTK resources
nltk.download("punkt")
stemmer = LancasterStemmer()

# Load intents and chatbot training data
with open("intents.json") as file:
    intents_data = json.load(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(8, activation='relu'))
    model.add(layers.Dense(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)  # Adjust epochs and model fitting parameters as necessary

# Hugging Face sentiment and emotion models
tokenizer_sentiment = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
model_sentiment = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
tokenizer_emotion = AutoTokenizer.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
model_emotion = AutoModelForSequenceClassification.from_pretrained("j-hartmann/emotion-english-distilroberta-base")

# 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 after mapping
    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)
def bag_of_words(s, words):
    bag = [0] * len(words)
    s_words = word_tokenize(s)
    s_words = [stemmer.stem(word.lower()) for word in s_words if word.isalnum()]
    for se in s_words:
        for i, w in enumerate(words):
            if w == se:
                bag[i] = 1
    return np.array(bag)

def generate_chatbot_response(message, 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. 🤔")
    except Exception as e:
        response = f"Error: {e}"
    history.append((message, response))
    return history, response

def analyze_sentiment(user_input):
    inputs = tokenizer_sentiment(user_input, return_tensors="pt")
    with torch.no_grad():
        outputs = model_sentiment(**inputs)
    sentiment_class = torch.argmax(outputs.logits, dim=1).item()
    sentiment_map = ["Negative 😔", "Neutral 😐", "Positive 😊"]
    return f"Sentiment: {sentiment_map[sentiment_class]}"

def detect_emotion(user_input):
    pipe = pipeline("text-classification", model=model_emotion, tokenizer=tokenizer_emotion)
    result = pipe(user_input)
    emotion = result[0]["label"].lower().strip()
    emotion_map = {
        "joy": "Joy 😊",
        "anger": "Anger 😠",
        "sadness": "Sadness 😢",
        "fear": "Fear 😨",
        "surprise": "Surprise 😲",
        "neutral": "Neutral 😐",
    }
    return emotion_map.get(emotion, "Unknown 🤔"), emotion

def generate_suggestions(emotion):
    """Return relevant suggestions based on detected emotions."""
    emotion_key = emotion.lower()
    suggestions = {
        "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"],
        ],
    }

    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 empty list if inputs are missing

        geo_location = gmaps.geocode(location)
        if geo_location:
            lat, lng = geo_location[0]["geometry"]["location"].values()
            places_result = gmaps.places_nearby(location=(lat, lng), radius=10000, keyword=query)["results"]
            professionals = []
            map_ = folium.Map(location=(lat, lng), zoom_start=13)
            for place in places_result:
                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 [], ""
    except Exception as e:
        print(f"Failed to fetch healthcare professionals: {e}")
        return [], ""

# Main Application Logic
def app_function(user_input, location, query, symptoms, 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 Prediction Interface
def disease_app_function(name, symptom1, symptom2, symptom3, symptom4, symptom5):
    if not name.strip():
        return "Please enter the patient's name."
    
    symptoms_selected = [s for s in [symptom1, symptom2, symptom3, symptom4, symptom5] 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 = predict_disease(model, symptoms_selected)
        result = f"{model_name} Prediction: Predicted Disease: **{prediction}**"
        result += f" (Accuracy: {acc * 100:.2f}%)"
        results.append(result)
    
    return "\n\n".join(results)

# 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()