Update app.py

app.py

@@ -19,11 +19,46 @@ from pathlib import Path
 import warnings
 warnings.filterwarnings('ignore')
 
+def create_dummy_model(model_type):
+    """Create a realistic dummy model"""
+    class RealisticDummyModel:
+        def __init__(self, model_type):
+            self.model_type = model_type
+            self.n_features_in_ = 9
+            self.feature_names_in_ = [
+                'floor_area_sqm', 'storey_level', 'flat_age', 'remaining_lease',
+                'transaction_year', 'flat_type_encoded', 'town_encoded',
+                'flat_model_encoded', 'dummy_feature'
+            ]
+        
+        def predict(self, X):
+            # Realistic prediction logic
+            floor_area = X[0][0]
+            storey_level = X[0][1]
+            flat_age = X[0][2]
+            town_encoded = X[0][6]
+            flat_type_encoded = X[0][5]
+            
+            base_price = floor_area * (4800 + town_encoded * 200)
+            storey_bonus = storey_level * 2500
+            age_discount = flat_age * 1800
+            
+            if self.model_type == "xgboost":
+                price = base_price + storey_bonus - age_discount + 35000
+                if storey_level > 20: price += 15000
+                if flat_age < 10: price += 20000
+            else:
+                price = base_price + storey_bonus - age_discount - 25000
+            
+            return max(300000, price)
+
+    return RealisticDummyModel(model_type)
+
 # Load models using Hugging Face Hub (handles Xet pointers)
 def load_models():
     """Load models using Hugging Face Hub library"""
     models = {}
-
+    
     try:
         # Download XGBoost model (handles Xet pointer automatically)
         xgboost_path = hf_hub_download(
@@ -34,11 +69,12 @@ def load_models():
         models['xgboost'] = joblib.load(xgboost_path)
         print("✅ XGBoost model loaded successfully via Hugging Face Hub")
         print(f"   File size: {os.path.getsize(xgboost_path)} bytes")
-
+        
     except Exception as e:
         print(f"❌ Error loading XGBoost model: {e}")
+        print("⚠️  This usually means xgboost package is not installed")
         models['xgboost'] = None
-
+    
     try:
         # Download Linear Regression model
         linear_path = hf_hub_download(
@@ -46,14 +82,21 @@ def load_models():
             filename="linear_regression.joblib",
             repo_type="space"
         )
-        models['linear_regression'] = joblib.load(linear_path)
-        print("✅ Linear Regression model loaded successfully via Hugging Face Hub")
-        print(f"   File size: {os.path.getsize(linear_path)} bytes")
-
+        # Try to load without xgboost dependency
+        try:
+            models['linear_regression'] = joblib.load(linear_path)
+            print("✅ Linear Regression model loaded successfully via Hugging Face Hub")
+        except Exception as e:
+            if "xgboost" in str(e).lower():
+                print("❌ Linear Regression model also requires xgboost")
+                models['linear_regression'] = None
+            else:
+                raise e
+                
     except Exception as e:
         print(f"❌ Error loading Linear Regression model: {e}")
         models['linear_regression'] = None
-
+    
     return models
 
 def load_data():
@@ -68,7 +111,7 @@ def load_data():
         df = pd.read_csv(data_path)
         print("✅ Data loaded successfully via Hugging Face Hub")
         return df
-
+        
     except Exception as e:
         print(f"❌ Error loading data: {e}")
         # Fallback to creating sample data
@@ -81,7 +124,7 @@ def create_sample_data():
     towns = ['ANG MO KIO', 'BEDOK', 'TAMPINES', 'WOODLANDS', 'JURONG WEST']
     flat_types = ['4 ROOM', '5 ROOM', 'EXECUTIVE']
     flat_models = ['Improved', 'Model A', 'New Generation']
-
+    
     data = []
     for _ in range(100):
         town = np.random.choice(towns)
@@ -90,22 +133,22 @@ def create_sample_data():
         floor_area = np.random.randint(85, 150)
         storey = np.random.randint(1, 25)
         age = np.random.randint(0, 40)
-
+        
         base_price = floor_area * 5000
         town_bonus = towns.index(town) * 20000
         storey_bonus = storey * 2000
         age_discount = age * 1500
         flat_type_bonus = flat_types.index(flat_type) * 30000
-
+        
         resale_price = base_price + town_bonus + storey_bonus - age_discount + flat_type_bonus
         resale_price = max(300000, resale_price + np.random.randint(-20000, 20000))
-
+        
         data.append({
             'town': town, 'flat_type': flat_type, 'flat_model': flat_model,
             'floor_area_sqm': floor_area, 'storey_level': storey,
             'flat_age': age, 'resale_price': resale_price
         })
-
+    
     return pd.DataFrame(data)
 
 # Preload models and data
@@ -114,50 +157,152 @@ models = load_models()
 data = load_data()
 
 # If models failed to load, create dummy ones
-if models['xgboost'] is None:
+if models.get('xgboost') is None:
     print("⚠️  Creating dummy XGBoost model for demonstration")
     models['xgboost'] = create_dummy_model("xgboost")
 
-if models['linear_regression'] is None:
+if models.get('linear_regression') is None:
     print("⚠️  Creating dummy Linear Regression model for demonstration")
     models['linear_regression'] = create_dummy_model("linear_regression")
 
-def create_dummy_model(model_type):
-    """Create a realistic dummy model"""
-    class RealisticDummyModel:
-        def __init__(self, model_type):
-            self.model_type = model_type
-            self.n_features_in_ = 9
-            self.feature_names_in_ = [
-                'floor_area_sqm', 'storey_level', 'flat_age', 'remaining_lease',
-                'transaction_year', 'flat_type_encoded', 'town_encoded',
-                'flat_model_encoded', 'dummy_feature'
-            ]
+def preprocess_input(user_input, model_type='xgboost'):
+    """Preprocess user input for prediction with correct feature mapping"""
+    # Flat type mapping
+    flat_type_mapping = {'1 ROOM': 1, '2 ROOM': 2, '3 ROOM': 3, '4 ROOM': 4,
+                         '5 ROOM': 5, 'EXECUTIVE': 6, 'MULTI-GENERATION': 7}
+
+    # Town mapping
+    town_mapping = {
+        'SENGKANG': 0, 'WOODLANDS': 1, 'TAMPINES': 2, 'PUNGGOL': 3,
+        'JURONG WEST': 4, 'YISHUN': 5, 'BEDOK': 6, 'HOUGANG': 7,
+        'CHOA CHU KANG': 8, 'ANG MO KIO': 9
+    }
+
+    # Flat model mapping
+    flat_model_mapping = {
+        'Model A': 0, 'Improved': 1, 'New Generation': 2,
+        'Standard': 3, 'Premium': 4
+    }
+
+    # Create input array with features
+    input_features = [
+        user_input['floor_area_sqm'],           # Feature 1
+        user_input['storey_level'],             # Feature 2
+        user_input['flat_age'],                 # Feature 3
+        99 - user_input['flat_age'],            # Feature 4: remaining_lease
+        2025,                                   # Feature 5: transaction_year
+        flat_type_mapping.get(user_input['flat_type'], 4),  # Feature 6: flat_type_ordinal
+        town_mapping.get(user_input['town'], 0),           # Feature 7: town_encoded
+        flat_model_mapping.get(user_input['flat_model'], 0), # Feature 8: flat_model_encoded
+        1                                       # Feature 9: (placeholder)
+    ]
+
+    return np.array([input_features])
+
+def create_market_insights_chart(data, user_input, predicted_price_xgb, predicted_price_lr):
+    """Create market insights visualization with both model predictions"""
+    if data is None or len(data) == 0:
+        return None
+
+    similar_properties = data[
+        (data['flat_type'] == user_input['flat_type']) &
+        (data['town'] == user_input['town'])
+    ]
+
+    if len(similar_properties) < 5:
+        similar_properties = data[data['flat_type'] == user_input['flat_type']]
+
+    if len(similar_properties) > 0:
+        fig = px.scatter(similar_properties, x='floor_area_sqm', y='resale_price',
+                         color='flat_model',
+                         title=f"Market Position: {user_input['flat_type']} in {user_input['town']}",
+                         labels={'floor_area_sqm': 'Floor Area (sqm)', 'resale_price': 'Resale Price (SGD)'})
+
+        # Add both model predictions
+        fig.add_trace(go.Scatter(x=[user_input['floor_area_sqm']], y=[predicted_price_xgb],
+                                 mode='markers',
+                                 marker=dict(symbol='star', size=20, color='red',
+                                             line=dict(width=2, color='darkred')),
+                                 name='XGBoost Prediction'))
+
+        fig.add_trace(go.Scatter(x=[user_input['floor_area_sqm']], y=[predicted_price_lr],
+                                 mode='markers',
+                                 marker=dict(symbol='diamond', size=20, color='blue',
+                                             line=dict(width=2, color='darkblue')),
+                                 name='Linear Regression Prediction'))
+
+        fig.update_layout(template="plotly_white", height=400, showlegend=True)
+        return fig
+    return None
+
+def predict_hdb_price(town, flat_type, flat_model, floor_area_sqm, storey_level, flat_age, model_choice):
+    """Main prediction function for Gradio"""
+    user_input = {
+        'town': town,
+        'flat_type': flat_type,
+        'flat_model': flat_model,
+        'floor_area_sqm': floor_area_sqm,
+        'storey_level': storey_level,
+        'flat_age': flat_age
+    }
+
+    if models['xgboost'] is None or models['linear_regression'] is None:
+        return "Error: Models not loaded", None, "Models failed to load. Please check the model files."
 
-        def predict(self, X):
-            # Realistic prediction logic
-            floor_area = X[0][0]
-            storey_level = X[0][1]
-            flat_age = X[0][2]
-            town_encoded = X[0][6]
-            flat_type_encoded = X[0][5]
-
-            base_price = floor_area * (4800 + town_encoded * 200)
-            storey_bonus = storey_level * 2500
-            age_discount = flat_age * 1800
-
-            if self.model_type == "xgboost":
-                price = base_price + storey_bonus - age_discount + 35000
-                if storey_level > 20: price += 15000
-                if flat_age < 10: price += 20000
-            else:
-                price = base_price + storey_bonus - age_discount - 25000
-
-            return max(300000, price)
-
-    return RealisticDummyModel(model_type)
+    try:
+        processed_input = preprocess_input(user_input)
+        
+        # Get predictions from both models
+        predicted_price_xgb = max(0, models['xgboost'].predict(processed_input)[0])
+        predicted_price_lr = max(0, models['linear_regression'].predict(processed_input)[0])
+        
+        # Use selected model's prediction
+        if model_choice == "XGBoost":
+            final_price = predicted_price_xgb
+            model_name = "XGBoost"
+        else:
+            final_price = predicted_price_lr
+            model_name = "Linear Regression"
+
+        # Create insights
+        remaining_lease = 99 - flat_age
+        price_per_sqm = final_price / floor_area_sqm
+
+        insights = f"""
+        **Property Summary:**
+        - Location: {town}
+        - Type: {flat_type}
+        - Model: {flat_model}
+        - Area: {floor_area_sqm} sqm
+        - Floor: Level {storey_level}
+        - Age: {flat_age} years
+        - Remaining Lease: {remaining_lease} years
+        - Price per sqm: ${price_per_sqm:,.0f}
+
+        **Model Predictions:**
+        - XGBoost: ${predicted_price_xgb:,.0f}
+        - Linear Regression: ${predicted_price_lr:,.0f}
+        - Difference: ${abs(predicted_price_xgb - predicted_price_lr):,.0f}
+
+        **Selected Model: {model_choice}**
+
+        **Financing Eligibility:**
+        """
+
+        if remaining_lease >= 60:
+            insights += "✅ Bank loan eligible"
+        elif remaining_lease >= 20:
+            insights += "⚠️ HDB loan eligible only"
+        else:
+            insights += "❌ Limited financing options"
+
+        # Create chart with both predictions
+        chart = create_market_insights_chart(data, user_input, predicted_price_xgb, predicted_price_lr)
+
+        return f"${final_price:,.0f}", chart, insights
 
-# ... [rest of your functions remain the same: preprocess_input, create_market_insights_chart, predict_hdb_price] ...
+    except Exception as e:
+        return f"Error: {str(e)}", None, f"Prediction failed. Error: {str(e)}"
 
 # Define Gradio interface
 towns_list = [
@@ -181,8 +326,8 @@ with gr.Blocks(title="🏠 HDB Price Predictor", theme=gr.themes.Soft()) as demo
             floor_area_sqm = gr.Slider(label="Floor Area (sqm)", minimum=30, maximum=200, value=95, step=5)
             storey_level = gr.Slider(label="Storey Level", minimum=1, maximum=50, value=8, step=1)
             flat_age = gr.Slider(label="Flat Age (years)", minimum=0, maximum=99, value=15, step=1)
-            model_choice = gr.Radio(label="Select Model",
-                                   choices=["XGBoost", "Linear Regression"],
+            model_choice = gr.Radio(label="Select Model", 
+                                   choices=["XGBoost", "Linear Regression"], 
                                    value="XGBoost")
 
             predict_btn = gr.Button("🔮 Predict Price", variant="primary")