Core ML

Domain Adaptation

A model trained on one data distribution gets deployed on a shifted one, and domain adaptation closes that gap without collecting new labels.

The same two classes sit in different places in a source domain and a target domain; a decision boundary fit on the source domain misclassifies the target domain until the domains are aligned back together

Why Does This Exist?

A defect-detection model for a factory line was trained on thousands of labeled photos taken under one specific lighting rig. The factory upgrades its cameras, and lighting changes — brighter, a different color temperature, slightly different angle. The defects themselves haven't changed at all. The model's accuracy collapses anyway.

Nothing about the task changed — it's still "is this part defective," the same two classes, the same definition of defective. What changed is the distribution of what the inputs look like: covariate shift, a mismatch between the source domain the model was trained on and the target domain it's now deployed on. Collecting and labeling a fresh dataset under the new lighting would fix it, but that's exactly the expensive step domain adaptation exists to avoid.

Think of It Like This

A weather forecaster moving to a new climate

A forecaster trained for years reading weather patterns in a temperate coastal city develops excellent judgment — this cloud formation plus this wind direction reliably means rain within the hour. Transferred to a desert city, that same judgment misfires constantly, not because the forecaster's underlying skill at reading atmospheric patterns disappeared, but because the relationship between what they observe and what it means shifted along with the climate.

A forecaster who deliberately studies how the desert's patterns differ from the coast's — recalibrating what a given cloud formation now implies — adapts far faster than one who either starts over from nothing or stubbornly applies coastal rules unchanged. Domain adaptation is that deliberate recalibration, applied to a model instead of a person.

How It Actually Works

Naming the shift precisely: covariate shift versus concept shift

Covariate shift means the input distribution $P(x)$ changes between source and target domains, while the relationship between input and label, $P(y \mid x)$ , stays the same — the lighting changed, but a defect is still a defect under any lighting. This is the case domain adaptation is built for. Concept shift is different and harder: the label relationship itself changes, meaning what used to count as a defect no longer does. No amount of aligning input distributions fixes concept shift, because the thing that moved isn't the inputs — it's the definition of the task itself.

Feature alignment: making the domains statistically indistinguishable

One family of domain adaptation methods works by training the model's internal representation to make source and target domain examples statistically indistinguishable from each other, even though the raw inputs obviously differ. Domain-adversarial training does this directly: alongside the main task, train a small classifier whose only job is to guess which domain a given internal representation came from, and train the main network to make that domain classifier fail — the features get pushed toward a form that no longer reveals whether an example was source or target. If the domain classifier truly can't tell the domains apart at the feature level, the reasoning goes, then whatever the main task learned on the source domain should transfer, since the target domain now looks statistically like more of the same thing.

A simpler baseline: recentering the features

A much cruder but frequently effective first step is to recenter the target domain's features to match the source domain's statistics — subtract the target domain's mean, add back the source domain's mean, before feeding examples to the source-trained model. This doesn't address anything as deep as domain-adversarial training does, but when the shift is close to a simple translation in feature space, it recovers a surprising amount of the lost accuracy for very little engineering cost, and it's worth trying before reaching for anything more elaborate.

Why this differs from ordinary transfer learning

Transfer learning typically assumes the target task has at least some labeled data to fine-tune on, even if less than would be needed to train from scratch. Domain adaptation is often framed as the harder unsupervised case: the target domain has no labels at all, and the only leverage available is the assumption that the underlying task hasn't changed — only the input distribution has.

Show Me the Code

A boundary fit on a source domain, evaluated on a target domain shifted to the right, before and after a simple mean-recentering fix.

1import numpy as np2
3
4def fit(x: np.ndarray, y: np.ndarray, steps: int = 300) -> tuple[float, float]:5    w, b = 0.0, 0.06    for _ in range(steps):7        p = 1 / (1 + np.exp(-(w * x + b)))8        w -= 0.5 * float(np.mean((p - y) * x))9        b -= 0.5 * float(np.mean(p - y))10    return w, b11
12
13def accuracy(w: float, b: float, x: np.ndarray, y: np.ndarray) -> float:14    p = 1 / (1 + np.exp(-(w * x + b)))15    return float(((p > 0.5).astype(float) == y).mean())16
17
18rng = np.random.default_rng(5)19x_src = np.concatenate([rng.normal(-2, 1, 500), rng.normal(2, 1, 500)])20y_src = np.concatenate([np.zeros(500), np.ones(500)])21w, b = fit(x_src, y_src)22print(f"source-domain accuracy: {accuracy(w, b, x_src, y_src):.3f}")23
24x_tgt = np.concatenate([rng.normal(1, 1, 500), rng.normal(5, 1, 500)])  # shifted right by 325y_tgt = np.concatenate([np.zeros(500), np.ones(500)])26print(f"target accuracy, no adaptation: {accuracy(w, b, x_tgt, y_tgt):.3f}")27
28shift = x_tgt.mean() - x_src.mean()29print(f"target accuracy, mean-shift adaptation: {accuracy(w, b, x_tgt - shift, y_tgt):.3f}")30# -> source-domain accuracy: 0.97931# -> target accuracy, no adaptation: 0.56332# -> target accuracy, mean-shift adaptation: 0.985

Deploying the source-trained model directly on the shifted target domain drops accuracy from 97.9% to barely above chance at 56.3%. Recentering the target domain's mean to match the source domain's, before scoring, recovers essentially all of it — a one-line fix for a shift that happens to be a simple translation.

Watch Out For

Applying domain adaptation to concept shift instead of covariate shift

Every technique on this page assumes the input-output relationship stayed fixed and only the input distribution moved. If the task itself has genuinely changed — what counts as a defect really did change, not just how it looks — aligning feature distributions will not fix a broken label relationship, and can actively make things worse by forcing the model to treat genuinely different situations as the same.

Trusting mean-recentering when the shift isn't a simple translation

Mean-shift adaptation only works well when the target distribution is approximately a shifted copy of the source distribution. If the shift also changes the spread, the shape, or the relationship between features, subtracting a single mean difference will only partially help and can leave a false sense that adaptation succeeded. Check accuracy on a held-out labeled slice of the target domain, if any exists, rather than assuming the simple fix generalizes.

The Quick Version

Domain adaptation addresses covariate shift: the input distribution changes between training and deployment, while the true input-output relationship stays fixed.
It's distinct from concept shift, where the task's actual definition changes — no amount of input-distribution alignment fixes that.
Domain-adversarial training pushes internal features toward a form that a domain classifier can't distinguish, so source-trained behavior transfers to the target domain.
A simpler mean-recentering step can recover much of the lost accuracy when the shift is close to a pure translation in feature space.
It's typically framed as an unsupervised problem: no labels exist in the target domain at all.