Upload medic_bot.py

medic_bot.py

@@ -0,0 +1,359 @@
+# -*- coding: utf-8 -*-
+"""Medic_bot.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/#fileId=https%3A//huggingface.co/spaces/QueenS5Ella/Royalty/blob/main/Medic_bot.ipynb
+"""
+
+# IMPORT THE NECESSARY LIBARIES 1
+#Import Python libraries: Numpy and Pandas
+import pandas as pd
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+from openai import OpenAI
+import faiss
+import numpy as np
+
+#import libraries &modules for data visualization
+from pandas.plotting import scatter_matrix
+from matplotlib import pyplot
+
+#import scikit-learn module for algoruthm/model: Linear Regression
+from sklearn.neighbors import KNeighborsRegressor
+
+#import scikit learn module to split the dataset into train/test sub-datasets
+from sklearn.model_selection import train_test_split
+
+#Import scikit-learn module for K-fold cross validation - algorithm/model evluation & vallidation
+from sklearn.model_selection import KFold
+from sklearn.model_selection import cross_val_score
+
+#Import sckit-learn module for classification report
+from sklearn.metrics import classification_report
+
+from sklearn.preprocessing import LabelEncoder
+from sklearn.preprocessing import OrdinalEncoder
+
+# IMPORTATION OF NECESSARY LIBRARIES 2
+import os # for handling data
+import re # for text preprocessing
+
+# For Natural Language Processing tasks
+import nltk
+from sklearn.model_selection import train_test_split
+
+nltk.download("punkt")
+nltk.download("stopwords")
+
+# Optional: for vectorization and building of the models
+from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
+
+#IMPORTATION OF THE DIFFERENT MODELS FOR THE CHATBOT
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestRegressor
+import xgboost as xgb
+from sklearn.linear_model import Ridge
+from sklearn.neural_network import MLPRegressor
+
+import scipy
+print(scipy.__version__)
+
+import gradio as gr
+
+# 🔑 Replace with your real OpenAI API key
+client = OpenAI(api_key = "sk-...")  # <- Replace this with your actual API key
+
+# 📄 Load dataset
+d1 = pd.read_csv("ai-medical-chatbot.csv")
+d1.dropna(subset=["Description", "Doctor"], inplace=True)
+
+vector1 = TfidfVectorizer()
+# Keep the sparse matrix — don't convert to dense
+qvs = vector1.fit_transform(d1["Description"])  # No .toarray()
+
+d1.head()
+
+def find_best_match(user_input):
+    user_vec = vector1.transform([user_input])  # Still a sparse matrix
+    similarities = cosine_similarity(user_vec, qvs)
+    best_idx = np.argmax(similarities[0])
+    best_score = float(similarities[0][best_idx])
+    return d1.iloc[best_idx]["Description"], d1.iloc[best_idx]["Doctor"], best_score
+
+# 🔍 Vectorize questions
+#vectorizer = TfidfVectorizer()
+#question_vectors = vectorizer.fit_transform(df["Question"]).toarray()
+
+# 🔎 Find the most similar FAQ match
+#def find_best_match(user_input):
+    #user_vec = vectorizer.transform([user_input]).toarray()
+    #similarities = cosine_similarity(user_vec, question_vectors)
+    #best_idx = np.argmax(similarities[0])
+   # best_score = float(similarities[0][best_idx])
+  #  return df.iloc[best_idx]["Question"], df.iloc[best_idx]["Answer"], best_score
+
+# 🤖 Query OpenAI if no good FAQ match
+def query_gpt(user_input):
+    try:
+        response = client.chat.completions.create(
+            model="gpt-4",  # or use "gpt-3.5-turbo"
+            messages=[
+                {"role": "system", "content": "You are a pediatric pulmonology expert."},
+                {"role": "user", "content": user_input},
+                {"role": "assistant", "content": "Hello"}
+            ]
+        )
+        return response.choices[0].message["content"]
+    except Exception as e:
+        return f"⚠️ GPT Error: {str(e)}"
+
+# 💬 Chatbot response logic
+def chatbot_response(user_input):
+    if not user_input.strip():
+        return "Please enter a question."
+
+    try:
+        matched_q, matched_a, score = find_best_match(user_input)
+        if score > 0.75:
+            return f"📚 **Answer from FAQ**:\n\n**Q:** {matched_q}\n**A:** {matched_a}"
+        else:
+            gpt_answer = query_gpt(user_input)
+            return f"🤖 **Answer from GPT-4**:\n\n{gpt_answer}"
+    except Exception as e:
+        return f"❌ Error processing your question: {str(e)}"
+
+# 🌐 Launch Gradio interface
+gr.Interface(
+    fn=chatbot_response,
+    inputs=gr.Textbox(label="Ask any pediatric pulmonology related questions"),
+    outputs=gr.Textbox(label="Response", lines=10),
+    title="Pediatric Pulmonology Medicbot",
+    description="Answers common non-critical questions about pediatric pulmonology using a mix of FAQ and GPT-4."
+).launch(share=True)
+
+# Set your OpenAI key
+#openai.api_key = "sk-..."  # <- Replace this with your actual API key
+
+# Load CSV
+chat = pd.read_csv("PedMedQA_final.csv")
+
+chat.head()
+
+chat.describe()
+
+chat.isnull().sum()
+
+chat.shape
+
+chat.info()
+
+chat["answer"]. unique()
+
+chat["answer"].value_counts()
+
+chat["answer"] = chat["answer"].fillna("Reassurance")
+print(chat["answer"])
+
+chat["age_years"].unique
+
+chat["age_years"].value_counts
+
+chat.head()
+
+chat.dtypes
+
+chat.dropna(subset=["question", "answer"], inplace=True)
+chat.drop_duplicates(subset=["question"], inplace=True)
+
+chat.isnull().sum()
+
+#oe = OrdinalEncoder()
+
+#chat["index"] = oe.fit_transform(chat[["index"]])
+chat["index"].head(3)
+
+#chat["meta_info"] = oe.fit_transform(chat[["meta_info"]])
+chat["meta_info"].head(3)
+
+#chat["question"] = oe.fit_transform(chat[["question"]])
+chat["question"].head(3)
+
+#chat["answer_idx"] = oe.fit_transform(chat[["answer_idx"]])
+chat["answer_idx"].head(3)
+
+#chat["answer"] = oe.fit_transform(chat[["answer"]])
+chat["answer"].head(3)
+
+#chat["options"] = oe.fit_transform(chat[["options"]])
+chat["options"].head(3)
+
+chat.shape
+
+chat.columns
+
+from sklearn.linear_model import LassoCV
+from sklearn.feature_selection import SelectFromModel
+
+#clf = LassoCV.fit(X_train, Y_trarin)
+#importance = np.abs(clf.coef)
+#print(importance)
+
+while True:
+    user_input = input("You can ask me any pediatric pulmonology related question (or type 'exit'): ")
+
+    if user_input.lower() == "exit":
+        break
+
+    response = chatbot_response(user_input)
+    print(response)
+
+#response = chatbot_response(ui)
+#print(response)
+chat.dropna(subset=["question", "answer"], inplace=True)
+
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+# Vectorize the questions using TF-IDF
+# ✅ 1. Fit and transform your dataset questions
+vector1 = TfidfVectorizer()
+qvs = vector1.fit_transform(chat["question"]).toarray()
+
+# ✅ 2. Later, transform user input using the same vectorizer
+user_vec = vector1.transform([user_input]).toarray()
+
+# 🔌 Connect to OpenAI
+#openai.api_key = "your-openai-api-key"  # Replace with your real key
+
+# 📄 Step 1: Load your dataset
+df.dropna(subset=["Question", "Answer"], inplace=True)
+
+# 🧠 Step 2: Vectorize dataset questions
+#vectorizer = TfidfVectorizer()
+#question_vectors = vectorizer.fit_transform(df["Question"]).toarray()
+
+# 🔍 Step 3: Find most similar question
+def find_best_match(user_input):
+    user_vec = vector1.transform([user_input]).toarray()
+    similarities = cosine_similarity(user_vec, qvs)
+    best_idx = np.argmax(similarities[0])
+    best_score = similarities[0][answer_idx]
+    return df.iloc[best_idx]["question"], chat.iloc[best_idx]["answer"], best_score
+
+# 🤖 Step 4: Fallback to GPT-4 if no good match
+def query_gpt(user_input):
+    response = client.chat.completions.create(
+        model="gpt-4",
+        messages=[
+            {"role": "system", "content": "You are a pediatric pulmonology expert."},
+            {"role": "user", "content": user_input}
+        ]
+    )
+try:
+    # some risky code
+    risky_function()
+except Exception as e:
+    print(f"An error occurred: {e}")
+
+# 💬 Step 5: Define chatbot logic
+def chatbot_response(user_input):
+    matched_q, matched_a, score = find_best_match(user_input)
+    if score > 0.75:
+        return f"📚 Answer from FAQ:\nQ: {matched_q}\nA: {matched_a}"
+    else:
+        return f"🤖 Answer from GPT-4:\n{query_gpt(user_input)}"
+
+# 🌐 Step 6: Launch Gradio interface
+gr.Interface(
+    fn=chatbot_response,
+    inputs=gr.Textbox(label="Ask any pediatric pulmonology related question"),
+    outputs=gr.Textbox(label="Response"),
+    title="Royalty Medic_bot",
+    description="Get non-crtical answers to common pediatric respiratory health questions."
+).launch(share=True)
+
+
+def find_best_match(user_input):
+    input_vec = vectorizer.transform([user_input]).toarray()
+    sims = cosine_similarity(input_vec, question_vectors)
+    idx = np.argmax(sims)
+    score = sims[0][answer_idx]
+    return chat.iloc[answer_idx]["Question"], chat.iloc[answer_idx]["Answer"], score
+
+while True:
+    user_input = input("🧒 Ask a pediatric pulmonology question (or type 'exit'): ")
+    if user_input.lower() == "exit":
+        print("👋 Goodbye!")
+        break
+    print(chatbot_response(user_input))
+
+
+def chatbot_gradio_interface(user_input):
+    return chatbot_response(user_input)
+
+gr.Interface(fn=chatbot_gradio_interface,
+             inputs="text",
+             outputs="text",
+             title="Pediatric Pulmonology Medicbot",
+             description="Ask any question related to pediatric lung health.").launch(share=True)
+
+
+
+
+
+# Build FAISS index for similarity search
+index = faiss.IndexFlatL2(question_vectors.shape[1])
+index.add(np.array(question_vectors))
+
+# Function to find the closest question
+def find_most_similar_question(user_question, top_k=1):
+    user_vec = vectorizer.transform([user_question]).toarray()
+    D, I = index.search(user_vec, top_k)
+    return df.iloc[I[0][0]]["Question"], df.iloc[I[0][0]]["Answer"]
+
+# Function to query a language model
+def ask_openai(question, model="gpt-4"):
+    try:
+        response = client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": "You are a pediatric pulmonology expert."},
+                {"role": "user", "content": question},
+            ],
+            temperature=0.3,
+        )
+        return response.choices[0].message["content"]
+    except Exception as e:
+        print(f"Error with {model}: {e}")
+        return None
+
+# Main chatbot function
+def pediatric_pulmonology_chatbot(user_input):
+    matched_question, matched_answer = find_most_similar_question(user_input)
+
+    similarity = cosine_similarity(
+        vectorizer.transform([user_input]), vectorizer.transform([matched_question])
+    )[0][0]
+
+    if similarity > 0.7:
+        return f"(From Knowledge Base)\nQ: {matched_question}\nA: {matched_answer}"
+    else:
+        # Try GPT-4 first
+        reply = ask_openai(user_input, model="gpt-4")
+        if reply:
+            return f"(From GPT-4)\n{reply}"
+        else:
+            # Fallback to GPT-3.5
+            reply = ask_openai(user_input, model="gpt-3.5-turbo")
+            if reply:
+                return f"(From GPT-3.5)\n{reply}"
+            else:
+                return "Sorry, I couldn't find an answer to that."
+
+# 🔁 Example interaction
+while True:
+    user_input = input("\n👶 Ask a pediatric pulmonology question (or type 'exit'): ")
+    if user_input.lower() == "exit":
+        break
+    print(pediatric_pulmonology_chatbot(user_input))