Test-time training and adaptation (TENT, CoTTA)

"They shipped me trained on ten subjects and expected me to meet the eleventh with grace. So I learned to adjust my own knobs between heartbeats, quietly, without asking anyone for a label."

A Self-Tuning AI Agent

Why adapt at test time at all

A sensor model fails in the field for a concrete reason: the feature statistics it saw in training no longer match what the deployed sensor produces. A human-activity model trained on ten subjects meets an eleventh whose gait, wrist placement, and phone model shift the accelerometer distribution; a bearing-fault detector meets a motor running five degrees hotter. The decision boundary is often still roughly correct, but the activations feeding it have drifted, and in a network with batch normalization that drift is exactly what the normalization statistics were supposed to remove. That observation is the seed of the whole field. If the only thing that broke is the input statistics, you may be able to repair the model without a single label, just by re-estimating those statistics and gently re-tuning the layers that consume them. TTA is attractive for sensing precisely because the alternative, collecting labels for every new subject or device and retraining, does not scale to a fleet, and because the target data streams in for free.

Test-time training: adapt through a self-supervised proxy

Test-time training (TTT, Sun et al., 2020) is the founding idea. At training time you attach a self-supervised auxiliary head to a shared feature extractor and train two losses jointly: the real task and a proxy that needs no labels. For images the classic proxy is predicting a rotation; for sensor time series the natural analogues from Chapter 17 are predicting an applied transformation (time reversal, channel permutation, a jitter magnitude) or a masked-reconstruction loss. At test time you are handed an unlabeled window, you cannot compute the task loss, but you can compute the proxy loss, so you take one or a few gradient steps on it to update the shared features, and only then read off the task prediction. The bet is that a feature extractor forced to solve the proxy well on the target sample is also a better substrate for the real task. TTT works, but it commits you to a specific auxiliary head chosen before deployment, and it modifies the whole backbone, which is heavy for an edge device.

TENT: minimize the entropy of your own predictions

TENT (Test-time ENTropy minimization, Wang et al., 2021) is the idea that made TTA practical, and it is disarmingly simple. It needs no auxiliary head and no change to how you trained. The insight: on data a model handles well, its softmax predictions are confident (low entropy); on shifted data they are mushy (high entropy). So drive the entropy down. For a prediction \(\hat{y}\) with class probabilities \(p_c\), TENT minimizes the Shannon entropy

averaged over the current test batch. Two design choices make it safe and cheap. First, it updates only the batch-norm affine parameters (the per-channel scale \(\gamma\) and shift \(\beta\)), a few thousand numbers, freezing every convolution and linear weight; this keeps the learned decision structure intact and cannot overfit the way a full backbone update can. Second, it recomputes the batch-norm normalization statistics from the test batch itself rather than reusing the stale training running averages, which alone recovers a surprising fraction of the lost accuracy. Entropy is minimized by making predictions both confident and, as a side effect of sharpening, more separated. Because the update touches so little, TENT runs online: one forward pass, one entropy backward pass over \(\gamma,\beta\), predict, repeat on the next batch. It is the reason TTA moved from a research curiosity to something you can put on a phone.

CoTTA: surviving a domain that never stops changing

TENT assumes a single fixed target domain. Real sensor deployments are continual: a wearable crosses from walking to a car to a cold morning run, a factory line changes product every hour. Under this stream, plain TENT accumulates error, because each adaptation step is trained on the last step's possibly-wrong predictions, and it suffers catastrophic forgetting of the source knowledge. CoTTA (Continual Test-Time Adaptation, Wang et al., 2022) adds three guards. (1) A weight-averaged teacher: a slowly moving exponential average of the student supplies the target pseudo-labels, so the supervision signal is smoother and less noisy than the student's own instantaneous output. (2) Augmentation averaging: when the teacher is uncertain, it averages predictions over several augmentations of the input to produce a more reliable pseudo-label. (3) Stochastic restore: after each update a small random fraction of weights is reset to their original source values, which continually reinjects source knowledge and provably bounds forgetting. The net effect is an adapter that can ride a shifting stream for a long time without collapsing, at the cost of running a teacher and augmentations, which is heavier than TENT.

A minimal TENT step

The whole method is small enough to read. Code 66.4.1 configures a network so that only its batch-norm layers train and their statistics are re-estimated from the incoming batch, then adapts by minimizing prediction entropy. Everything else stays frozen.

import torch, torch.nn as nn

def configure_for_tent(model):
    """Freeze everything except BN affine params; let BN use batch stats."""
    model.train()                                  # BN uses batch statistics
    for p in model.parameters():
        p.requires_grad_(False)                    # freeze all weights
    params = []
    for m in model.modules():
        if isinstance(m, (nn.BatchNorm1d, nn.BatchNorm2d)):
            m.track_running_stats = False          # ignore stale train stats
            m.running_mean = m.running_var = None  # normalize with this batch
            for p in m.parameters():               # gamma, beta only
                p.requires_grad_(True)
                params.append(p)
    return params

def softmax_entropy(logits):
    p = logits.softmax(dim=1)
    return -(p * p.clamp_min(1e-8).log()).sum(dim=1)   # per-sample entropy

@torch.enable_grad()
def tent_adapt_step(model, x, optimizer):
    logits = model(x)                              # forward on unlabeled batch
    loss = softmax_entropy(logits).mean()          # label-free objective
    optimizer.zero_grad(); loss.backward(); optimizer.step()
    return logits.detach()                         # prediction AFTER adapting

# usage on a stream of unlabeled sensor batches
params = configure_for_tent(model)
optimizer = torch.optim.Adam(params, lr=1e-3)
for x_batch in unlabeled_test_stream:              # e.g. accel windows
    preds = tent_adapt_step(model, x_batch, optimizer).argmax(1)

Note in Code 66.4.1 that the optimizer is handed only the collected batch-norm parameters, so the several-million-weight backbone never moves. That single restriction is what keeps the entropy objective from steering the model off a cliff, and it is the difference between TENT and a full-backbone update that would overfit the first noisy batch it saw.

When TTA helps, and when it quietly hurts

TTA is not free robustness. It helps most when the shift is a genuine covariate shift (the input statistics moved but the label meaning did not), when unlabeled target data arrives in reasonable quantity, and when the model uses normalization layers you can re-estimate. It hurts when the shift is a label or concept shift (the classes themselves changed, so confident predictions are confidently wrong), when batches are tiny and non-i.i.d. so batch statistics are unreliable, or when the stream is class-imbalanced enough that entropy minimization collapses toward the majority. Two rules keep you safe. Prefer the least invasive method that closes the gap: statistics-only recomputation first, then TENT, then CoTTA only if the stream is truly continual. And never adapt blind; the whole point of Section 66.6 is that you must monitor a risk signal during adaptation and be ready to freeze or roll back, because an unlabeled objective can walk your accuracy down as smoothly as it walks it up.

What's Next

In Section 66.5, we drop the gradient step entirely. Backpropagating on a microcontroller between sensor windows is often a non-starter, so we study optimization-free test-time adaptation for cross-person human-activity recognition: methods that repair a model by re-aligning feature statistics or prototypes directly, no optimizer, no learning rate, no risk of the entropy collapse this section warned you about.