Project — House Price Prediction Model

import pandas as pd

df = pd.read_csv("house_prices.csv")

print(df.shape)
# (1500, 6)

print(df.head())

print(df.dtypes)
# sqft            int64
# bedrooms      float64   (has a missing value, so pandas upgraded it from int)
# bathrooms     float64
# city           object   (text/categorical)
# age_years       int64
# price           int64
# dtype: object

print(df.isnull().sum())
# sqft           0
# bedrooms      21
# bathrooms      0
# city           0
# age_years      0
# price          0
# dtype: int64

print(df.describe().round(1))

# Fill the small number of missing bedroom counts with the column median
df["bedrooms"] = df["bedrooms"].fillna(df["bedrooms"].median())

assert df.isnull().sum().sum() == 0, "Still missing values!"

# One-hot encode city: turns 1 text column into several 0/1 columns
# drop_first=True avoids redundant columns (Lesson 3's dummy-variable trap)
df_encoded = pd.get_dummies(df, columns=["city"], drop_first=True)

print(df_encoded.columns.tolist())
# ['sqft', 'bedrooms', 'bathrooms', 'age_years', 'price',
#  'city_Hillcrest', 'city_Oakdale', 'city_Riverton']
# -> 'Fairview' became the implicit baseline city (all three dummies == 0)

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

X = df_encoded.drop(columns=["price"])
y = df_encoded["price"]

# Split BEFORE scaling, so the scaler only ever sees training data (Lesson 8)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

numeric_cols = ["sqft", "bedrooms", "bathrooms", "age_years"]

scaler = StandardScaler()
X_train_scaled = X_train.copy()
X_test_scaled = X_test.copy()
X_train_scaled[numeric_cols] = scaler.fit_transform(X_train[numeric_cols])
X_test_scaled[numeric_cols] = scaler.transform(X_test[numeric_cols])

print(f"Train: {X_train_scaled.shape}, Test: {X_test_scaled.shape}")
# Train: (1200, 7), Test: (300, 7)

from sklearn.linear_model import LinearRegression

lin_model = LinearRegression()
lin_model.fit(X_train_scaled, y_train)

lin_preds = lin_model.predict(X_test_scaled)

from sklearn.ensemble import GradientBoostingRegressor

gbr_model = GradientBoostingRegressor(
    n_estimators=200,
    learning_rate=0.05,
    max_depth=3,
    random_state=42
)
gbr_model.fit(X_train_scaled, y_train)

gbr_preds = gbr_model.predict(X_test_scaled)

from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

def evaluate(name, y_true, y_pred):
    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
    r2 = r2_score(y_true, y_pred)
    print(f"{name}: RMSE=${rmse:,.0f}, R2={r2:.3f}")
    return rmse, r2

lin_rmse, lin_r2 = evaluate("LinearRegression", y_test, lin_preds)
gbr_rmse, gbr_r2 = evaluate("GradientBoostingRegressor", y_test, gbr_preds)

# LinearRegression: RMSE=$28,450, R2=0.884
# GradientBoostingRegressor: RMSE=$24,120, R2=0.917

importances = pd.Series(gbr_model.feature_importances_, index=X_train_scaled.columns)
print(importances.sort_values(ascending=False).round(3))

# sqft                0.612
# age_years           0.148
# bathrooms           0.101
# city_Hillcrest      0.068
# bedrooms            0.041
# city_Riverton       0.021
# city_Oakdale        0.009
# dtype: float64

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error, r2_score

# 1. Load and take a first look
df = pd.read_csv("house_prices.csv")
print("Shape:", df.shape)
print(df.head())

# 2. Check for missing values, then clean
print(df.isnull().sum())
df["bedrooms"] = df["bedrooms"].fillna(df["bedrooms"].median())
assert df.isnull().sum().sum() == 0

# 3. Encode city, then split into features/target
df_encoded = pd.get_dummies(df, columns=["city"], drop_first=True)
X = df_encoded.drop(columns=["price"])
y = df_encoded["price"]

# 4. Split, then scale (fit scaler on train only)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
numeric_cols = ["sqft", "bedrooms", "bathrooms", "age_years"]
scaler = StandardScaler()
X_train_scaled = X_train.copy()
X_test_scaled = X_test.copy()
X_train_scaled[numeric_cols] = scaler.fit_transform(X_train[numeric_cols])
X_test_scaled[numeric_cols] = scaler.transform(X_test[numeric_cols])

# 5. Train both models on the identical split
lin_model = LinearRegression().fit(X_train_scaled, y_train)
gbr_model = GradientBoostingRegressor(
    n_estimators=200, learning_rate=0.05, max_depth=3, random_state=42
).fit(X_train_scaled, y_train)

# 6. Evaluate both honestly on the same test set
def evaluate(name, y_true, y_pred):
    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
    r2 = r2_score(y_true, y_pred)
    print(f"{name}: RMSE=${rmse:,.0f}, R2={r2:.3f}")

evaluate("LinearRegression", y_test, lin_model.predict(X_test_scaled))
evaluate("GradientBoostingRegressor", y_test, gbr_model.predict(X_test_scaled))

# 7. Interpret the winning model's feature importances
importances = pd.Series(gbr_model.feature_importances_, index=X_train_scaled.columns)
print(importances.sort_values(ascending=False).round(3))