What does scikit-learn's StandardScaler learn in fit(), and why never fit it on test data?

## The transformer contract Every scikit-learn preprocessing object is stateful. `fit()` learns something from the data it is handed and stores it on the instance under a trailing-underscore attribute; `transform()` applies that stored state to any matrix with the same columns. `fit_transform()` is nothing but the two calls in sequence on the same data. The whole train/test discipline in preprocessing falls out of that split: whoever calls `fit` decides what statistics the model is standardised against forever after. ## What StandardScaler stores After `scaler.fit(X_train)` the instance carries: - `mean_` — one mean per column (unless `with_mean=False`, when it is `None`). - `var_` — one variance per column, and `scale_` — the square root of it, the actual divisor. - `n_samples_seen_` — how many rows contributed, per column, which is what makes `partial_fit()` able to update the statistics incrementally over minibatches. - `n_features_in_` and, for a DataFrame input, `feature_names_in_` — used to check that later `transform()` calls present the same columns in the same order. `transform()` computes `(x - mean_) / scale_` elementwise. `inverse_transform()` reverses it, which is how you get predictions back into original units when you have scaled a regression target with a separate scaler. ## Why fitting on test data is wrong Two separate harms, and candidates usually only name the first. The measurement harm: the test set exists to estimate performance on data the model has never influenced. If the scaler is fitted on the test set, information about the test distribution — its centre and spread — has been folded into the features the model consumes, so the score is optimistic and no longer an estimate of anything you will observe in production. The deployment harm, which is the more concrete one: at serving time you often score a single row. A single row has a mean equal to itself and a standard deviation of zero. There is no test-set-shaped batch to fit on, so a pipeline that only works when it can re-fit is a pipeline that cannot be deployed. The scaler must ship with frozen `mean_`/`scale_` learned once on training data, exactly as a model ships with frozen coefficients. The correct sequence is `scaler.fit(X_train)` then `scaler.transform(X_train)` and `scaler.transform(X_test)`; in practice you put the scaler in a `Pipeline` so `fit`/`predict` route the calls for you and there is no opportunity to get it wrong by hand. ## Edge cases interviewers probe **Constant columns.** Variance is zero, so the naive divisor is zero. scikit-learn replaces zero scales with `1.0`, so a constant feature standardises to all zeros instead of `NaN` or `inf`. No warning is raised, so a column that is constant only in your training split silently becomes a dead feature. **Sparse input.** Centring a sparse matrix would fill in every implicit zero and blow up memory, so `StandardScaler` raises on sparse input unless you pass `with_mean=False`, which divides by `scale_` without subtracting. When you want the structure of sparse data untouched, `MaxAbsScaler` is the natural choice — it divides by the maximum absolute value per column and leaves zeros as zeros. **Unseen ranges.** Standardising does not clip. A test value far outside the training range simply produces a large z-score, which is usually what you want. The sibling scalers behave differently in this respect: `MinMaxScaler` maps the training range onto `feature_range` (default `(0, 1)`) using `data_min_`/`data_max_`, so test values outside the training range land outside that interval unless you pass `clip=True`; `RobustScaler` centres on the median and divides by the interquartile range (`center_`, `scale_`, controlled by `quantile_range`, default the 25th–75th percentiles), which is why it is the usual pick when a few extreme values would otherwise dominate the mean and standard deviation. **`with_std=False`.** Centres without scaling; occasionally useful when a downstream method needs zero-mean input but the units are meaningful. ## What a strong answer sounds like Name the attributes, state the `(x - mean_) / scale_` formula, say plainly that the test set only gets `transform()`, and give the single-row serving argument rather than only the abstract 'leakage' word. If you add the zero-variance and sparse behaviours, you have demonstrated you have actually read what the object does rather than only used it.