Master Numerical Feature Scaling

This skill is expert in numerical feature scaling and normalization for machine learning and data preprocessing, with knowledge of when and how to apply different scaling methods, their mathematical foundations, and their impact on various algorithms. Its scale-selection guidelines map method to situation: StandardScaler (Z-score) for normally distributed features or variance-sensitive algorithms like SVM/neural networks/PCA, MinMaxScaler for bounded [0,1] ranges or magnitude-sensitive algorithms like KNN, RobustScaler (median and IQR based) when outliers are present, MaxAbsScaler to preserve sparsity in sparse data, Normalizer when vector magnitude matters more than individual feature scale (text analysis), and Quantile transformers for uniform or normal-distribution transformations. It covers the correct fit-transform workflow (fit only on training data, transform test and new data), algorithm-specific strategies (StandardScaler for distance-based and logistic regression models, RobustScaler for tree-based models with outliers, MinMaxScaler with a [-1,1] range for neural network convergence), a custom AdvancedRobustScaler implementing IQR or median-absolute-deviation-based scaling, a ColumnTransformer pipeline applying different scalers to different feature groups by distribution shape, distribution visualization before/after scaling, scaling-quality validation checks (mean near 0 and std near 1 for StandardScaler, in-range checks for MinMaxScaler), an incremental scaler for chunked processing of large datasets with joblib persistence, and explicit data-leakage prevention plus edge-case handling for constant features, infinite values, and missing data.

Use this skill when preprocessing numerical features for ML models that are sensitive to feature scale - distance-based algorithms, neural networks, PCA, and regularized linear models all need it, while the skill notes tree-based algorithms like Random Forest and XGBoost often don't strictly need scaling (though RobustScaler can still help interpretation when outliers are present). It explicitly names the most common mistake as data leakage - fitting a scaler on the full dataset before splitting - and shows the wrong-versus-correct pattern side by side. It is not a general feature engineering guide - it's scoped specifically to numerical scaling and normalization, not encoding, feature selection, or feature creation.

class AdvancedRobustScaler(BaseEstimator, TransformerMixin):
    def __init__(self, quantile_range=(25.0, 75.0), outlier_method='iqr'):
        self.quantile_range = quantile_range
        self.outlier_method = outlier_method
        
    def fit(self, X, y=None):
        X = np.array(X)
        self.center_ = np.median(X, axis=0)
        
        if self.outlier_method == 'iqr':
            q25, q75 = np.percentile(X, self.quantile_range, axis=0)
            self.scale_ = q75 - q25
        elif self.outlier_method == 'mad':
            self.scale_ = stats.median_abs_deviation(X, axis=0)
            
        self.scale_[self.scale_ == 0] = 1.0
        return self
    
    def transform(self, X):
        return (np.array(X) - self.center_) / self.scale_

Given a feature matrix, the skill produces a fitted scaler (StandardScaler, MinMaxScaler, RobustScaler, or a custom scaler like the one above) applied correctly to train/test splits, a ColumnTransformer routing different feature groups to different scalers by distribution, pre/post scaling distribution plots, scaling-quality metric dictionaries, an IncrementalScaler for chunked large-dataset processing, and a leakage-safe fit/transform pattern plus edge-case handling for constant, infinite, or missing values before scaling.

Data scientists and ML engineers preprocessing numerical features who need to pick the right scaler per algorithm and avoid data leakage, rather than defaulting to one scaler for every pipeline. It suits teams building production ML pipelines that need persisted, reusable scalers (via joblib), incremental scaling for datasets too large to fit in memory, and validated scaling quality checks before the data reaches downstream models.