Feature Engineering for Regression

# Import pandas, numpy, and scipy for skewness calculation
import pandas as pd
import numpy as np
from scipy.stats import skew  # measures asymmetry of a distribution

# Create a house price DataFrame — 10 rows, realistic skewed values
housing_df = pd.DataFrame({
    'house_id':      [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],                               # unique IDs
    'bedrooms':      [3, 4, 2, 5, 3, 4, 3, 2, 4, 6],                                # number of bedrooms
    'bathrooms':     [2, 3, 1, 4, 2, 3, 2, 1, 3, 5],                                # number of bathrooms
    'lot_size_sqft': [5000, 8500, 3200, 22000, 6100, 9800, 5500, 4200, 11000, 48000],# lot size — right-skewed
    'sale_price':    [285000, 410000, 195000, 890000, 320000,
                      475000, 305000, 210000, 520000, 1950000]                        # target — right-skewed
})

# Measure skewness of the raw values — positive skew means long right tail
raw_price_skew   = skew(housing_df['sale_price'])       # skewness of original sale price
raw_lotsize_skew = skew(housing_df['lot_size_sqft'])    # skewness of original lot size

# Apply log1p transform: log(1 + x) — safer than log(x) because it handles zeros without error
# log1p is the standard choice for financial and count-based features
housing_df['log_sale_price']    = np.log1p(housing_df['sale_price'])       # log-transformed target
housing_df['log_lot_size_sqft'] = np.log1p(housing_df['lot_size_sqft'])    # log-transformed feature

# Measure skewness after transformation — should be much closer to zero
log_price_skew   = skew(housing_df['log_sale_price'])      # skewness after log transform
log_lotsize_skew = skew(housing_df['log_lot_size_sqft'])   # skewness after log transform

# Report the before/after skewness comparison
print(f"sale_price   skewness: raw = {raw_price_skew:.3f}   →   log-transformed = {log_price_skew:.3f}")
print(f"lot_size_sqft skewness: raw = {raw_lotsize_skew:.3f}  →   log-transformed = {log_lotsize_skew:.3f}\n")

# Show the transformed columns alongside the originals
print(housing_df[['house_id','sale_price','log_sale_price','lot_size_sqft','log_lot_size_sqft']].round(3).to_string(index=False))

# Import libraries
import pandas as pd
import numpy as np
from sklearn.preprocessing import PolynomialFeatures  # generates polynomial and interaction terms

# Create a clean house size DataFrame — 10 rows
housing_df2 = pd.DataFrame({
    'house_id':  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'sqft':      [1200, 1850, 950, 3100, 1600, 2200, 1400, 1050, 2600, 4200],  # house size in sqft
    'bedrooms':  [2, 3, 2, 5, 3, 4, 2, 2, 4, 6],                               # number of bedrooms
    'sale_price':[285000, 410000, 195000, 890000, 320000, 475000, 305000, 210000, 520000, 1050000]
})

# --- Manual polynomial and interaction features ---

# Polynomial term: sqft squared — captures the curve in price vs size
housing_df2['sqft_sq'] = housing_df2['sqft'] ** 2  # sqft raised to power 2

# Interaction term: bedrooms × sqft — captures that bedrooms matter more in larger houses
housing_df2['bed_x_sqft'] = housing_df2['bedrooms'] * housing_df2['sqft']

# Ratio feature: price per sqft — a direct normalised signal
housing_df2['price_per_sqft'] = housing_df2['sale_price'] / housing_df2['sqft']

# Print manual features
print("Manual polynomial and interaction features:")
print(housing_df2[['house_id','sqft','sqft_sq','bedrooms','bed_x_sqft','price_per_sqft']].to_string(index=False))

# --- sklearn PolynomialFeatures for systematic generation ---
# degree=2 generates: [1, sqft, bedrooms, sqft^2, sqft*bedrooms, bedrooms^2]
poly = PolynomialFeatures(degree=2, include_bias=False)  # include_bias=False drops the constant column

# Fit and transform only the two base features
X_base  = housing_df2[['sqft', 'bedrooms']].values   # numpy array of the two original features
X_poly  = poly.fit_transform(X_base)                  # generates all degree-2 terms

# Create a named DataFrame of the polynomial output
poly_df = pd.DataFrame(X_poly, columns=poly.get_feature_names_out(['sqft', 'bedrooms']))
print("\nsklearn PolynomialFeatures output (degree=2):")
print(poly_df.astype(int).to_string(index=False))

# Import pandas and numpy
import pandas as pd
import numpy as np

# Create a house age and price DataFrame — 10 rows
housing_df3 = pd.DataFrame({
    'house_id':   [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'house_age':  [2, 15, 35, 55, 72, 88, 105, 8, 45, 120],    # age in years — wide spread
    'sale_price': [520000, 350000, 290000, 265000, 280000,       # U-shaped: new and very old = higher price
                   340000, 410000, 495000, 275000, 450000]
})

# Step 1: bin house_age into meaningful segments using pd.cut
# Bins are defined by the domain knowledge of the U-shaped relationship
age_bins   = [0, 10, 30, 60, 90, 200]                            # bin edges in years
age_labels = ['New (0-10)', 'Modern (11-30)', 'Mature (31-60)',   # human-readable labels
              'Older (61-90)', 'Vintage (91+)']

housing_df3['age_bin'] = pd.cut(
    housing_df3['house_age'],   # the column to bin
    bins=age_bins,              # the bin edges
    labels=age_labels,          # the label for each bin
    right=True                  # intervals are (left, right] — left-exclusive, right-inclusive
)

# Step 2: encode the age bin as an ordered integer for models that need numeric input
# Map each label to an integer rank based on its position in the list
age_rank_map = {label: i for i, label in enumerate(age_labels)}  # {'New':0, 'Modern':1, ...}
housing_df3['age_bin_rank'] = housing_df3['age_bin'].map(age_rank_map)  # integer encoding

# Step 3: binary vintage flag — houses older than 80 years may command a premium
housing_df3['is_vintage'] = (housing_df3['house_age'] > 80).astype(int)  # 1 if vintage, else 0

# Print results
print(housing_df3[['house_id','house_age','age_bin','age_bin_rank','is_vintage','sale_price']].to_string(index=False))