Update app.py

app.py

@@ -1,168 +1,11 @@
-# import requests
-# import numpy as np
-# import tensorflow as tf
-# import tensorflow_hub as hub
-# import gradio as gr
-# from PIL import Image
-
-# # Load models
-# #model_initial = keras.models.load_model(
-# #    "models/initial_model.h5", custom_objects={'KerasLayer': hub.KerasLayer}
-# #)
-# #model_tumor = keras.models.load_model(
-# #    "models/model_tumor.h5", custom_objects={'KerasLayer': hub.KerasLayer}
-# #)
-# #model_stroke = keras.models.load_model(
-# #    "models/model_stroke.h5", custom_objects={'KerasLayer': hub.KerasLayer}
-# #)
-# #model_alzheimer = keras.models.load_model(
-# #    "models/model_alzheimer.h5", custom_objects={'KerasLayer': hub.KerasLayer}
-
-# # API key and user ID for on-demand
-# api_key = 'KGSjxB1uptfSk8I8A7ciCuNT9Xa3qWC3'
-# external_user_id = 'plugin-1717464304'
-
-# # Step 1: Create a chat session with the API
-# def create_chat_session():
-#     create_session_url = 'https://api.on-demand.io/chat/v1/sessions'
-#     create_session_headers = {
-#         'apikey': api_key
-#     }
-#     create_session_body = {
-#         "pluginIds": [],
-#         "externalUserId": external_user_id
-#     }
-#     response = requests.post(create_session_url, headers=create_session_headers, json=create_session_body)
-#     response_data = response.json()
-#     session_id = response_data['data']['id']
-#     return session_id
-
-# # Step 2: Submit query to the API
-# def submit_query(session_id, query):
-#     submit_query_url = f'https://api.on-demand.io/chat/v1/sessions/{session_id}/query'
-#     submit_query_headers = {
-#         'apikey': api_key
-#     }
-#     submit_query_body = {
-#         "endpointId": "predefined-openai-gpt4o",
-#         "query": query,
-#         "pluginIds": ["plugin-1712327325", "plugin-1713962163"],
-#         "responseMode": "sync"
-#     }
-#     response = requests.post(submit_query_url, headers=submit_query_headers, json=submit_query_body)
-#     return response.json()
-
-# # Combined disease model (placeholder)
-# class CombinedDiseaseModel(tf.keras.Model):
-#     def __init__(self, model_initial, model_alzheimer, model_tumor, model_stroke):
-#         super(CombinedDiseaseModel, self).__init__()
-#         self.model_initial = model_initial
-#         self.model_alzheimer = model_alzheimer
-#         self.model_tumor = model_tumor
-#         self.model_stroke = model_stroke
-#         self.disease_labels = ["Alzheimer's", 'No Disease', 'Stroke', 'Tumor']
-#         self.sub_models = {
-#             "Alzheimer's": model_alzheimer,
-#             'Tumor': model_tumor,
-#             'Stroke': model_stroke
-#         }
-
-#     def call(self, inputs):
-#         initial_probs = self.model_initial(inputs, training=False)
-#         main_disease_idx = tf.argmax(initial_probs, axis=1)
-#         main_disease = self.disease_labels[main_disease_idx[0].numpy()]
-#         main_disease_prob = initial_probs[0, main_disease_idx[0]].numpy()
-
-#         if main_disease == 'No Disease':
-#             sub_category = "No Disease"
-#             sub_category_prob = main_disease_prob
-#         else:
-#             sub_model = self.sub_models[main_disease]
-#             sub_category_pred = sub_model(inputs, training=False)
-#             sub_category = tf.argmax(sub_category_pred, axis=1).numpy()[0]
-#             sub_category_prob = sub_category_pred[0, sub_category].numpy()
-
-#             if main_disease == "Alzheimer's":
-#                 sub_category_label = ['Very Mild', 'Mild', 'Moderate']
-#             elif main_disease == 'Tumor':
-#                 sub_category_label = ['Glioma', 'Meningioma', 'Pituitary']
-#             elif main_disease == 'Stroke':
-#                 sub_category_label = ['Ischemic', 'Hemorrhagic']
-
-#             sub_category = sub_category_label[sub_category]
-
-#         return f"The MRI image shows {main_disease} with a probability of {main_disease_prob*100:.2f}%.\n" \
-#                f"The subcategory of {main_disease} is {sub_category} with a probability of {sub_category_prob*100:.2f}%."
-
-# # Placeholder function to process images
-# def process_image(image):
-#     image = image.resize((256, 256))
-#     image.convert("RGB")
-#     image_array = np.array(image) / 255.0
-#     image_array = np.expand_dims(image_array, axis=0)
-#     # Prediction logic here
-#     # predictions = cnn_model(image_array)
-#     return "Mock prediction: Disease identified with a probability of 85%."
-
-# # Function to handle patient info, query, and image processing
-# def gradio_interface(patient_info, query_type, image):
-#     if image is not None:
-#         image_response = process_image(image)
-
-#         # Call LLM with patient info and query
-#         session_id = create_chat_session()
-#         query = f"Patient Info: {patient_info}\nQuery Type: {query_type}"
-#         llm_response = submit_query(session_id, query)
-        
-#         # Debug: Print the full response to inspect it
-#         print("LLM Response:", llm_response)  # This will print the full response for inspection
-
-#         # Safely handle 'message' if it exists
-#         message = llm_response.get('data', {}).get('message', 'No message returned from LLM')
-
-#         # Check if message is empty and print the complete response if necessary
-#         if message == 'No message returned from LLM':
-#             print("Full LLM Response Data:", llm_response)  # Inspect the full LLM response for any helpful info
-
-#         response = f"Patient Info: {patient_info}\nQuery Type: {query_type}\n\n{image_response}\n\nLLM Response:\n{message}"
-#         return response
-#     else:
-#         return "Please upload an image."
-
-# # Gradio interface
-# iface = gr.Interface(
-#     fn=gradio_interface,
-#     inputs=[
-#         gr.Textbox(
-#             label="Patient Information",
-#             placeholder="Enter patient details here...",
-#             lines=5,
-#             max_lines=10
-#         ),
-#         gr.Textbox(
-#             label="Query Type",
-#             placeholder="Describe the type of diagnosis or information needed..."
-#         ),
-#         gr.Image(
-#             type="pil",
-#             label="Upload an MRI Image",
-#         )
-#     ],
-#     outputs=gr.Textbox(label="Response", placeholder="The response will appear here..."),
-#     title="Medical Diagnosis with MRI and LLM",
-#     description="Upload MRI images and provide patient information for a combined CNN model and LLM analysis."
-# )
-
-# iface.launch()
-
-
-
-
-
 import requests
 import gradio as gr
 import logging
 import json
+import tensorflow as tf
+import numpy as np
+from PIL import Image
+import io
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)
@@ -172,6 +15,39 @@ logger = logging.getLogger(__name__)
 api_key = 'KGSjxB1uptfSk8I8A7ciCuNT9Xa3qWC3'
 external_user_id = 'plugin-1717464304'
 
+# Load the keras model
+def load_model():
+    try:
+        model = tf.keras.models.load_model('model_epoch_01.h5.keras')
+        logger.info("Model loaded successfully")
+        return model
+    except Exception as e:
+        logger.error(f"Error loading model: {str(e)}")
+        raise
+
+# Preprocess image for model
+def preprocess_image(image):
+    try:
+        # Convert to numpy array if needed
+        if isinstance(image, Image.Image):
+            image = np.array(image)
+        
+        # Resize image to match model's expected input shape
+        # Note: Adjust these dimensions to match your model's requirements
+        target_size = (224, 224)  # Change this to match your model's input size
+        image = tf.image.resize(image, target_size)
+        
+        # Normalize pixel values
+        image = image / 255.0
+        
+        # Add batch dimension
+        image = np.expand_dims(image, axis=0)
+        
+        return image
+    except Exception as e:
+        logger.error(f"Error preprocessing image: {str(e)}")
+        raise
+
 def create_chat_session():
     try:
         create_session_url = 'https://api.on-demand.io/chat/v1/sessions'
@@ -192,7 +68,7 @@ def create_chat_session():
         logger.error(f"Error creating chat session: {str(e)}")
         raise
 
-def submit_query(session_id, query):
+def submit_query(session_id, query, image_analysis=None):
     try:
         submit_query_url = f'https://api.on-demand.io/chat/v1/sessions/{session_id}/query'
         submit_query_headers = {
@@ -200,10 +76,15 @@ def submit_query(session_id, query):
             'Content-Type': 'application/json'
         }
         
+        # Include image analysis in the query if available
+        query_with_image = query
+        if image_analysis:
+            query_with_image += f"\n\nImage Analysis Results: {image_analysis}"
+        
         structured_query = f"""
-        Based on the following patient information, provide a detailed medical analysis in JSON format:
+        Based on the following patient information and image analysis, provide a detailed medical analysis in JSON format:
 
-        {query}
+        {query_with_image}
 
         Return only valid JSON with these fields:
         - diagnosis_details
@@ -214,6 +95,7 @@ def submit_query(session_id, query):
         - additional_tests (array)
         - precautions (array)
         - follow_up (string)
+        - image_findings (object with prediction and confidence)
         """
         
         submit_query_body = {
@@ -234,11 +116,9 @@ def submit_query(session_id, query):
 def extract_json_from_answer(answer):
     """Extract and clean JSON from the LLM response"""
     try:
-        # First try to parse the answer directly
         return json.loads(answer)
     except json.JSONDecodeError:
         try:
-            # If that fails, try to find JSON content and parse it
             start_idx = answer.find('{')
             end_idx = answer.rfind('}') + 1
             if start_idx != -1 and end_idx != 0:
@@ -248,10 +128,31 @@ def extract_json_from_answer(answer):
             logger.error("Failed to parse JSON from response")
             raise
 
-def gradio_interface(patient_info):
+# Initialize the model
+model = load_model()
+
+def gradio_interface(patient_info, image):
     try:
+        # Process image if provided
+        image_analysis = None
+        if image is not None:
+            # Preprocess image
+            processed_image = preprocess_image(image)
+            
+            # Get model prediction
+            prediction = model.predict(processed_image)
+            
+            # Format prediction results
+            # Note: Adjust this based on your model's output format
+            image_analysis = {
+                "prediction": float(prediction[0][0]),  # Adjust indexing based on your model's output
+                "confidence": float(prediction[0][0]) * 100  # Convert to percentage
+            }
+        
+        # Create chat session and submit query
         session_id = create_chat_session()
-        llm_response = submit_query(session_id, patient_info)
+        llm_response = submit_query(session_id, patient_info, 
+                                  json.dumps(image_analysis) if image_analysis else None)
         
         if not llm_response or 'data' not in llm_response or 'answer' not in llm_response['data']:
             raise ValueError("Invalid response structure")
@@ -259,7 +160,7 @@ def gradio_interface(patient_info):
         # Extract and clean JSON from the response
         json_data = extract_json_from_answer(llm_response['data']['answer'])
         
-        # Return clean JSON string without extra formatting
+        # Return clean JSON string
         return json.dumps(json_data)
     
     except Exception as e:
@@ -275,6 +176,11 @@ iface = gr.Interface(
             placeholder="Enter patient details including: symptoms, medical history, current medications, age, gender, and any relevant test results...",
             lines=5,
             max_lines=10
+        ),
+        gr.Image(
+            label="Medical Image",
+            type="numpy",
+            optional=True
         )
     ],
     outputs=gr.Textbox(
@@ -283,8 +189,142 @@ iface = gr.Interface(
         lines=15
     ),
     title="Medical Diagnosis Assistant",
-    description="Enter detailed patient information to receive a structured medical analysis in JSON format."
+    description="Enter patient information and optionally upload a medical image for analysis."
 )
 
 if __name__ == "__main__":
-    iface.launch()
+    iface.launch()
+
+
+
+
+
+# import requests
+# import gradio as gr
+# import logging
+# import json
+
+# # Set up logging
+# logging.basicConfig(level=logging.INFO)
+# logger = logging.getLogger(__name__)
+
+# # API key and user ID for on-demand
+# api_key = 'KGSjxB1uptfSk8I8A7ciCuNT9Xa3qWC3'
+# external_user_id = 'plugin-1717464304'
+
+# def create_chat_session():
+#     try:
+#         create_session_url = 'https://api.on-demand.io/chat/v1/sessions'
+#         create_session_headers = {
+#             'apikey': api_key,
+#             'Content-Type': 'application/json'
+#         }
+#         create_session_body = {
+#             "pluginIds": [],
+#             "externalUserId": external_user_id
+#         }
+        
+#         response = requests.post(create_session_url, headers=create_session_headers, json=create_session_body)
+#         response.raise_for_status()
+#         return response.json()['data']['id']
+    
+#     except requests.exceptions.RequestException as e:
+#         logger.error(f"Error creating chat session: {str(e)}")
+#         raise
+
+# def submit_query(session_id, query):
+#     try:
+#         submit_query_url = f'https://api.on-demand.io/chat/v1/sessions/{session_id}/query'
+#         submit_query_headers = {
+#             'apikey': api_key,
+#             'Content-Type': 'application/json'
+#         }
+        
+#         structured_query = f"""
+#         Based on the following patient information, provide a detailed medical analysis in JSON format:
+
+#         {query}
+
+#         Return only valid JSON with these fields:
+#         - diagnosis_details
+#         - probable_diagnoses (array)
+#         - treatment_plans (array)
+#         - lifestyle_modifications (array)
+#         - medications (array of objects with name and dosage)
+#         - additional_tests (array)
+#         - precautions (array)
+#         - follow_up (string)
+#         """
+        
+#         submit_query_body = {
+#             "endpointId": "predefined-openai-gpt4o",
+#             "query": structured_query,
+#             "pluginIds": ["plugin-1712327325", "plugin-1713962163"],
+#             "responseMode": "sync"
+#         }
+        
+#         response = requests.post(submit_query_url, headers=submit_query_headers, json=submit_query_body)
+#         response.raise_for_status()
+#         return response.json()
+    
+#     except requests.exceptions.RequestException as e:
+#         logger.error(f"Error submitting query: {str(e)}")
+#         raise
+
+# def extract_json_from_answer(answer):
+#     """Extract and clean JSON from the LLM response"""
+#     try:
+#         # First try to parse the answer directly
+#         return json.loads(answer)
+#     except json.JSONDecodeError:
+#         try:
+#             # If that fails, try to find JSON content and parse it
+#             start_idx = answer.find('{')
+#             end_idx = answer.rfind('}') + 1
+#             if start_idx != -1 and end_idx != 0:
+#                 json_str = answer[start_idx:end_idx]
+#                 return json.loads(json_str)
+#         except (json.JSONDecodeError, ValueError):
+#             logger.error("Failed to parse JSON from response")
+#             raise
+
+# def gradio_interface(patient_info):
+#     try:
+#         session_id = create_chat_session()
+#         llm_response = submit_query(session_id, patient_info)
+        
+#         if not llm_response or 'data' not in llm_response or 'answer' not in llm_response['data']:
+#             raise ValueError("Invalid response structure")
+        
+#         # Extract and clean JSON from the response
+#         json_data = extract_json_from_answer(llm_response['data']['answer'])
+        
+#         # Return clean JSON string without extra formatting
+#         return json.dumps(json_data)
+    
+#     except Exception as e:
+#         logger.error(f"Error in gradio_interface: {str(e)}")
+#         return json.dumps({"error": str(e)})
+
+# # Gradio interface
+# iface = gr.Interface(
+#     fn=gradio_interface,
+#     inputs=[
+#         gr.Textbox(
+#             label="Patient Information",
+#             placeholder="Enter patient details including: symptoms, medical history, current medications, age, gender, and any relevant test results...",
+#             lines=5,
+#             max_lines=10
+#         )
+#     ],
+#     outputs=gr.Textbox(
+#         label="Medical Analysis",
+#         placeholder="JSON analysis will appear here...",
+#         lines=15
+#     ),
+#     title="Medical Diagnosis Assistant",
+#     description="Enter detailed patient information to receive a structured medical analysis in JSON format."
+# )
+
+# if __name__ == "__main__":
+#     iface.launch()