Day 44: Feature Engineering & Scaling

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.metrics import roc_auc_score
l = pd.read_csv("loan_applications.csv")
y = l["approved"]
raw = l[["monthly_income", "credit_score", "loan_amount", "years_employed"]]
eng = raw.assign(lti=l["loan_amount"] / (l["monthly_income"] * 12), salaried=(l["employment"] == "Salaried").astype(int))
for name, X, model in [("raw columns", raw, LogisticRegression(max_iter=5000)),
                       ("+ scaling", raw, make_pipeline(StandardScaler(), LogisticRegression())),
                       ("+ scaling + new features", eng, make_pipeline(StandardScaler(), LogisticRegression()))]:
    a, b, c, d = train_test_split(X, y, test_size=0.25, random_state=42, stratify=y)
    print(f"{name:26s} AUC = {roc_auc_score(d, model.fit(a, c).predict_proba(b)[:, 1]):.3f}")

import pandas as pd
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler
l = pd.read_csv("loan_applications.csv")
x = l[["monthly_income"]]
out = pd.DataFrame({"raw": x["monthly_income"],
                    "standard": StandardScaler().fit_transform(x).ravel(),
                    "minmax": MinMaxScaler().fit_transform(x).ravel(),
                    "robust": RobustScaler().fit_transform(x).ravel()})
print(out.describe().loc[["mean", "std", "min", "50%", "max"]].round(2))

import pandas as pd
from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder
h = pd.read_csv("house_prices.csv")
ohe = OneHotEncoder(sparse_output=False, handle_unknown="ignore").fit(h[["city"]])
print(ohe.get_feature_names_out(), ohe.transform(pd.DataFrame({"city": ["Pune", "Indore"]})))
ordi = OrdinalEncoder(categories=[["Unfurnished", "Semi-Furnished", "Furnished"]]).fit(h[["furnishing"]])
print(ordi.transform(pd.DataFrame({"furnishing": ["Unfurnished", "Furnished"]})).ravel())

import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder, StandardScaler
h = pd.read_csv("house_prices.csv")
num = ["area_sqft", "bedrooms", "bathrooms", "age_years", "metro_km"]
pre = ColumnTransformer([
    ("num", StandardScaler(), num),
    ("city", OneHotEncoder(handle_unknown="ignore", sparse_output=False), ["city", "parking"]),
    ("furn", OrdinalEncoder(categories=[["Unfurnished", "Semi-Furnished", "Furnished"]]), ["furnishing"]),
])
Xt = pre.fit_transform(h)
print(Xt.shape)
print(pd.DataFrame(Xt, columns=pre.get_feature_names_out()).head(3).round(2))

import numpy as np
import pandas as pd
h = pd.read_csv("house_prices.csv")
f = pd.DataFrame(index=h.index)
f["area_per_bedroom"] = h["area_sqft"] / h["bedrooms"]                  # ratio
f["near_metro"] = (h["metro_km"] <= 1).astype(int)                       # flag from domain knowledge
f["age_band"] = pd.cut(h["age_years"], [-1, 5, 15, 30], labels=[0, 1, 2]).astype(int)   # binning
f["log_area"] = np.log(h["area_sqft"])                                   # skew fix
f["area_x_metro"] = h["area_sqft"] * h["metro_km"]                       # interaction
print(f.head().round(2))
print(f.corrwith(h["price_lakh"]).round(2).to_string())

import pandas as pd
s = pd.read_csv("sales_data.csv", parse_dates=["order_date"])
feat = pd.DataFrame({"month": s["order_date"].dt.month,
                     "weekday": s["order_date"].dt.dayofweek,
                     "is_weekend": (s["order_date"].dt.dayofweek >= 5).astype(int),
                     "days_to_diwali": (pd.Timestamp("2024-10-31") - s["order_date"]).dt.days.clip(lower=0),
                     "festive": s["order_date"].between("2024-10-01", "2024-11-15").astype(int)})
print(feat.head(3))
r = pd.read_csv("product_reviews.csv")
txt = pd.DataFrame({"n_words": r["review"].str.split().str.len(),
                    "n_exclaim": r["review"].str.count("!"),
                    "has_refund": r["review"].str.contains("refund|return", case=False).astype(int)})
print(txt.assign(stars=r["stars"]).groupby("has_refund")["stars"].mean().round(2))

import pandas as pd
from sklearn.impute import SimpleImputer
s = pd.read_csv("sales_data.csv")
imp = SimpleImputer(strategy="median", add_indicator=True)
out = imp.fit_transform(s[["customer_age", "rating"]])
print(pd.DataFrame(out, columns=imp.get_feature_names_out()).iloc[s["rating"].isna().to_numpy().nonzero()[0][:3]])

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import roc_auc_score
l = pd.read_csv("loan_applications.csv")
rng = np.random.default_rng(0)
# a column only known AFTER the decision: the disbursed amount (0 if rejected)
l["disbursed_amount"] = np.where(l["approved"] == 1, l["loan_amount"] * rng.uniform(0.9, 1.0, len(l)), 0)
y = l["approved"]
for cols in [["credit_score", "monthly_income", "loan_amount"], ["credit_score", "monthly_income", "loan_amount", "disbursed_amount"]]:
    a, b, c, d = train_test_split(l[cols], y, test_size=0.25, random_state=0, stratify=y)
    auc = roc_auc_score(d, RandomForestClassifier(random_state=0).fit(a, c).predict_proba(b)[:, 1])
    print(f"{'+ disbursed_amount' if len(cols) == 4 else 'honest features':20s} AUC = {auc:.3f}")