Update app.py

app.py

@@ -1,78 +1,171 @@
 import gradio as gr
-
 import pandas as pd
-
 import numpy as np
 import pickle
+from sklearn.preprocessing import StandardScaler
+import sklearn
+import os
+
+print(f"Prediction environment scikit-learn version: {sklearn.__version__}")
+
+def load_model():
+    """Load the model with version compatibility check"""
+    possible_paths = [
+        "/content/Project/metadata/mlflow/mlartifacts/0951b451e9554321adaebc8f9f15ac8c/artifacts/train/model/artifacts/sk_model/model.pkl",
+        "model.pkl",
+        "/home/user/app/model.pkl",
+        "./model.pkl",
+        "../model.pkl"
+    ]
+    
+    for path in possible_paths:
+        try:
+            if os.path.exists(path):
+                with open(path, 'rb') as f:
+                    try:
+                        model = pickle.load(f)
+                        # Test if model can make predictions
+                        dummy_data = pd.DataFrame({
+                            'num__age': [0],
+                            'num__avg_glucose_level': [0],
+                            'num__bmi': [0],
+                            'cat__gender_Male': [0],
+                            'cat__gender_Other': [0],
+                            'cat__hypertension_1': [0],
+                            'cat__heart_disease_1': [0],
+                            'cat__ever_married_Yes': [0],
+                            'cat__work_type_Never_worked': [0],
+                            'cat__work_type_Private': [0],
+                            'cat__work_type_Self-employed': [0],
+                            'cat__work_type_children': [0],
+                            'cat__Residence_type_Urban': [0],
+                            'cat__smoking_status_formerly smoked': [0],
+                            'cat__smoking_status_never smoked': [0],
+                            'cat__smoking_status_smokes': [0]
+                        })
+                        model.predict_proba(dummy_data)
+                        print(f"Successfully loaded and tested model from {path}")
+                        return model
+                    except Exception as e:
+                        print(f"Model loaded but failed testing from {path}: {e}")
+                        continue
+        except Exception as e:
+            print(f"Failed to load from {path}: {e}")
+            continue
+    
+    print("Could not load model from any location")
+    return None
+
+# Load the model once when starting the app
+model = load_model()
+
+def preprocess_input(data_dict):
+    """Preprocess input data to match the training format"""
+    # First create DataFrame with original columns
+    df = pd.DataFrame([data_dict])
+    
+    # Store original features before transformation
+    original_df = df.copy()
+    
+    # Numeric features
+    numeric_features = ['age', 'avg_glucose_level', 'bmi']
+    
+    # Scale numeric features and add prefix
+    scaler = StandardScaler()
+    scaled_features = scaler.fit_transform(df[numeric_features])
+    for i, feat in enumerate(numeric_features):
+        df[f'num__{feat}'] = scaled_features[:, i]
+    
+    # Create categorical features
+    # Gender
+    df['cat__gender_Male'] = (df['gender'] == 'Male').astype(float)
+    df['cat__gender_Other'] = 0.0
+    
+    # Hypertension
+    df['cat__hypertension_1'] = df['hypertension'].astype(float)
+    
+    # Heart Disease
+    df['cat__heart_disease_1'] = df['heart_disease'].astype(float)
+    
+    # Ever Married
+    df['cat__ever_married_Yes'] = (df['ever_married'] == 'Yes').astype(float)
+    
+    # Work Type
+    df['cat__work_type_Never_worked'] = (df['work_type'] == 'Never_worked').astype(float)
+    df['cat__work_type_Private'] = (df['work_type'] == 'Private').astype(float)
+    df['cat__work_type_Self-employed'] = (df['work_type'] == 'Self-employed').astype(float)
+    df['cat__work_type_children'] = (df['work_type'] == 'children').astype(float)
+    
+    # Residence Type
+    df['cat__Residence_type_Urban'] = (df['Residence_type'] == 'Urban').astype(float)
+    
+    # Smoking Status
+    df['cat__smoking_status_formerly smoked'] = (df['smoking_status'] == 'formerly smoked').astype(float)
+    df['cat__smoking_status_never smoked'] = (df['smoking_status'] == 'never smoked').astype(float)
+    df['cat__smoking_status_smokes'] = (df['smoking_status'] == 'smokes').astype(float)
+    
+    # Select only the transformed columns in the correct order
+    feature_columns = [
+        'num__age', 'num__avg_glucose_level', 'num__bmi',
+        'cat__gender_Male', 'cat__gender_Other', 'cat__hypertension_1',
+        'cat__heart_disease_1', 'cat__ever_married_Yes',
+        'cat__work_type_Never_worked', 'cat__work_type_Private',
+        'cat__work_type_Self-employed', 'cat__work_type_children',
+        'cat__Residence_type_Urban', 'cat__smoking_status_formerly smoked',
+        'cat__smoking_status_never smoked', 'cat__smoking_status_smokes'
+    ]
+    
+    return df[feature_columns]
+
+def predict(gender, age, hypertension, ever_married, work_type, heart_disease, 
+           avg_glucose_level, bmi, smoking_status, Residence_type):
+    """Make prediction using the loaded model"""
+    if model is None:
+        return "Error: Model not loaded"
+        
+    # Create input dictionary
+    input_data = {
+        'gender': gender,
+        'age': float(age),  # Ensure numeric
+        'hypertension': 1 if hypertension == 'Yes' else 0,
+        'heart_disease': 1 if heart_disease == 'Yes' else 0,
+        'ever_married': ever_married,
+        'work_type': work_type,
+        'Residence_type': Residence_type,
+        'avg_glucose_level': float(avg_glucose_level),  # Ensure numeric
+        'bmi': float(bmi),  # Ensure numeric
+        'smoking_status': smoking_status
+    }
+    
+    # Preprocess the input
+    processed_input = preprocess_input(input_data)
+    
+    # Use the loaded model
+    try:
+        prediction = model.predict_proba(processed_input)[0][1]
+        return f"The probability of stroke is {prediction:.2%}"
+    except Exception as e:
+        return f"Error making prediction: {str(e)}"
 
-def decode_file(file_path):
-    with open(file_path, 'rb') as file:
-        obj = pickle.load(file)
-    return obj
-
-model = decode_file('model.pkl')
-
-
-def predict(gender, age, hypertension, ever_married, work_type, heart_disease, avg_glucose_level, bmi, smoking_status, Residence_type):
-    # Mapping for categorical variables
-    gender_mapping = {'Male': 1, 'Female': 0}
-    hypertension_mapping = {'Yes': 1, 'No': 0}
-    ever_married_mapping = {'Yes': 1, 'No': 0}
-    work_type_mapping = {'Private': 2, 'Self-employed': 4, 'Govt_job': 3, 'children': 1, 'Never_worked': 0}
-    heart_disease_mapping = {'Yes': 1, 'No': 0}
-    smoking_status_mapping = {'formerly smoked': 3, 'smokes': 1, 'never smoked': 2, 'Unknown': 0}
-    Residence_type_mapping = {'Urban': 1, 'Rural': 0}
-
-    # Map categorical variables to their corresponding numerical values
-    gender = gender_mapping[gender]
-    hypertension = hypertension_mapping[hypertension]
-    ever_married = ever_married_mapping[ever_married]
-    work_type = work_type_mapping[work_type]
-    heart_disease = heart_disease_mapping[heart_disease]
-    smoking_status = smoking_status_mapping[smoking_status]
-    Residence_type = Residence_type_mapping[Residence_type]
-
-    inputs = [gender, age, hypertension, ever_married, work_type, heart_disease, avg_glucose_level, bmi, smoking_status, Residence_type]
-    input_labels = ['gender', 'age', 'hypertension', 'ever_married', 'work_type', 'heart_disease', 'avg_glucose_level', 'bmi', 'smoking_status', 'Residence_type']
-
-    # Convert the input into a pandas DataFrame
-    input_df = pd.DataFrame([inputs], columns=input_labels)
-
-    # Predict the stroke probability
-    prediction = model.predict_proba(input_df)[0][1]
-
-    # Return the prediction
-    result = "The probability of stroke is {:.2f}%".format(prediction * 100)  # to give a percentage
-    return result
-
-
-
-
-
-
-input_labels = [
-    'gender', 'age', 'hypertension', 'ever_married', 'work_type', 
-    'heart_disease', 'avg_glucose_level', 'bmi', 'smoking_status', 'Residence_type'
-]
 # Create the Gradio interface
 iface = gr.Interface(
     fn=predict,
     inputs=[
-        gr.components.Radio(choices=['Female', 'Male'], label="Gender"),
-        gr.components.Slider(label="Age"),
-        gr.components.Radio(choices=['Yes', 'No'], label="Hypertension"),
-        gr.components.Radio(choices=['Yes', 'No'], label="Ever Married"),
-        gr.components.Radio(choices=['Private', 'Self-employed', 'Govt_job', 'children', 'Never_worked'], label="Work Type"),
-        gr.components.Radio(choices=['Yes', 'No'], label="Heart Disease"),
-        gr.components.Number(label="Average Glucose Level"),
-        gr.components.Slider(label="BMI"),
-        gr.components.Radio(choices=['formerly smoked', 'never smoked', 'smokes', 'Unknown'], label="Smoking Status"),
-        gr.components.Radio(choices=['Urban', 'Rural'], label="Residence Type")
+        gr.Radio(choices=['Female', 'Male'], label="Gender"),
+        gr.Slider(minimum=0, maximum=100, label="Age"),
+        gr.Radio(choices=['Yes', 'No'], label="Hypertension"),
+        gr.Radio(choices=['Yes', 'No'], label="Ever Married"),
+        gr.Radio(choices=['Private', 'Self-employed', 'Govt_job', 'children', 'Never_worked'], label="Work Type"),
+        gr.Radio(choices=['Yes', 'No'], label="Heart Disease"),
+        gr.Number(label="Average Glucose Level"),
+        gr.Slider(minimum=10, maximum=50, label="BMI"),
+        gr.Radio(choices=['formerly smoked', 'never smoked', 'smokes', 'Unknown'], label="Smoking Status"),
+        gr.Radio(choices=['Urban', 'Rural'], label="Residence Type")
     ],
     outputs='text',
     title='Stroke Probability Predictor',
     description='Predicts the probability of having a stroke based on input features.'
 )
 
-
-iface.launch()
+if __name__ == "__main__":
+    iface.launch()