⚙️ The Foundation of Predictive Modeling Performance
Garbage in, garbage out. Even the most sophisticated machine learning algorithms will fail if trained on unscaled numerical ranges, unencoded categorical strings, or missing data points. Feature Engineering transforms raw observations into informative inputs that highlight underlying patterns, while Scaling and Encoding align diverse data types into standardized numerical matrices required by mathematical optimization models. This guide covers 10 real-world feature preprocessing patterns.
NaN). Scikit-Learn's SimpleImputer replaces missing entries with column statistics such as mean, median, or most frequent values.
import numpy as np
from sklearn.impute import SimpleImputer
def run_imputation():
print("=" * 65)
print("🛠️ EXAMPLE 1: MISSING DATA IMPUTATION")
print("=" * 65)
# Simulated dataset with missing values (NaN)
X = np.array([
[25, 50000],
[32, np.nan],
[47, 120000],
[np.nan, 80000],
[29, 65000]
])
imputer = SimpleImputer(strategy='mean')
X_imputed = imputer.fit_transform(X)
print(f"Original Matrix with NaNs:\n{X}")
print(f"Imputed Matrix (Mean Strategy):\n{np.round(X_imputed, 2)}")
print("=" * 65)
if __name__ == "__main__":
run_imputation()
import numpy as np
from sklearn.preprocessing import MinMaxScaler
def run_minmax():
print("=" * 65)
print("📏 EXAMPLE 2: MIN-MAX NORMALIZATION [0, 1]")
print("=" * 65)
X = np.array([
[10, 1000],
[20, 3000],
[50, 5000]
])
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
print(f"Original Feature Matrix:\n{X}")
print(f"Min-Max Scaled Matrix:\n{X_scaled}")
print("=" * 65)
if __name__ == "__main__":
run_minmax()
import numpy as np
from sklearn.preprocessing import StandardScaler
def run_standardization():
print("=" * 65)
print("⚖️ EXAMPLE 3: Z-SCORE STANDARDIZATION")
print("=" * 65)
X = np.array([
[100, 5.0],
[120, 6.0],
[140, 7.0],
[160, 8.0]
])
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
print(f"Standardized Mean (approx 0): {np.round(X_scaled.mean(axis=0), 4)}")
print(f"Standardized Std (approx 1) : {np.round(X_scaled.std(axis=0), 4)}")
print(f"Scaled Matrix:\n{np.round(X_scaled, 2)}")
print("=" * 65)
if __name__ == "__main__":
run_standardization()
RobustScaler uses the median and Interquartile Range (IQR), making it robust to outliers.
import numpy as np
from sklearn.preprocessing import RobustScaler
def run_robust_scaling():
print("=" * 65)
print("🛡️ EXAMPLE 4: ROBUST SCALING (MEDIAN & IQR)")
print("=" * 65)
# Dataset with an extreme outlier (10,000)
X = np.array([[10], [12], [14], [15], [10000]])
scaler = RobustScaler()
X_scaled = scaler.fit_transform(X)
print(f"Original Values with Outlier:\n{X.ravel()}")
print(f"Robust Scaled Values:\n{X_scaled.ravel()}")
print("=" * 65)
if __name__ == "__main__":
run_robust_scaling()
OneHotEncoder transforms them into binary columns (0 or 1).
import numpy as np
from sklearn.preprocessing import OneHotEncoder
def run_one_hot():
print("=" * 65)
print("🏷️ EXAMPLE 5: ONE-HOT ENCODING")
print("=" * 65)
categories = np.array([['Red'], ['Blue'], ['Green'], ['Red']])
encoder = OneHotEncoder(sparse_output=False)
encoded = encoder.fit_transform(categories)
print(f"Categories : {categories.ravel()}")
print(f"Encoded Matrix :\n{encoded}")
print("=" * 65)
if __name__ == "__main__":
run_one_hot()
OrdinalEncoder maps them to ordered integers.
import numpy as np
from sklearn.preprocessing import OrdinalEncoder
def run_ordinal():
print("=" * 65)
print("📊 EXAMPLE 6: ORDINAL ENCODING")
print("=" * 65)
ranks = np.array([['Low'], ['High'], ['Medium'], ['Low']])
encoder = OrdinalEncoder(categories=[['Low', 'Medium', 'High']])
encoded = encoder.fit_transform(ranks)
print(f"Categories : {ranks.ravel()}")
print(f"Encoded : {encoded.ravel()}")
print("=" * 65)
if __name__ == "__main__":
run_ordinal()
import pandas as pd
def run_target_encoding():
print("=" * 65)
print("🎯 EXAMPLE 7: TARGET ENCODING FOR HIGH CARDINALITY")
print("=" * 65)
df = pd.DataFrame({
'zip_code': ['90210', '10001', '90210', '10001', '90210'],
'default': [0, 1, 0, 0, 1]
})
# Compute mean target per category
encoding_map = df.groupby('zip_code')['default'].mean().to_dict()
df['zip_encoded'] = df['zip_code'].map(encoding_map)
print("Original vs Target Encoded Data:")
print(df)
print("=" * 65)
if __name__ == "__main__":
run_target_encoding()
import numpy as np
def run_log_transform():
print("=" * 65)
print("📉 EXAMPLE 8: LOG TRANSFORMATION FOR SKEWED DATA")
print("=" * 65)
skewed_income = np.array([20000, 50000, 100000, 500000, 5000000])
log_transformed = np.log1p(skewed_income)
print(f"Skewed Incomes : {skewed_income}")
print(f"Log Transformed : {np.round(log_transformed, 4)}")
print("=" * 65)
if __name__ == "__main__":
run_log_transform()
PolynomialFeatures automatically generates interaction terms (e.g., $x_1^2, x_2^2, x_1 x_2$) to capture complex boundaries.
import numpy as np
from sklearn.preprocessing import PolynomialFeatures
def run_poly():
print("=" * 65)
print("➕ EXAMPLE 9: POLYNOMIAL FEATURE GENERATION")
print("=" * 65)
X = np.array([[2, 3]]) # Features [x1, x2]
poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X)
print(f"Original Features [x1, x2] : {X.tolist()}")
print(f"Generated Polynomial Features : {X_poly.tolist()}")
print("Explanation: Generates [x1, x2, x1^2, x1*x2, x2^2]")
print("=" * 65)
if __name__ == "__main__":
run_poly()
ColumnTransformer unifies these workflows.
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
def run_column_transformer():
print("=" * 65)
print("🤖 EXAMPLE 10: COLUMN TRANSFORMER PIPELINE")
print("=" * 65)
df = pd.DataFrame({
'age': [25, 32, 47],
'income': [50000, 80000, 120000],
'city': ['New York', 'London', 'New York']
})
preprocessor = ColumnTransformer(
transformers=[
('num', StandardScaler(), ['age', 'income']),
('cat', OneHotEncoder(sparse_output=False), ['city'])
]
)
X_transformed = preprocessor.fit_transform(df)
print("Transformed Feature Matrix:")
print(np.round(X_transformed, 2))
print("=" * 65)
if __name__ == "__main__":
run_column_transformer()