Update app.py

app.py

@@ -7,181 +7,131 @@ import tensorflow_hub as hub
 import numpy as np
 from PIL import Image
 import io
+import os
 
-# Set up logging
-logging.basicConfig(level=logging.INFO)
+# Set up logging with more detailed format
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
 
 # API key and user ID for on-demand
 api_key = 'KGSjxB1uptfSk8I8A7ciCuNT9Xa3qWC3'
 external_user_id = 'plugin-1717464304'
 
-# Load the keras model
 def load_model():
     try:
-        # Define custom objects dictionary with batch normalization handling
+        model_path = 'model_epoch_01.h5.keras'
+        
+        # Check if model file exists
+        if not os.path.exists(model_path):
+            raise FileNotFoundError(f"Model file not found at {model_path}")
+            
+        logger.info(f"Attempting to load model from {model_path}")
+        
+        # Define custom objects dictionary
         custom_objects = {
             'KerasLayer': hub.KerasLayer,
-            'BatchNormalization': tf.keras.layers.BatchNormalization
+            'BatchNormalization': tf.keras.layers.BatchNormalization,
+            # Add more custom objects if needed
         }
         
-        # Load model with custom object scope and proper batch norm behavior
-        with tf.keras.utils.custom_object_scope(custom_objects):
-            model = tf.keras.models.load_model(
-                'model_epoch_01.h5.keras',
-                custom_objects=custom_objects,
-                compile=False  # Don't compile the model on load
-            )
+        # Try loading with different configurations
+        try:
+            logger.info("Attempting to load model with custom objects...")
+            with tf.keras.utils.custom_object_scope(custom_objects):
+                model = tf.keras.models.load_model(model_path, compile=False)
+        except Exception as e:
+            logger.error(f"Failed to load with custom objects: {str(e)}")
+            logger.info("Attempting to load model without custom objects...")
+            model = tf.keras.models.load_model(model_path, compile=False)
+        
+        # Verify model loaded correctly
+        if model is None:
+            raise ValueError("Model loading returned None")
             
+        # Print model summary for debugging
+        model.summary()
         logger.info("Model loaded successfully")
         return model
+        
     except Exception as e:
         logger.error(f"Error loading model: {str(e)}")
+        logger.error(f"Model loading failed with exception type: {type(e)}")
         raise
 
-# Preprocess image for model
+# Initialize the model globally
+try:
+    logger.info("Initializing model...")
+    model = load_model()
+    logger.info("Model initialization completed")
+except Exception as e:
+    logger.error(f"Failed to initialize model: {str(e)}")
+    model = None
+    
 def preprocess_image(image):
     try:
         # Convert to numpy array if needed
         if isinstance(image, Image.Image):
             image = np.array(image)
         
+        # Log image shape and type for debugging
+        logger.info(f"Input image shape: {image.shape}, dtype: {image.dtype}")
+        
         # Ensure image has 3 channels (RGB)
         if len(image.shape) == 2:  # Grayscale image
+            logger.info("Converting grayscale to RGB")
             image = np.stack((image,) * 3, axis=-1)
         elif len(image.shape) == 3 and image.shape[2] == 4:  # RGBA image
+            logger.info("Converting RGBA to RGB")
             image = image[:, :, :3]
             
         # Resize image to match model's expected input shape
         target_size = (224, 224)  # Change this to match your model's input size
         image = tf.image.resize(image, target_size)
+        logger.info(f"Resized image shape: {image.shape}")
         
         # Normalize pixel values
         image = image / 255.0
         
         # Add batch dimension
         image = np.expand_dims(image, axis=0)
+        logger.info(f"Final preprocessed image shape: {image.shape}")
         
         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'
-        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, image_analysis=None):
-    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'
-        }
-        
-        # 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 and image analysis, provide a detailed medical analysis in JSON format:
-        {query_with_image}
-        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)
-        - image_findings (object with prediction and confidence)
-        """
         
-        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:
-        return json.loads(answer)
-    except json.JSONDecodeError:
-        try:
-            # Find the first occurrence of '{' and last occurrence of '}'
-            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 format_prediction(prediction):
-    """Format model prediction into a standardized structure"""
-    try:
-        # Adjust this based on your model's output format
-        confidence = float(prediction[0][0])
-        return {
-            "prediction": "abnormal" if confidence > 0.5 else "normal",
-            "confidence": round(confidence * 100, 2)
-        }
     except Exception as e:
-        logger.error(f"Error formatting prediction: {str(e)}")
+        logger.error(f"Error preprocessing image: {str(e)}")
         raise
 
-# Initialize the model
-try:
-    model = load_model()
-except Exception as e:
-    logger.error(f"Failed to initialize model: {str(e)}")
-    model = None
-
 def gradio_interface(patient_info, image):
     try:
         if model is None:
-            raise ValueError("Model not properly initialized")
+            logger.error("Model is not initialized")
+            return json.dumps({
+                "error": "Model initialization failed. Please check the logs for details.",
+                "status": "error"
+            }, indent=2)
             
         # Process image if provided
         image_analysis = None
         if image is not None:
+            logger.info("Processing uploaded image")
             # Preprocess image
             processed_image = preprocess_image(image)
             
             # Get model prediction
+            logger.info("Running model prediction")
             prediction = model.predict(processed_image)
+            logger.info(f"Raw prediction shape: {prediction.shape}")
             
             # Format prediction results
-            image_analysis = format_prediction(prediction)
+            image_analysis = {
+                "prediction": float(prediction[0][0]),
+                "confidence": float(prediction[0][0]) * 100
+            }
+            logger.info(f"Image analysis results: {image_analysis}")
         
         # Create chat session and submit query
         session_id = create_chat_session()
@@ -194,13 +144,17 @@ def gradio_interface(patient_info, image):
         # Extract and clean JSON from the response
         json_data = extract_json_from_answer(llm_response['data']['answer'])
         
-        # Format output for better readability
         return json.dumps(json_data, indent=2)
-    
+        
     except Exception as e:
         logger.error(f"Error in gradio_interface: {str(e)}")
-        return json.dumps({"error": str(e)}, indent=2)
-        
+        return json.dumps({
+            "error": str(e),
+            "status": "error",
+            "details": "Check the application logs for more information"
+        }, indent=2)
+
+# Gradio interface
 iface = gr.Interface(
     fn=gradio_interface,
     inputs=[
@@ -213,7 +167,7 @@ iface = gr.Interface(
         gr.Image(
             label="Medical Image",
             type="numpy",
-            interactive=True,  # This replaces the 'optional' parameter
+            interactive=True
         )
     ],
     outputs=gr.Textbox(
@@ -226,7 +180,15 @@ iface = gr.Interface(
 )
 
 if __name__ == "__main__":
-    iface.launch()
+    # Add version information logging
+    logger.info(f"TensorFlow version: {tf.__version__}")
+    logger.info(f"TensorFlow Hub version: {hub.__version__}")
+    logger.info(f"Gradio version: {gr.__version__}")
+    
+    iface.launch(
+        server_name="0.0.0.0",
+        debug=True
+    )