Standardize Features (Z-Score)

Standardization (the z-score transform) rescales each feature so it has zero mean and unit variance. It is a routine preprocessing step for models that are sensitive to feature scale, and interviewers ask for it to check that you can reduce along the right axis and handle the degenerate constant-column case.

Definition

For a column x with mean mu and standard deviation sigma, the standardized value of each entry is:

z[i] = (x[i] - mu) / sigma

The transform is applied independently to every column of the input matrix.

Task

Complete standardize(X) so it returns a new array of the same shape where each column has mean 0 and standard deviation 1. X is a 2-D NumPy array with rows as samples and columns as features. If a column has zero variance (all entries equal), return that column as all zeros rather than dividing by zero. Do not call sklearn or any built-in scaler.

Example

X = np.array([[1.0, 10.0, 5.0],
              [2.0, 20.0, 5.0],
              [3.0, 30.0, 5.0]])
standardize(X)
# -> array([[-1.22474487, -1.22474487,  0.        ],
#           [ 0.        ,  0.        ,  0.        ],
#           [ 1.22474487,  1.22474487,  0.        ]])

The first two columns become [-1.2247, 0, 1.2247] after centering and scaling; the third column is constant, so it maps to all zeros.

Constraints

• 1 <= n <= 10^6, 1 <= d <= 10^3; use vectorized NumPy, not a per-column Python loop.
• Use the population standard deviation (ddof=0).
• Values fit in float64.

Approach

Reduce down the rows with axis=0 to get a per-column mean and standard deviation, then center and scale by broadcasting those length-d vectors across all rows at once. The only subtlety is a constant column, whose standard deviation is 0: replace those zeros with 1 before dividing so the centered values (already 0) pass through as 0 instead of producing nan.

Solution

import numpy as np

def standardize(X):
    X = np.asarray(X, dtype=np.float64)
    mu = X.mean(axis=0)                 # per-column mean, shape (d,)
    sigma = X.std(axis=0, ddof=0)       # per-column std, shape (d,)
    safe_sigma = np.where(sigma == 0, 1.0, sigma)  # avoid divide-by-zero
    return (X - mu) / safe_sigma

Walkthrough

On the example with columns [1,2,3], [10,20,30], [5,5,5]:

• mu = [2, 20, 5] and sigma = [0.8165, 8.165, 0] (population std).
• The third column has sigma = 0, so safe_sigma = [0.8165, 8.165, 1.0].
• Centering: X - mu gives columns [-1,0,1], [-10,0,10], [0,0,0].
• Dividing by safe_sigma: the first two columns become [-1.2247, 0, 1.2247]; the constant column stays [0, 0, 0] because dividing zeros by 1 leaves zeros.

Complexity & notes

• Time O(n·d), space O(n·d) — a couple of full-array reductions plus one broadcasted subtract-and-divide.
• Using np.where(sigma == 0, 1.0, sigma) is cleaner than adding a tiny epsilon: it leaves nonzero columns exactly correct and maps constant columns to exact zeros, whereas sigma + 1e-8 slightly distorts every column.
• ddof=0 is the population standard deviation, which is the convention scalers use; ddof=1 (sample std) would change the scale by a factor of sqrt(n/(n-1)).
• In a real pipeline you fit mu and sigma on the training set and reuse them to transform validation and test data, so the same shift and scale apply everywhere and no target leakage occurs.