Update app.py

app.py

@@ -1,36 +1,52 @@
 import gradio as gr
 import tensorflow as tf
 import numpy as np
+import pickle
 
-# Load the trained model locally
-model_path = 'doctor_ai_model.h5'
-model = tf.keras.models.load_model(model_path)
+# Paths to model and tokenizer
+model_path = "doctor_ai_model.h5"
+tokenizer_path = "tokenizer.pkl"
+label_encoder_path = "label_encoder.pkl"
 
-# Tokenizer setup (you may need to recreate a tokenizer if your model requires it)
-# Assuming you have a tokenizer saved locally
-# tokenizer = load_your_tokenizer()
+# Load the trained model
+try:
+    model = tf.keras.models.load_model(model_path)
+except Exception as e:
+    print(f"Error loading model: {e}")
 
-def chatbot(question):
-    # Preprocessing the question (similar to how you did it during training)
-    # Convert the question into a format the model can understand (tokenization and padding)
-    # Example placeholder for preprocessing:
-    question_input = preprocess_question(question)  # Replace with actual preprocessing
-    
-    # Get model prediction
-    prediction = model.predict(question_input)
-    
-    # Postprocess the prediction into readable text
-    answer = postprocess_prediction(prediction)  # Replace with actual postprocessing
-    
-    return answer
+# Load the tokenizer and label encoder
+with open(tokenizer_path, 'rb') as handle:
+    tokenizer = pickle.load(handle)
 
-# Set up the Gradio interface
-iface = gr.Interface(fn=chatbot, 
-                     inputs="text", 
-                     outputs="text", 
-                     title="Doctor AI - Offline",
-                     description="Ask Doctor AI your medical questions. **This chatbot works completely offline**.",
-                     article="This model is trained on a custom dataset and designed to work without an internet connection.")
+with open(label_encoder_path, 'rb') as handle:
+    label_encoder = pickle.load(handle)
 
-# Launch the interface
-iface.launch()
+# Define the prediction function
+def predict_answer(question):
+    try:
+        # Tokenize the input question
+        seq = tokenizer.texts_to_sequences([question])
+        padded_seq = tf.keras.preprocessing.sequence.pad_sequences(seq, maxlen=27)  # Adjust maxlen to match your model
+        
+        # Make prediction
+        prediction = model.predict(padded_seq)
+        
+        # Convert prediction to label
+        predicted_label = label_encoder.inverse_transform(np.argmax(prediction, axis=1))
+        
+        return predicted_label[0]
+    except Exception as e:
+        return f"Error during prediction: {e}"
+
+# Define the Gradio interface
+iface = gr.Interface(
+    fn=predict_answer,
+    inputs=gr.inputs.Textbox(lines=2, placeholder="Enter your question..."),
+    outputs="text",
+    title="Doctor AI Chatbot",
+    description="This AI chatbot provides answers based on your medical-related questions. Works completely offline."
+)
+
+# Launch the Gradio app
+if __name__ == "__main__":
+    iface.launch()