Normalizing Mixed-Scale Site Attributes for Scoring

This page solves one exact task: taking candidate-site attributes measured on incompatible scales — population in the tens of thousands, rent in dollars per square foot, competitor distance in kilometers, income in dollars — and transforming them into a commensurable 0-to-1 matrix that a weighted-sum model can combine without one variable’s raw magnitude drowning out the rest.

Normalization is the precondition that makes a suitability score meaningful. A weighted sum of raw attributes is dominated entirely by whichever column has the largest numbers, regardless of its assigned weight, because a weight of 0.30 on a population count of 80,000 dwarfs a weight of 0.15 on a rent of $45. The weighted site suitability scoring model assumes every attribute already lives on a shared, dimensionless scale; producing that scale correctly is this task.

Concept: three normalization methods and directionality #

Three methods cover almost all site-scoring work, each with a different behavior under outliers and distribution shape.

Min-max rescales a criterion linearly to a fixed $[0, 1]$ range using the observed extremes:

$$x'_{ij} = \frac{x_{ij} - \min_i x_{ij}}{\max_i x_{ij} - \min_i x_{ij}}$$

It preserves the shape of the distribution and guarantees a bounded output, but is sensitive to outliers — a single extreme value stretches the range and compresses everyone else.

Z-score (standardization) centers each criterion on its mean and scales by its standard deviation:

$$z_{ij} = \frac{x_{ij} - \mu_j}{\sigma_j}$$

producing values typically in roughly $[-3, 3]$, unbounded, and robust to the range but not to the mean being pulled by outliers. Z-scores must be mapped back into $[0, 1]$ (for example via a logistic squash) before entering a bounded weighted sum.

Rank normalization replaces each value with its position in the sorted order, scaled to $[0, 1]$. It discards magnitude entirely, keeping only ordering, which makes it completely immune to outliers and to distribution skew — at the cost of treating a tiny gap and a huge gap between adjacent sites identically.

Directionality applies to all three. Benefit criteria (population, income) keep their orientation; cost criteria (rent, competitive saturation) must be inverted so that high normalized values always mean “more suitable.” Competitor distance is a benefit criterion in disguise: being farther from competitors is good, so it needs no inversion, whereas competitor count or saturation does. Getting this wrong inverts the ranking without raising any error. This is the same discipline applied to demographic inputs in the Python script for normalizing demographic data across zip codes.

Choosing among the three comes down to how the criterion is distributed and how you want gaps treated. Min-max is the right default when the distribution is roughly uniform and magnitudes carry meaning — the difference between 40,000 and 80,000 reachable people should register as a real gap, not just a rank step. Z-score suits approximately normal criteria where you want a site’s distance from the market average to drive its contribution, and it degrades gracefully when a new candidate lands outside the previous range. Rank normalization is the safe choice when a criterion is heavily skewed or riddled with outliers you cannot clean, because it throws away magnitude entirely and keeps only order; the cost is that it cannot distinguish a photo-finish from a landslide between adjacent sites. A common production pattern mixes methods per column — min-max for well-behaved criteria, rank for the one skewed cost column — as long as every column exits in the same $[0, 1]$ range.

Prerequisites #

Before running this task you need:

• Python packages: pandas and numpy for the transforms, and scikit-learn for its batteries-included scalers. Install with pip install pandas numpy scikit-learn.
• An assembled attribute matrix — one row per candidate site, one column per criterion — with a declared direction (benefit or cost) for each column. This is the output of the matrix-assembly step in building weighted site suitability scores.
• Missing values already resolved. Normalization assumes no NaN; impute or drop before scaling, because a blank cell will otherwise propagate through min or max.

Configuration and execution parameters #

The output range is non-negotiable: whatever method is chosen, every column must exit in $[0, 1]$ so the weighted sum stays a convex combination. The outlier-handling choice is where most judgment lives — winsorizing before min-max is the common compromise between preserving magnitude and resisting a single extreme parcel.

Annotated implementation #

The function below normalizes a mixed-scale matrix into a 0-to-1 matrix, honoring each column’s direction, offering all three methods, and optionally winsorizing outliers before min-max scaling. Every method returns a bounded, dimensionless result ready for the weighted sum.

import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler

# (column, direction): 'benefit' higher-is-better, 'cost' inverted after scaling.
DIRECTIONS = {
    "reach_pop":   "benefit",
    "med_income":  "benefit",
    "comp_dist_km": "benefit",   # farther from competitors is better
    "comp_sat":    "cost",
    "rent_sqft":   "cost",
}


def _winsorize(col: pd.Series, lo=0.05, hi=0.95) -> pd.Series:
    """Clip extremes to percentile bounds so one outlier can't stretch the range."""
    return col.clip(lower=col.quantile(lo), upper=col.quantile(hi))


def normalize_matrix(df: pd.DataFrame,
                     directions: dict = DIRECTIONS,
                     method: str = "minmax",
                     winsorize: bool = True) -> pd.DataFrame:
    """
    Return a 0-1 normalized matrix with cost criteria inverted.

    method: 'minmax' | 'zscore' | 'rank'
    """
    missing = [c for c in directions if c not in df.columns]
    if missing:
        raise KeyError(f"matrix missing columns: {missing}")
    if df[list(directions)].isna().any().any():
        raise ValueError("NaN present; impute or drop before normalizing")

    out = pd.DataFrame(index=df.index)
    for col, direction in directions.items():
        s = df[col].astype(float)

        if method == "minmax":
            if winsorize:
                s = _winsorize(s)
            scaler = MinMaxScaler()            # fit only on sites being ranked
            v = scaler.fit_transform(s.to_frame()).ravel()
        elif method == "zscore":
            mu, sigma = s.mean(), s.std(ddof=0)
            z = (s - mu) / sigma if sigma > 0 else pd.Series(0.0, index=s.index)
            v = 1.0 / (1.0 + np.exp(-z))       # logistic squash into (0, 1)
        elif method == "rank":
            v = s.rank(method="average", pct=True).to_numpy()  # already in (0, 1]
        else:
            raise ValueError(f"unknown method: {method}")

        if direction == "cost":                # invert so high = more suitable
            v = 1.0 - v
        out[f"n_{col}"] = np.clip(v, 0.0, 1.0)  # guard float drift at the bounds

    return out

Driving it on a small candidate matrix shows the scale collapse in one call:

sites = pd.DataFrame({
    "reach_pop":    [82000, 15000, 47000, 210000],
    "med_income":   [61000, 48000, 95000, 38000],
    "comp_dist_km": [3.2, 0.8, 5.5, 1.1],
    "comp_sat":     [2.1, 6.8, 0.9, 5.2],
    "rent_sqft":    [42, 19, 78, 24],
})
norm = normalize_matrix(sites, method="minmax", winsorize=True)
print(norm.round(3))
print("column ranges:\n", norm.agg(["min", "max"]).round(3))

Because cost columns are inverted after scaling, the cheapest-rent and least-saturated sites now carry the highest normalized values, so a naive weighted sum over norm rewards suitability rather than raw magnitude.

Failure modes and debugging #

Data leakage is the subtle one. If you fit a MinMaxScaler on a superset that includes sites you are about to score against a held-out benchmark, the normalized values encode information from outside the decision set, and any validation against outcomes is optimistically biased. Fit the scaler strictly on the candidates being ranked in this run.

Verification #

Confirm the normalized matrix before it feeds the weighted sum:

1. Range check: every n_* column has min >= 0 and max <= 1. A value outside $[0, 1]$ means a scaling or inversion bug.

mins = norm.min()
maxs = norm.max()
assert (mins >= -1e-9).all() and (maxs <= 1 + 1e-9).all(), "out-of-range normalized value"

2. Direction check: for a benefit column, the site with the largest raw value must have the largest normalized value; for a cost column, the smallest raw value must have the largest normalized value.

raw_pop = sites["reach_pop"]
assert norm["n_reach_pop"].idxmax() == raw_pop.idxmax(), "benefit direction wrong"
raw_rent = sites["rent_sqft"]
assert norm["n_rent_sqft"].idxmax() == raw_rent.idxmin(), "cost inversion wrong"

3. No NaN: assert not norm.isna().any().any() — a NaN survivor signals a constant column or an unhandled missing value.

4. Row count preserved: assert len(norm) == len(sites) — normalization is a per-column transform and must never add or drop sites.

A matrix that passes these checks is safe to hand to the weighted-sum model: every criterion is bounded, dimensionless, and oriented so that higher always means more suitable, which is exactly the contract the scoring stage depends on.

Related #

• Building Weighted Site Suitability Scores — the parent stage that multiplies this normalized matrix by criterion weights.
• Calibrating Distance-Decay Functions for Trade Areas — produce the reachable-population term this task then rescales.
• Python Script for Normalizing Demographic Data Across Zip Codes — the same normalization discipline applied to demographic variables.

← Back to Building Weighted Site Suitability Scores