Domain generalization for sensors (DIVERSIFY)

"They trained me on nine wrists and tested me on a tenth. I had memorized nine wrists. The tenth was a stranger, and strangers were never in my loss function."

An Overfit AI Agent

Why sensor domains are latent, and why that breaks textbook DG

Classical domain generalization, from methods like domain-adversarial training (DANN), invariant risk minimization (IRM), and group distributionally robust optimization (GroupDRO), assumes you know which domain each sample came from. Give the algorithm a domain label per example and it can penalize any feature that lets a discriminator tell the domains apart, on the theory that a truly invariant feature will also transfer to the unseen one. That assumption is comfortable in vision benchmarks where "domain" means a labeled dataset like sketch, cartoon, or photo. It collapses for wearable and industrial time series.

The reason is that the shift-inducing factors in a sensor stream are usually not recorded and often not even discrete. A single "subject 07" walking is not one domain: their sensor drifts with skin temperature, the strap loosens over an afternoon, the phone rotates in the pocket, the gait changes with fatigue. The distribution that actually matters is a fine-grained mixture of latent sub-populations, and the coarse label you happened to log (subject ID, device model) is a poor proxy for it. Aligning on the wrong grouping wastes the invariance budget: you make the model blind to distinctions that never hurt transfer while leaving the genuinely fragile ones untouched. What you need is a way to discover the split that will hurt most, then defend against exactly that split.

The DIVERSIFY min-max: manufacture the worst split, then erase it

DIVERSIFY (Lu and colleagues, ICLR 2023) formalizes the two moves as an alternating optimization over three networks: a feature extractor \(g\), a task classifier \(h\) for the activity labels, and an auxiliary domain discriminator \(d\). It iterates three steps until convergence.

Step 1, fine-grained latent-domain characterization. Cluster the current representations into \(K\) pseudo-domains and assign each window a latent domain label. \(K\) is a small hyperparameter (often 2 to 10), decoupled from the number of subjects. The clustering is not innocent: it is pushed to maximize the between-cluster distribution gap so that the pseudo-domains are the hardest grouping the current features admit.

Step 2, worst-case latent distribution. Update the feature extractor to increase the divergence between those pseudo-domains, sharpening the adversarial scenario. Conceptually this seeks

where \(\mathcal{Z}\) ranges over latent partitions and \(\mathrm{dist}\) is a distributional distance the discriminator estimates. This is the step textbook DG skips entirely.

Step 3, domain-invariant learning. Now flip the sign. Train \(g\) to fool the discriminator \(d\) on the latent domains just discovered, while \(h\) keeps the activity labels accurate. Using a gradient-reversal layer, the joint objective is

so \(g\) minimizes task loss and simultaneously destroys any signal \(d\) could use to recover the latent domain. The three steps loop: characterize a worse split, then align it away, repeatedly, so the representation is invariant not to one handed-down grouping but to the most damaging grouping the data can produce. The trade-off parameter \(\lambda\) controls how aggressively invariance is bought at the cost of task accuracy.

The mechanism in code: a gradient-reversal domain-adversarial core

The engine underneath Step 3 is the gradient-reversal layer: in the forward pass it is the identity, and in the backward pass it multiplies the gradient by \(-\lambda\). That single sign flip turns one optimizer into the min-max of the invariance objective above. The skeleton below is the reusable core; DIVERSIFY wraps it with the clustering of Steps 1 and 2 that supplies the domain labels rather than reading them from a file.

import torch, torch.nn as nn
from torch.autograd import Function

class GradReverse(Function):
    @staticmethod
    def forward(ctx, x, lamb):
        ctx.lamb = lamb
        return x.view_as(x)              # identity forward
    @staticmethod
    def backward(ctx, grad):
        return -ctx.lamb * grad, None    # sign-flipped backward

def grad_reverse(x, lamb=1.0):
    return GradReverse.apply(x, lamb)

class DomainAdversarial(nn.Module):
    def __init__(self, encoder, feat_dim, n_classes, n_latent_domains):
        super().__init__()
        self.g = encoder                                  # shared features g(x)
        self.h = nn.Linear(feat_dim, n_classes)           # activity head
        self.d = nn.Linear(feat_dim, n_latent_domains)    # latent-domain head

    def forward(self, x, lamb):
        f = self.g(x)
        y_logits = self.h(f)                              # task path
        d_logits = self.d(grad_reverse(f, lamb))          # adversarial path
        return y_logits, d_logits

def step(model, x, y, dom, lamb, opt, ce=nn.CrossEntropyLoss()):
    y_logits, d_logits = model(x, lamb)
    loss = ce(y_logits, y) + ce(d_logits, dom)   # GRL makes d-term adversarial to g
    opt.zero_grad(); loss.backward(); opt.step()
    return loss.item()

Notice what Code 66.3.1 does not contain: any real domain label. The dom tensor is synthetic, refreshed each outer iteration by re-clustering the features. That is the entire conceptual difference from DANN, and it is why the method works on raw sensor logs where the only "domain" you ever recorded is a subject ID that does not capture the shift.

When DG is the right tool, and when to reach past it

Domain generalization earns its keep when you genuinely cannot touch the target before acting: a certified medical device that must not adapt in the field, a firmware-frozen microcontroller classifier, a first-boot experience where no target data exists yet. It is also the honest baseline: if a leave-one-domain-out split (the only trustworthy evaluation here, and a direct application of the leakage-safe discipline from Chapter 50's robustness lens) already gives you an acceptable target error, you may not need adaptation at all, and you avoid its runtime risk.

But DG has a ceiling. It buys invariance against the worst case the training data can express, and if the true target sits outside that convex hull, no amount of source-only alignment reaches it. When you can observe even a trickle of unlabeled target stream at deployment, spending it is almost always worth more than a better DG regularizer. That is the pivot the rest of this chapter takes: from making one frozen model robust in advance to letting the model quietly adjust itself once the target arrives.

What's Next

In Section 66.4, we lift the constraint that made this section hard: we let the model see the unlabeled target stream at inference time and update itself on the spot. Test-time training and adaptation methods such as TENT and CoTTA turn the frozen, defend-in-advance stance of DG into a live, self-correcting one, and we will see both the accuracy they recover and the new failure mode, silent collapse, that they invite.