Topic 8.9: Feature Scaling

A sports academy evaluates recruits across three tests: a 100-metre sprint time (10–15 seconds, lower is better), a standing jump height (50–120 cm, higher is better), and a grip strength test (20–80 kg, higher is better). To compute a total score by summing all three, the academy faces a problem: the measurements are in completely different units and on different scales. Adding seconds to centimetres to kilograms produces a meaningless total where the jump height (range of 70 cm) dominates the sprint time (range of 5 seconds) simply because the numbers are larger.

Feature scaling solves this problem. When numeric features are measured in different units and on different scales, combining them directly is mathematically incoherent. Any model that computes distances between data points, or applies gradient descent in a parameter space, is dominated by whichever feature has the largest absolute values. Scaling brings all features onto a comparable range before they are combined.

Min-Max Normalisation rescales a feature to a fixed range — by default, [0, 1]. Every value is transformed using the formula: X_scaled = (X − X_min) / (X_max − X_min). The minimum value becomes exactly 0, the maximum becomes exactly 1, and all other values fall proportionally between them.

In the W8 dataset, the score column (range 45–99) is a natural candidate for Min-Max scaling: it has a bounded range and no severe outliers that would compress the scaled values.

import pandas as pd
from sklearn.preprocessing import MinMaxScaler

df = pd.read_csv('../Datasets/8_4_competition_results.csv')

# Select numeric columns to scale
numeric_cols = ['age', 'score']

scaler = MinMaxScaler()
df[numeric_cols] = scaler.fit_transform(df[numeric_cols])

print(df[numeric_cols].describe().round(3))

Both age and score are scaled together in a single MinMaxScaler call by passing both column names in numeric_cols. For each column independently, the minimum value maps to exactly 0.000 and the maximum maps to exactly 1.000 — that's confirmed by the min and max rows above. Note the row counts differ (192 for age, 197 for score) because both columns still contain missing values at this point in the notebook — scaling does not require imputation first, since MinMaxScaler simply skips NaN entries when computing min/max and leaves them as NaN in the output.

Z-Score Standardisation rescales a feature so that it has a mean of 0 and a standard deviation of 1. Every value is transformed using: X_scaled = (X − μ) / σ, where μ is the column mean and σ is the standard deviation. Positive scaled values are above average; negative values are below average.

In the W8 dataset, the age column is well-suited for StandardScaler: the values (15–19) are already in a narrow bounded range, and standardisation will allow the model to compare age relative to the group mean rather than in absolute years.

import pandas as pd
from sklearn.preprocessing import StandardScaler

df = pd.read_csv('../Datasets/8_4_competition_results.csv')

numeric_cols = ['age', 'score']

scaler = StandardScaler()
df[numeric_cols] = scaler.fit_transform(df[numeric_cols])

print(df[numeric_cols].describe().round(3))

After standardisation, both age and score have a mean of (essentially) 0 and a standard deviation of (essentially) 1 — that's the defining property of StandardScaler, applied independently to each column. Unlike MinMaxScaler, the output is unbounded: age ranges from about −1.58 to +2.74 standard deviations from its mean, and score ranges from about −2.91 to +1.82. A value's sign and magnitude now express how far it sits from that column's own average, in standard-deviation units — no longer in years or raw points.

The choice between MinMaxScaler and StandardScaler depends on the feature's distribution, the presence of outliers, and the algorithm that will receive the scaled data. Neither is universally superior — each is designed for different circumstances.

A direct comparison of the two scalers' output ranges shows the practical difference: MinMaxScaler bounds everything to [0, 1], while StandardScaler is unbounded and centred at 0. Re-running each scaler (as in the previous two sections) and comparing the describe() output side by side makes this concrete:

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

numeric_cols = ['age', 'score']

# MinMaxScaler result
df_mm = pd.read_csv('../Datasets/8_4_competition_results.csv')
df_mm[numeric_cols] = MinMaxScaler().fit_transform(df_mm[numeric_cols])

# StandardScaler result
df_std = pd.read_csv('../Datasets/8_4_competition_results.csv')
df_std[numeric_cols] = StandardScaler().fit_transform(df_std[numeric_cols])

print("MinMaxScaler — bounded to [0, 1]:")
print(df_mm[numeric_cols].describe().round(3))

print("\nStandardScaler — centred at 0, unbounded:")
print(df_std[numeric_cols].describe().round(3))

Key observations. With MinMaxScaler: every column's min is exactly 0.000 and max is exactly 1.000 — confirmed in both rows above. With StandardScaler: every column's mean is (essentially) 0.000 and std is (essentially) 1.000 — confirmed in the mean/std rows. The relative ordering of values within each column is identical between the two methods; only the numeric scale and reference point differ.

With both scalers applied, a final check runs the complete W8 cleaning and scaling pipeline from start to finish and summarises the result for both features.

# Summary comparison
import pandas as pd
from sklearn.preprocessing import MinMaxScaler, StandardScaler

df = pd.read_csv('../Datasets/8_4_competition_results.csv')

scaler_std = StandardScaler()
df['age_scaled'] = scaler_std.fit_transform(df[['age']])

scaler_mm = MinMaxScaler()
df['score_scaled'] = scaler_mm.fit_transform(df[['score']])

print("Feature scaling results summary:")
print(f"{'Feature':<15} {'Original Min':>12} {'Original Max':>12} {'Scaled Min':>10} {'Scaled Max':>10} {'Method'}")
print(f"{'score':<15} {df['score'].min():>12.1f} {df['score'].max():>12.1f} {df['score_scaled'].min():>10.4f} {df['score_scaled'].max():>10.4f} MinMaxScaler")
print(f"{'age':<15} {df['age'].min():>12.1f} {df['age'].max():>12.1f} {df['age_scaled'].min():>10.4f} {df['age_scaled'].max():>10.4f} StandardScaler")

The scaling results confirm the expected behaviour. Score: min=0.0000, max=1.0000 — perfectly bounded [0,1]. Age: min=−1.8729, max=+1.5169 — unbounded, centred near 0 with spread determined by the standard deviation. The two scalers produce fundamentally different output ranges, which is why the choice of scaler must match the algorithm's requirements.