Update app.py

app.py

@@ -1,132 +1,19 @@
-import os
 import gradio as gr
-import nltk
-import numpy as np
-import json
-import tflearn
-import random
-import pickle
-from nltk.tokenize import word_tokenize
-from nltk.stem.lancaster import LancasterStemmer
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
-import torch
 import pandas as pd
+import numpy as np
 from sklearn.tree import DecisionTreeClassifier
 from sklearn.ensemble import RandomForestClassifier
 from sklearn.naive_bayes import GaussianNB
 from sklearn.metrics import accuracy_score
-import googlemaps
-import folium
-
-# Suppress TensorFlow warnings
-os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
-
-# NLTK Setup
-nltk.download("punkt")
-stemmer = LancasterStemmer()
-
-# Load chatbot and disease prediction 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)
-
-# Chatbot model setup
-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 models for Well-Being Companion
-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"))
-
-# Functions: Chatbot, Sentiment, Emotion, and Suggestions
-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):
-    """Generate chatbot response and maintain conversation history."""
-    history = history or []
-    result = chatbot_model.predict([bag_of_words(message, words)])
-    tag = labels[np.argmax(result)]
-    response = next((r for intent in intents_data["intents"] if intent["tag"] == tag for r in intent["responses"]), "I'm sorry, I didn't understand that. 🤔")
-    history.append((message, response))
-    return history, response
-
-def analyze_sentiment(user_input):
-    inputs = tokenizer_sentiment(user_input, return_tensors="pt")
-    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 🤔")
-
-def generate_suggestions(emotion):
-    suggestions = {
-        "joy": [["Relaxation Techniques", "https://helpguide.org"], ["Dealing with Stress", "https://helpguide.org"]],
-        "anger": [["Stress Management", "https://health.harvard.edu"], ["Anger Management", "https://helpguide.org"]],
-        "fear": [["Mindfulness", "https://helpguide.org"], ["Coping with Anxiety", "https://helpguide.org"]],
-        "sadness": [["Emotional Wellness", "https://nih.gov"], ["Relaxation Video", "https://youtu.be/-e-4Kx5px_I"]],
-        "surprise": [["Managing Stress", "https://helpguide.org"], ["Coping Strategies", "https://helpguide.org"]]
-    }
-    return suggestions.get(emotion, [["No suggestions available.", "#"]])
-
-def get_health_professionals_and_map(location, query):
-    try:
-        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 = [[place['name'], place.get('vicinity', 'No address')] for place in places_result]
-            map_ = folium.Map(location=(lat, lng), zoom_start=13)
-            for place in places_result:
-                folium.Marker([place["geometry"]["location"]["lat"], place["geometry"]["location"]["lng"]],
-                              popup=place['name']).add_to(map_)
-            return professionals, map_._repr_html_()
-        return [], ""
-    except Exception as e:
-        return [], ""
-
-def app_function(user_input, location, query, history):
-    chatbot_history, chatbot_response = generate_chatbot_response(user_input, history)
-    sentiment = analyze_sentiment(user_input)
-    emotion = detect_emotion(user_input)
-    suggestions = generate_suggestions(emotion)
-    professionals, map_html = get_health_professionals_and_map(location, query)
-    return chatbot_history, sentiment, emotion, suggestions, professionals, map_html
-
-# Chronic Disease Prediction (Placeholder function; keep similar)
+# Load datasets
 def load_data():
     df = pd.read_csv("Training.csv")
     tr = pd.read_csv("Testing.csv")
-    disease_dict = {  'Fungal infection': 0, 'Allergy': 1, 'GERD': 2, 'Chronic cholestasis': 3, 'Drug Reaction': 4,
+    
+    # Encode diseases
+    disease_dict = {
+        'Fungal infection': 0, 'Allergy': 1, 'GERD': 2, 'Chronic cholestasis': 3, 'Drug Reaction': 4,
         'Peptic ulcer diseae': 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,
@@ -136,17 +23,30 @@ def load_data():
         'Hypoglycemia': 33, 'Osteoarthristis': 34, 'Arthritis': 35,
         '(vertigo) Paroymsal  Positional Vertigo': 36, 'Acne': 37, 'Urinary tract infection': 38,
         'Psoriasis': 39, 'Impetigo': 40
-    } # Same logic.
+    }
+
     df.replace({'prognosis': disease_dict}, inplace=True)
+    df = df.infer_objects(copy=False)
+
+    tr.replace({'prognosis': disease_dict}, inplace=True)
+    tr = tr.infer_objects(copy=False)
+    
     return df, tr, disease_dict
 
-df, tr, disease_dict = load_data()
-l1 = list(df.columns[:-1])
+try:
+    df, tr, disease_dict = load_data()
+except FileNotFoundError as e:
+    raise RuntimeError("Data files not found. Please ensure `Training.csv` and `Testing.csv` are available.")
+except Exception as e:
+    raise RuntimeError(f"An error occurred while loading data: {e}")
+
+l1 = list(df.columns[:-1])  
 X = df[l1]
 y = df['prognosis']
 X_test = tr[l1]
 y_test = tr['prognosis']
 
+# Trained models
 def train_models():
     models = {
         "Decision Tree": DecisionTreeClassifier(),
@@ -162,123 +62,49 @@ def train_models():
 
 trained_models = train_models()
 
-disease_to_professional = {
-    'Fungal infection': ["Dermatologist", "Family Doctor"],
-    'Allergy': ["Allergist", "Family Doctor"],
-    'GERD': ["Gastroenterologist", "Family Doctor"],
-    'Chronic cholestasis': ["Gastroenterologist", "Family Doctor"],
-    'Drug Reaction': ["Dermatologist", "Family Doctor"],
-    'Peptic ulcer disease': ["Gastroenterologist", "Family Doctor"],
-    'AIDS': ["Infectious Disease Specialist", "Family Doctor"],
-    'Diabetes ': ["Endocrinologist", "Family Doctor"],
-    'Gastroenteritis': ["Gastroenterologist", "Family Doctor"],
-    'Bronchial Asthma': ["Pulmonologist", "Family Doctor"],
-    'Hypertension ': ["Cardiologist", "Family Doctor"],
-    'Migraine': ["Neurologist", "Family Doctor"],
-    'Cervical spondylosis': ["Orthopedist", "Family Doctor"],
-    'Paralysis (brain hemorrhage)': ["Neurologist", "Family Doctor"],
-    'Jaundice': ["Hepatologist", "Family Doctor"],
-    'Malaria': ["Infectious Disease Specialist", "Family Doctor"],
-    'Chicken pox': ["Pediatrician", "Family Doctor"],
-    'Dengue': ["Infectious Disease Specialist", "Family Doctor"],
-    'Typhoid': ["Infectious Disease Specialist", "Family Doctor"],
-    'hepatitis A': ["Hepatologist", "Family Doctor"],
-    'Hepatitis B': ["Hepatologist", "Family Doctor"],
-    'Hepatitis C': ["Hepatologist", "Family Doctor"],
-    'Hepatitis D': ["Hepatologist", "Family Doctor"],
-    'Hepatitis E': ["Hepatologist", "Family Doctor"],
-    'Alcoholic hepatitis': ["Hepatologist", "Family Doctor"],
-    'Tuberculosis': ["Pulmonologist", "Family Doctor"],
-    'Common Cold': ["General Practitioner"],
-    'Pneumonia': ["Pulmonologist", "Family Doctor"],
-    'Dimorphic hemorrhoids(piles)': ["Gastroenterologist", "Family Doctor"],
-    'Heart attack': ["Cardiologist"],
-    'Varicose veins': ["Vascular Surgeon", "Family Doctor"],
-    'Hypothyroidism': ["Endocrinologist", "Family Doctor"],
-    'Hyperthyroidism': ["Endocrinologist", "Family Doctor"],
-    'Hypoglycemia': ["Endocrinologist", "Family Doctor"],
-    'Osteoarthritis': ["Orthopedist", "Family Doctor"],
-    'Arthritis': ["Rheumatologist", "Family Doctor"],
-    '(vertigo) Paroxysmal Positional Vertigo': ["Neurologist", "Family Doctor"],
-    'Acne': ["Cosmetic Dermatologist", "Family Doctor"],
-    'Urinary tract infection': ["Urologist", "Family Doctor"],
-    'Psoriasis': ["Dermatologist", "Family Doctor"],
-    'Impetigo': ["Dermatologist", "Family Doctor"]
-}
-def disease_predictor(symptoms):
-    results = []
+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]
+    return list(disease_dict.keys())[list(disease_dict.values()).index(prediction)]
+
+# Gradio Interface
+def app_function(name, symptom1, symptom2, symptom3, symptom4, symptom5):
+    if not name.strip():
+        return "Please enter the patient's name."
     
-    for model_name, (model, acc) in trained_models.items():
-        disease = predict_disease(model, symptoms)
-        pro = disease_to_professional.get(disease, ["No Recommendations Available"])
-        
-        # Convert the list of recommended professionals into a string without commas
-        pro_str = " and ".join(pro) if isinstance(pro, list) else pro
-        
-        results.append(f"Model: {model_name}\nPredicted Disease: {disease}\nRecommended Professionals: {pro_str}\n")
+    symptoms_selected = [s for s in [symptom1, symptom2, symptom3, symptom4, symptom5] if s != "None"]
     
-    return "\n".join(results)
-
-
+    if len(symptoms_selected) < 3:
+        return "Please select at least 3 symptoms for accurate prediction."
     
-def predict_disease_button(symptom1, symptom2, symptom3, symptom4, symptom5):
-    # Filter out "None" values and pass selected symptoms
-    selected_symptoms = [s for s in [symptom1, symptom2, symptom3, symptom4, symptom5] if s != "None"]
+    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)
     
-    # Check if at least 3 symptoms are selected
-    if len(selected_symptoms) < 3:
-        return "Please select at least three symptoms."
-    else:
-        return disease_predictor(selected_symptoms)
-# Gradio Interface
-def interface(user_input, symptoms, location, query, history, model_name="Decision Tree"):
-    """Main interface function for Gradio."""
-    # Generate responses and predictions
-    chatbot_history, response = generate_chatbot_response(user_input, history)
-    sentiment_result = analyze_sentiment(user_input)
-    emotion_result = detect_emotion(user_input)
-    suggestions = generate_suggestions(emotion_result.split()[0].lower())
-
-    # Chronic disease prediction
-    predicted_disease, professionals, acc = predict_disease(symptoms.split(", "), model_name)
-
-    # Get nearby health professionals
-    nearby_professionals, map_html = get_health_professionals_and_map(location, query)
-
-    return {
-        "Chatbot History": chatbot_history,
-        "Response": response,
-        "Sentiment": sentiment_result,
-        "Emotion": emotion_result,
-        "Suggestions": suggestions,
-        "Predicted Disease": predicted_disease,
-        "Recommended Professionals": professionals,
-        "Prediction Accuracy": f"{acc * 100:.2f}%",
-        "Nearby Professionals": nearby_professionals,
-        "Map": map_html,
-    }
-
-# Gradio App Configuration
-interface_inputs = [
-    gr.Textbox(label="User Input"),
-    gr.Textbox(label="Symptoms (comma-separated)"),
-    gr.Textbox(label="Location"),
-    gr.Textbox(label="Query (e.g., 'doctor')"),
-    gr.State([]),  # For chatbot history
-    gr.Radio(["Decision Tree", "Random Forest", "Naive Bayes"], label="Prediction Model", value="Decision Tree")
-]
-
-interface_outputs = [
-    gr.JSON(label="Results")
-]
-
-app = gr.Interface(
-    fn=interface,
-    inputs=interface_inputs,
-    outputs=interface_outputs,
-    title="Mental Health & Chronic Disease Assistant",
-    description="Chatbot, sentiment analysis, emotion detection, disease prediction, and professional locator."
+    return "\n\n".join(results)
+
+# Gradio Interface Setup
+iface = gr.Interface(
+    fn=app_function,
+    inputs=[
+        gr.Textbox(label="Name of Patient"),
+        gr.Dropdown(["None"] + l1, label="Symptom 1"),
+        gr.Dropdown(["None"] + l1, label="Symptom 2"),
+        gr.Dropdown(["None"] + l1, label="Symptom 3"),
+        gr.Dropdown(["None"] + l1, label="Symptom 4"),
+        gr.Dropdown(["None"] + l1, label="Symptom 5"),
+    ],
+    outputs=gr.Textbox(label="Prediction"),
+    title="Disease Predictor Using Machine Learning",
+    description="For accurate results, please select at least 3 symptoms.",
+    article="**Caution:** This system is designed for informational purposes only. Please visit a healthcare provider for any medical concerns."
 )
 
-if __name__ == "__main__":
-    app.launch()
+# Launch the Gradio application
+iface.launch()