Update app.py

app.py

@@ -1,52 +1,38 @@
-import gradio as gr
-import tensorflow as tf
-import numpy as np
 import pickle
+import tensorflow as tf
+from tensorflow import keras
+from fastapi import FastAPI
+from pydantic import BaseModel
+import uvicorn
 
-# Paths to model and tokenizer
-model_path = "doctor_ai_model.h5"
-tokenizer_path = "tokenizer.pkl"
-label_encoder_path = "label_encoder.pkl"
-
-# Load the trained model
-try:
-    model = tf.keras.models.load_model(model_path)
-except Exception as e:
-    print(f"Error loading model: {e}")
-
-# Load the tokenizer and label encoder
-with open(tokenizer_path, 'rb') as handle:
-    tokenizer = pickle.load(handle)
+# Load the model
+model_path = 'doctor_ai_model.h5'
+model = keras.models.load_model(model_path)
 
-with open(label_encoder_path, 'rb') as handle:
-    label_encoder = pickle.load(handle)
+# Create FastAPI app
+app = FastAPI()
 
-# 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 request model
+class InputData(BaseModel):
+    input_data: list
 
-# 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."
-)
+# Define the prediction endpoint
+@app.post('/predict')
+async def predict(data: InputData):
+    # Prepare input data
+    input_array = tf.convert_to_tensor(data.input_data)
+    
+    # Check if input shape matches the model's input shape
+    expected_shape = (None, 27)
+    if input_array.shape[1] != expected_shape[1]:
+        return {'error': f'Input data must have shape: {expected_shape}'}
+    
+    # Make a prediction
+    prediction = model.predict(tf.expand_dims(input_array, axis=0))  # Expand dims to match batch size
+    predicted_class = tf.argmax(prediction, axis=1).numpy().tolist()
+    
+    return {'predicted_class': predicted_class}
 
-# Launch the Gradio app
-if __name__ == "__main__":
-    iface.launch()
+# Start the FastAPI server (this will run offline)
+if __name__ == '__main__':
+    uvicorn.run(app, host='127.0.0.1', port=8000)  # Use localhost for offline mode