Feature Engineering: Leaky Aggregate Causes AUC Drop

import numpy as np
from sklearn.preprocessing import MinMaxScaler, StandardScaler
import pandas as pd

# Simulate a small customer dataset with wildly different scales
customer_data = pd.DataFrame({
    'age':    [22, 35, 47, 58, 29, 63],
    'income': [32000, 75000, 120000, 95000, 48000, 180000]
})

print("=== Raw Data ===")
print(customer_data)
print(f"Income std dev: {customer_data['income'].std():.1f}")
print(f"Age std dev:    {customer_data['age'].std():.1f}\n")

# --- Min-Max Scaling ---
# Each value becomes (value - min) / (max - min)
# Result: every column lives between 0.0 and 1.0
min_max_scaler = MinMaxScaler()
min_max_scaled = pd.DataFrame(
    min_max_scaler.fit_transform(customer_data),
    columns=['age_minmax', 'income_minmax']
)
print("=== After Min-Max Scaling ===")
print(min_max_scaled.round(3))

# --- Standardization (Z-score) ---
# Each value becomes (value - mean) / std_dev
# Result: mean=0, std=1 — no fixed upper or lower bound
standard_scaler = StandardScaler()
standardized = pd.DataFrame(
    standard_scaler.fit_transform(customer_data),
    columns=['age_zscore', 'income_zscore']
)
print("\n=== After Standardization ===")
print(standardized.round(3))
print(f"\nAge z-score mean:    {standardized['age_zscore'].mean():.6f}  (should be ~0)")
print(f"Income z-score std:  {standardized['income_zscore'].std():.6f}  (should be ~1)")

import pandas as pd
from sklearn.preprocessing import LabelEncoder, OrdinalEncoder

# A dataset where both ordinal AND nominal categories exist
product_orders = pd.DataFrame({
    'product_color':    ['Red', 'Blue', 'Green', 'Blue', 'Red', 'Green'],  # NOMINAL — no order
    'satisfaction_level': ['Low', 'High', 'Medium', 'High', 'Low', 'Medium'],  # ORDINAL — real order
    'purchase_amount':  [25.0, 89.0, 45.0, 120.0, 30.0, 67.0]
})

print("=== Original Data ===")
print(product_orders, "\n")

# --- WRONG approach: Label Encoding a NOMINAL column ---
# This assigns Red=2, Green=0, Blue=1 — implying Green < Blue < Red
# The model will treat color differences as numerical distances. That's invented information.
bad_label_encoder = LabelEncoder()
product_orders['color_BAD_label'] = bad_label_encoder.fit_transform(product_orders['product_color'])
print("=== WRONG: Label Encoded Color (invents false order) ===")
print(product_orders[['product_color', 'color_BAD_label']])
print(f"Classes learned: {bad_label_encoder.classes_}")
print(f"Encoded as:      {list(range(len(bad_label_encoder.classes_)))}\n")

# --- RIGHT approach: One-Hot Encoding for NOMINAL columns ---
# Creates separate binary columns — no false ranking, model learns each color independently
one_hot_encoded = pd.get_dummies(
    product_orders[['product_color']],
    columns=['product_color'],
    drop_first=True   # drop one column to avoid multicollinearity (dummy variable trap)
)
print("=== CORRECT: One-Hot Encoded Color ===")
print(one_hot_encoded, "\n")

# --- RIGHT approach: Ordinal Encoding for ORDINAL columns ---
# We explicitly define the meaningful order — Low < Medium < High
ordinal_encoder = OrdinalEncoder(categories=[['Low', 'Medium', 'High']])
product_orders['satisfaction_encoded'] = ordinal_encoder.fit_transform(
    product_orders[['satisfaction_level']]
).astype(int)
print("=== CORRECT: Ordinal Encoded Satisfaction (preserves real order) ===")
print(product_orders[['satisfaction_level', 'satisfaction_encoded']])

import pandas as pd
import numpy as np

# Simulated e-commerce customer dataset
customers = pd.DataFrame({
    'customer_id':       [101, 102, 103, 104, 105, 106],
    'account_age_days':  [365, 12, 890, 45, 200, 730],
    'total_orders':      [24, 1, 87, 3, 18, 55],
    'total_spent_usd':   [1200, 35, 8700, 90, 950, 4400],
    'last_login_days_ago': [2, 45, 1, 30, 8, 15],
    'age':               [34, 22, 61, 19, 45, 38]
})

print("=== Raw Customer Features ===")
print(customers.to_string(index=False), "\n")

# --- Ratio feature: average order value ---
# This captures 'how much does this customer spend per purchase' — a better
# signal for high-value customer segmentation than raw totals alone
customers['avg_order_value'] = (
    customers['total_spent_usd'] / customers['total_orders']
).round(2)

# --- Ratio feature: order frequency ---
# Orders per day since account creation — normalizes total_orders by tenure
# A new customer with 3 orders in 12 days is MORE active than a veteran with 24 in 365 days
customers['orders_per_day'] = (
    customers['total_orders'] / customers['account_age_days']
).round(4)

# --- Binary flag feature: is the customer 'at risk'? ---
# Domain knowledge: customers inactive for 30+ days churn at 3x the rate
customers['is_churn_risk'] = (customers['last_login_days_ago'] >= 30).astype(int)

# --- Binning: age groups ---
# Linear models struggle with non-linear age effects — binning makes the
# relationship step-shaped and easier for them to capture
age_bin_edges  = [0, 25, 35, 50, 100]
age_bin_labels = ['GenZ', 'YoungAdult', 'MidCareer', 'Senior']
customers['age_group'] = pd.cut(
    customers['age'],
    bins=age_bin_edges,
    labels=age_bin_labels,
    right=True  # intervals are (left, right] — so 25 falls in GenZ, 26 in YoungAdult
)

print("=== Engineered Features ===")
engineered_cols = [
    'customer_id', 'avg_order_value', 'orders_per_day',
    'is_churn_risk', 'age_group'
]
print(customers[engineered_cols].to_string(index=False))

# Quick sanity check — customer 102 has 1 order in 12 days vs customer 101 with 24 in 365
print("\n=== Sanity Check: Order Frequency ===")
for _, row in customers.iterrows():
    print(f"  Customer {row['customer_id']}: {row['orders_per_day']:.4f} orders/day "
          f"({'high' if row['orders_per_day'] > 0.05 else 'low'} frequency)")

import pandas as pd
import numpy as np

# Simulated transaction timestamps
dates = pd.to_datetime([
    '2025-01-05 08:15:00',
    '2025-01-05 23:45:00',
    '2025-03-15 14:30:00',
    '2025-07-20 03:10:00',
    '2025-11-11 12:00:00'
])

tx_df = pd.DataFrame({'timestamp': dates,
                     'amount': [50, 200, 15, 300, 100]})

# Extract basic components
tx_df['hour'] = tx_df['timestamp'].dt.hour
tx_df['day_of_week'] = tx_df['timestamp'].dt.dayofweek  # Monday=0
tx_df['month'] = tx_df['timestamp'].dt.month
tx_df['is_weekend'] = (tx_df['timestamp'].dt.dayofweek >= 5).astype(int)

# Cyclical encoding for hour (preserves 23 and 0 as close)
tx_df['hour_sin'] = np.sin(2 * np.pi * tx_df['hour'] / 24)
tx_df['hour_cos'] = np.cos(2 * np.pi * tx_df['hour'] / 24)

# Time since a reference (e.g., first transaction)
first_timestamp = tx_df['timestamp'].min()
tx_df['hours_since_first'] = (tx_df['timestamp'] - first_timestamp).dt.total_seconds() / 3600

print("=== Date/Time Features ===")
print(tx_df[['timestamp', 'hour', 'day_of_week', 'month', 'is_weekend', 'hour_sin', 'hour_cos', 'hours_since_first']])

from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer

# Sample product descriptions
documents = [
    "Stainless steel water bottle with double-wall insulation",
    "Cotton t-shirt in size medium available in blue and black",
    "Wireless bluetooth noise-cancelling headphones with 30-hour battery",
    "Organic green tea bags pack of 100"
]

# --- Bag-of-Words ---
bow = CountVectorizer(stop_words='english')
bow_matrix = bow.fit_transform(documents)
print("=== Bag-of-Words Feature Matrix (first 2 documents) ===")
print(pd.DataFrame(bow_matrix.toarray()[:2], columns=bow.get_feature_names_out()).T)
print()

# --- TF-IDF ---
tfidf = TfidfVectorizer(stop_words='english')
tfidf_matrix = tfidf.fit_transform(documents)
print("=== TF-IDF Feature Matrix (first 2 documents) ===")
print(pd.DataFrame(tfidf_matrix.toarray()[:2], columns=tfidf.get_feature_names_out()).T)