Update app.py

app.py

@@ -9,106 +9,89 @@ import cv2
 from PIL import Image
 from sklearn.preprocessing import LabelEncoder
 
-# Initialize LabelEncoder for gender encoding
+# Load trained model and scaler
+model = joblib.load('lgbm_model.pkl')  # Replace with actual path
+scaler = joblib.load('minmax_scaler.pkl')  # Replace with actual path
+
+# Get expected feature names from the model
+expected_features = model.feature_name_  # Extracts trained feature names
+
+# Initialize LabelEncoder for gender encoding (if used in training)
 gender_encoder = LabelEncoder()
-gender_encoder.fit(['Female', 'Male'])  # Ensuring correct label mapping
+gender_encoder.fit(['Female', 'Male'])  # Ensure correct mapping
 
-# Function to extract features from the image
+# Function to extract features
 def extract_features(image):
-    # Convert PIL image to NumPy array
     image = np.array(image)
 
-    # Extract RGB means
-    meanr = np.mean(image[:, :, 0])  
-    meang = np.mean(image[:, :, 1])  
-    meanb = np.mean(image[:, :, 2])  
+    meanr = np.mean(image[:, :, 0])
+    meang = np.mean(image[:, :, 1])
+    meanb = np.mean(image[:, :, 2])
 
-    # Convert to HSI and compute HHR
     hsv_image = rgb2hsv(image)
     hue = hsv_image[:, :, 0]
     high_hue_pixels = np.sum(hue > 0.95)
     total_pixels = hue.size
     HHR = high_hue_pixels / total_pixels
 
-    # Convert to Grayscale
     gray_image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
 
-    # Compute Entropy
     Ent = shannon_entropy(gray_image)
-
-    # Compute Brightness
     B = np.mean(gray_image)
 
-    # Define sliding window filters
     def g1_filter(window): return window[4] - np.min(window)
     def g2_filter(window): return np.max(window) - window[4]
     def g3_filter(window): return window[4] - np.mean(window)
     def g4_filter(window): return np.std(window)
     def g5_filter(window): return window[4]
 
-    # Apply filters with 3x3 window
     g1 = generic_filter(gray_image, g1_filter, size=3).mean()
     g2 = generic_filter(gray_image, g2_filter, size=3).mean()
     g3 = generic_filter(gray_image, g3_filter, size=3).mean()
     g4 = generic_filter(gray_image, g4_filter, size=3).mean()
     g5 = generic_filter(gray_image, g5_filter, size=3).mean()
 
-    # Return extracted features
     return {
         "meanr": meanr, "meang": meang, "meanb": meanb,
         "HHR": HHR, "Ent": Ent, "B": B, "g1": g1,
         "g2": g2, "g3": g3, "g4": g4, "g5": g5,
     }
 
-# Function to predict hemoglobin value
+# Prediction function
 def predict_hemoglobin(age, gender, image):
     try:
-        # Validate image input
         if image is None:
             return "Error: No image uploaded. Please upload an image."
 
         if not isinstance(image, Image.Image):
             return "Error: Invalid image format. Please upload a valid image file."
 
-        # Validate gender input
-        if gender not in ["Male", "Female"]:
-            return "Error: Invalid gender selected."
-
-        print(f"Received Gender: {gender}")  # Debugging line
-
-        # Extract features from the image
+        # Extract features
         features = extract_features(image)
-
-        # Encode gender as a numerical value
-        features['Gender'] = gender_encoder.transform([gender])[0]
-        features['Age'] = age
+        
+        # Encode gender only if the model was trained with it
+        if "Gender" in expected_features:
+            features["Gender"] = gender_encoder.transform([gender])[0]
+        
+        features["Age"] = age
 
         # Convert to DataFrame
         features_df = pd.DataFrame([features])
 
-        # Load trained model and scaler
-        model = joblib.load('lgbm_model.pkl')  # Replace with actual path
-        scaler = joblib.load('minmax_scaler.pkl')  # Replace with actual path
-
-        # Ensure features match expected columns
-        expected_columns = ['meanr', 'meang', 'meanb', 'HHR', 'Ent', 'B', 'g1', 'g2', 'g3', 'g4', 'g5', 'Age', 'Gender']
-        for col in expected_columns:
-            if col not in features_df:
-                features_df[col] = 0  # Assign default value if missing
-
-        features_df = features_df[expected_columns]  # Ensure correct column order
+        # Ensure only model-expected features are used
+        features_df = features_df[expected_features]  # Select only required columns
 
         # Apply scaling
-        features_df_scaled = scaler.transform(features_df)
+        features_scaled = scaler.transform(features_df)
 
         # Predict hemoglobin
-        hemoglobin = model.predict(features_df_scaled)[0]
+        hemoglobin = model.predict(features_scaled)[0]
 
         return f"Predicted Hemoglobin Value: {hemoglobin:.2f}"
 
     except Exception as e:
-        print(f"An error occurred during prediction: {e}")
-        return "An error occurred during prediction. Please try again."
+        print(f"Error during prediction: {e}")
+        return "An error occurred. Please check inputs and try again."
 
 # Gradio interface
 with gr.Blocks() as anemia_detection_app:
@@ -116,7 +99,7 @@ with gr.Blocks() as anemia_detection_app:
 
     with gr.Row():
         age_input = gr.Number(label="Age", value=25)
-        gender_input = gr.Radio(label="Gender", choices=["Male", "Female"], value="Male", type="value")  # ✅ FIXED
+        gender_input = gr.Radio(label="Gender", choices=["Male", "Female"], value="Male", type="value")
     
     image_input = gr.Image(label="Upload Retinal Image", type="pil")
     output_text = gr.Textbox(label="Predicted Hemoglobin Value")