📂 Dataset

Download from Kaggle: House Prices – Advanced Regression Techniques . Place train.csv in your working folder.

🔎 Step-by-Step Process

1. Load & Inspect: understand datatypes, missing values, and target skew.
2. Target Transform: apply log1p to SalePrice for normality.
3. Split Columns: identify numeric vs categorical features.
4. Preprocess: median-impute numerics; most-frequent-impute + one-hot-encode categoricals.
5. Train/Test Split: hold out 20% for honest evaluation.
6. Models: baseline LinearRegression, improve with Ridge or RandomForestRegressor.
7. Evaluate: report RMSE (log & $) and R²; show predicted vs actual intuition.
8. Interpret: examine top features (quality, living area, garage) for stakeholder insights.

💻 Complete Python Code (Pipeline + Metrics)

import pandas as pd
import numpy as np

from sklearn.model_selection import train_test_split, RandomizedSearchCV
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score

# 1) Load
df = pd.read_csv("train.csv")  # Kaggle House Prices train.csv

# 2) Target transform
y = np.log1p(df["SalePrice"])   # log(1 + price)
X = df.drop(columns=["SalePrice", "Id"])

# 3) Identify column types
num_cols = X.select_dtypes(include=["int64","float64"]).columns
cat_cols = X.select_dtypes(include=["object"]).columns

# 4) Preprocessing (pipelines avoid leakage)
num_pipe = SimpleImputer(strategy="median")
cat_pipe = Pipeline([
    ("imp", SimpleImputer(strategy="most_frequent")),
    ("ohe", OneHotEncoder(handle_unknown="ignore"))
])

preprocess = ColumnTransformer([
    ("num", num_pipe, num_cols),
    ("cat", cat_pipe, cat_cols)
])

# 5) Train/Test split
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)

# ---- Baseline Linear Regression ----
lin = Pipeline([("prep", preprocess), ("reg", LinearRegression())])
lin.fit(X_tr, y_tr)
pred_log_lin = lin.predict(X_te)

rmse_log_lin = np.sqrt(mean_squared_error(y_te, pred_log_lin))
r2_lin = r2_score(y_te, pred_log_lin)

# invert to dollars for intuition
pred_lin_d = np.expm1(pred_log_lin); y_te_d = np.expm1(y_te)
rmse_lin_d = np.sqrt(mean_squared_error(y_te_d, pred_lin_d))

print(f"Linear Regression -> RMSE(log): {rmse_log_lin:.4f} | R²: {r2_lin:.3f} | RMSE($): {rmse_lin_d:,.0f}")

# ---- Ridge (regularized linear) ----
ridge = Pipeline([("prep", preprocess), ("ridge", Ridge(alpha=10.0, random_state=42))])
ridge.fit(X_tr, y_tr)
pred_log_ridge = ridge.predict(X_te)
rmse_log_ridge = np.sqrt(mean_squared_error(y_te, pred_log_ridge))
r2_ridge = r2_score(y_te, pred_log_ridge)
print(f"Ridge(alpha=10) -> RMSE(log): {rmse_log_ridge:.4f} | R²: {r2_ridge:.3f}")

# ---- Random Forest (non-linear) ----
rf = Pipeline([("prep", preprocess),
               ("rf", RandomForestRegressor(n_estimators=400, random_state=42, n_jobs=-1))])
rf.fit(X_tr, y_tr)
pred_log_rf = rf.predict(X_te)
rmse_log_rf = np.sqrt(mean_squared_error(y_te, pred_log_rf))
r2_rf = r2_score(y_te, pred_log_rf)
pred_rf_d = np.expm1(pred_log_rf)
rmse_rf_d = np.sqrt(mean_squared_error(y_te_d, pred_rf_d))
print(f"RandomForest -> RMSE(log): {rmse_log_rf:.4f} | R²: {r2_rf:.3f} | RMSE($): {rmse_rf_d:,.0f}")

# ---- Optional: quick hyperparameter search for RF ----
param_dist = {
    "rf__n_estimators": [300, 400, 600],
    "rf__max_depth": [None, 10, 20, 30],
    "rf__min_samples_split": [2, 5, 10],
    "rf__min_samples_leaf": [1, 2, 4]
}
search = RandomizedSearchCV(rf, param_distributions=param_dist, n_iter=10, cv=3,
                            n_jobs=-1, random_state=42, verbose=0)
search.fit(X_tr, y_tr)
best = search.best_estimator_
best_pred_log = best.predict(X_te)
rmse_log_best = np.sqrt(mean_squared_error(y_te, best_pred_log))
r2_best = r2_score(y_te, best_pred_log)
print("Best RF params:", search.best_params_)
print(f"Best RF -> RMSE(log): {rmse_log_best:.4f} | R²: {r2_best:.3f}")

# ---- Feature Importance (for best RF) ----
feat_names = best.named_steps["prep"].get_feature_names_out()
rf_model = best.named_steps["rf"]
importances = pd.Series(rf_model.feature_importances_, index=feat_names).sort_values(ascending=False)
print("Top 15 features:\\n", importances.head(15).round(4))
      

📊 Expected Outcomes

• ✔️ R²: often ≥ 0.85 with tuned tree-based models.
• ✔️ RMSE (log): ~0.14–0.16; report also RMSE in dollars for business context.
• ✔️ Top Drivers: OverallQual, GrLivArea (living area), GarageCars, TotalBsmtSF, YearBuilt.
• ✔️ Deliverables: 1-page summary, predicted vs actual scatter, feature-importance bar chart.