Update app.py

app.py

@@ -3,24 +3,25 @@ import pandas as pd
 import numpy as np
 import pickle
 
-print("\n--- Creating Gradio Interface ---")
+# ==============================
+# Load Saved Model Files
+# ==============================
 
-file = 'final_model.pkl'
-final_model = pickle.load(file)
+with open("final_model.pkl", "rb") as f:
+    final_model = pickle.load(f)
 
-file = 'scaler.pkl'
-scaler = pickle.load(file)
+with open("scaler.pkl", "rb") as f:
+    scaler = pickle.load(f)
 
-file = 'label_encoder.pkl'
-label_encoder = pickle.load(file)
+with open("label_encoder.pkl", "rb") as f:
+    label_encoder = pickle.load(f)
 
-print("✓ Models, Scaler, and Label Encoder loaded successfully.")
 
-# Get original feature names from X (from previous execution, assuming it's available or re-derivable)
-# If X is not in kernel state, we'd need to load the original dataset and derive column names
-# For this example, assuming X.columns can be reconstructed or is available.
-# Let's manually list the original 30 feature columns based on previous EDA/preprocessing steps
-original_feature_columns = [
+# ==============================
+# Feature Columns (Same as Training)
+# ==============================
+
+feature_columns = [
     'radius_mean', 'texture_mean', 'perimeter_mean', 'area_mean',
     'smoothness_mean', 'compactness_mean', 'concavity_mean',
     'concave points_mean', 'symmetry_mean', 'fractal_dimension_mean',
@@ -32,66 +33,63 @@ original_feature_columns = [
     'concave points_worst', 'symmetry_worst', 'fractal_dimension_worst'
 ]
 
-def predict_cancer( *args ):
-    """
-    Prediction function for Gradio interface.
-    Takes 30 numerical inputs, preprocesses them, and returns diagnosis and confidence.
-    """
-    if len(args) != len(original_feature_columns):
-        raise ValueError(f"Expected {len(original_feature_columns)} inputs, but got {len(args)}")
-
-    # Create a DataFrame from the inputs
-    input_data = pd.DataFrame([args], columns=original_feature_columns)
-
-    # Apply scaling
-    input_scaled = scaler.transform(input_data)
-    input_scaled_df = pd.DataFrame(input_scaled, columns=original_feature_columns)
-
-    # Apply feature engineering (same as done during training)
-    if 'radius_mean' in input_scaled_df.columns and 'area_mean' in input_scaled_df.columns:
-        input_scaled_df['radius_area_ratio'] = input_scaled_df['radius_mean'] / (input_scaled_df['area_mean'] + 1e-6)
-    if 'perimeter_mean' in input_scaled_df.columns and 'area_mean' in input_scaled_df.columns:
-        input_scaled_df['perimeter_area_ratio'] = input_scaled_df['perimeter_mean'] / (input_scaled_df['area_mean'] + 1e-6)
-    if 'concavity_mean' in input_scaled_df.columns and 'concave points_mean' in input_scaled_df.columns:
-        input_scaled_df['concavity_points_product'] = input_scaled_df['concavity_mean'] * input_scaled_df['concave points_mean']
-
-    # Make prediction
-    prediction_proba = final_model.predict_proba(input_scaled_df)[0]
-    prediction_class_idx = np.argmax(prediction_proba)
-    prediction_class = label_encoder.inverse_transform([prediction_class_idx])[0]
-
-    confidence = prediction_proba[prediction_class_idx]
-
-    # Map output to more readable format
-    diagnosis_map = {'M': 'Malignant (Cancer)', 'B': 'Benign (Non-cancerous)'}
-    predicted_diagnosis = diagnosis_map.get(prediction_class, prediction_class)
-
-    return predicted_diagnosis, f"{confidence*100:.2f}%"
-
-# Create Gradio input components
-inputs = []
-for col in original_feature_columns:
-    # Using gr.Number for all numerical features
-    inputs.append(gr.Number(label=col, value=0.0)) # Default value can be adjusted
-
-# Example values from a benign case (e.g., from df.head() with diagnosis B)
-# Using averages for a generic starting point, adjust as needed
-example_inputs = [
-    12.45, 15.7 , 82.57, 477.1, 0.1045, 0.08947, 0.04991, 0.02111, 0.1716, 0.06337,
-    0.3344, 1.157 , 2.508 , 32.43, 0.007624, 0.01802, 0.01993, 0.008453, 0.01538, 0.003463,
-    13.78, 20.8  , 91.18, 592.7, 0.146 , 0.2158 , 0.1672 , 0.07899, 0.2823, 0.07526
-]
 
-# Create Gradio interface
+# ==============================
+# Prediction Function
+# ==============================
+
+def predict_cancer(*inputs):
+
+    # Convert input into dataframe
+    input_df = pd.DataFrame([inputs], columns=feature_columns)
+
+    # Scale data
+    scaled_data = scaler.transform(input_df)
+    scaled_df = pd.DataFrame(scaled_data, columns=feature_columns)
+
+    # Feature Engineering (must match training)
+    scaled_df['radius_area_ratio'] = scaled_df['radius_mean'] / (scaled_df['area_mean'] + 1e-6)
+    scaled_df['perimeter_area_ratio'] = scaled_df['perimeter_mean'] / (scaled_df['area_mean'] + 1e-6)
+    scaled_df['concavity_points_product'] = (
+        scaled_df['concavity_mean'] * scaled_df['concave points_mean']
+    )
+
+    # Prediction
+    probabilities = final_model.predict_proba(scaled_df)[0]
+    class_index = np.argmax(probabilities)
+    predicted_label = label_encoder.inverse_transform([class_index])[0]
+    confidence = probabilities[class_index] * 100
+
+    diagnosis_map = {
+        "M": "Malignant (Cancer)",
+        "B": "Benign (Non-cancerous)"
+    }
+
+    result = diagnosis_map.get(predicted_label, predicted_label)
+
+    return result, f"{confidence:.2f}%"
+
+
+# ==============================
+# Create Gradio UI
+# ==============================
+
+inputs = [gr.Number(label=col, value=0.0) for col in feature_columns]
+
 interface = gr.Interface(
     fn=predict_cancer,
     inputs=inputs,
-    outputs=[gr.Textbox(label="Predicted Diagnosis"), gr.Textbox(label="Confidence")],
-    title="Breast Cancer Prediction",
-    description="Enter patient's cell nuclei measurements to predict breast cancer diagnosis.",
-    examples=[example_inputs]
+    outputs=[
+        gr.Textbox(label="Predicted Diagnosis"),
+        gr.Textbox(label="Confidence")
+    ],
+    title="Breast Cancer Prediction App",
+    description="Enter the 30 medical features to predict whether the tumor is Benign or Malignant."
 )
 
-# Launch the interface
-interface.launch(debug=True)
-print("\n--- Gradio interface launched ---")
+# ==============================
+# Launch App
+# ==============================
+
+if __name__ == "__main__":
+    interface.launch()