Debugging and inspecting learned filters

"The loss curve told me the model was fine. The dead filter told me the truth."

A Skeptical AI Agent

This section assumes you have trained at least a small 1D convolutional network and are comfortable with the frequency-domain view of a filter from Chapter 7. Everything below treats a learned kernel exactly as Chapter 7 treats any FIR filter: a short impulse response with a magnitude response you can read off with an FFT. The novelty is only that gradient descent, not you, chose the taps.

Read the kernel, then read its spectrum

What. The first-layer weights of a 1D CNN are literally a bank of FIR filters, one per output channel per input axis. For a layer with tensor shape \((C_\text{out}, C_\text{in}, k)\), each row \(w[c,:,:]\) is a filter you can plot in the time domain and, more revealingly, transform to see its passband. A learned kernel \(w\) of length \(k\) has magnitude response

and the peak of \(|H(f)|\) tells you the frequency each filter is tuned to.

Why. A time-domain kernel is hard to interpret by eye, but its spectrum is not. On a wrist accelerometer you expect some filters to concentrate near 1 to 3 Hz (walking cadence and its harmonics) and others to spread across a broad band (impacts, noise). If instead every filter has a flat, feature-less spectrum, the layer has learned nothing structured and is probably acting as a random projection. Reading spectra also exposes redundancy: two filters with near-identical passbands are wasting capacity.

How. Pull the weights off the first layer, FFT each kernel (zero-padded for resolution), and sort by peak frequency. The snippet below does exactly this for a trained model and flags the two failure modes we care about most: dead filters and duplicated filters.

import torch, torch.nn.functional as F

def inspect_first_layer(conv, fs, pad=256):
    W = conv.weight.detach()                     # (C_out, C_in, k)
    W = W.mean(dim=1)                            # collapse input axes -> (C_out, k)
    # Time-domain health: L2 norm per filter; near-zero == dead
    norms = W.norm(dim=1)
    dead = (norms < 0.05 * norms.median()).nonzero().flatten()
    # Frequency-domain view
    H = torch.fft.rfft(W, n=pad, dim=1).abs()    # (C_out, pad//2+1)
    freqs = torch.fft.rfftfreq(pad, 1.0/fs)
    peak_hz = freqs[H.argmax(dim=1)]
    # Duplicate detection via cosine similarity of spectra
    Hn = F.normalize(H, dim=1)
    sim = Hn @ Hn.t()
    sim.fill_diagonal_(0.0)
    dup_pairs = (sim > 0.98).nonzero()
    return dict(peak_hz=peak_hz, dead=dead, n_dup=len(dup_pairs)//2, norms=norms)

# report = inspect_first_layer(model.conv1, fs=50.0)
# print(report["peak_hz"].sort().values)   # where each filter is tuned
# print("dead:", report["dead"].tolist(), "dup pairs:", report["n_dup"])

The inspect_first_layer function is deliberately blunt: a healthy sensor front end should show peak frequencies spread across the physically meaningful band, a norm distribution with no cluster pinned at zero, and few near-duplicate spectra. If peak_hz collapses onto one value, or half the entries land in dead, the diagnosis is architectural, not cosmetic.

Dead, saturated, and duplicate filters: the common pathologies

Dead filters are units whose weights and gradients have collapsed toward zero, usually a ReLU that got pushed permanently negative early in training. They cost parameters and compute while contributing nothing. You catch them two ways: a near-zero weight norm (as above), and a near-zero activation rate measured over a validation batch (the fraction of windows for which the channel ever fires). A channel that activates on under one percent of windows is effectively dead.

Saturated filters are the opposite: they fire on almost everything, so they carry no discriminative information. On sensor data this frequently means the filter locked onto a DC offset or a slow drift that survived because the input was not standardized (a direct consequence of skipping the normalization discipline of Section 13.5).

Duplicate filters waste capacity: two channels that learned the same passband double the cost of that feature and halve the diversity of the bank. A light dose of weight decay, or an explicit orthogonality penalty, usually restores spread.

The reason to hunt these before trusting accuracy is that all three can coexist with a good validation number. A model with 40 percent dead filters may still classify walking versus running because the task is easy; the dead capacity only bites when the deployment distribution shifts and you needed those unused features. This is the same story you will formalize under distribution shift in Chapter 66.

Which inputs excite a filter: activation maximization and saliency

What. Reading a kernel's spectrum tells you the frequency it prefers; it does not tell you which real signal shapes drive it hardest, especially for filters in deeper layers where the FIR interpretation breaks down. Two complementary tools fill the gap. Real-example maximization ranks validation windows by how strongly they activate a chosen channel and shows you the top few, giving an honest, in-distribution picture of what the filter fires on. Gradient saliency computes \(\partial a_c / \partial x\), the sensitivity of a unit's activation to each input sample, highlighting which timesteps and axes matter.

Why. For a wearable model you want to confirm that a filter tagged "step detector" actually fires on heel-strike impulses and not on the moment the data loader zero-pads a short window. Real-example maximization is the most trustworthy check because it never leaves the data manifold, unlike synthetic activation maximization which can drift into adversarial nonsense on time series.

When. Use real-example maximization first for any per-channel sanity check; reach for saliency and integrated gradients when you need per-sample attribution for a specific prediction, which is the interpretability toolkit developed in full in Chapter 67. A useful ranking that combines both signals is filter importance by mean gradient-times-activation over a validation set:

which approximates how much each channel contributes to reducing the loss and cheaply orders filters from load-bearing to ignorable.

Watch training, not just the final model

What. Many filter pathologies are born in the first few hundred steps, so the highest-leverage habit is to log filter health during training, not to autopsy it afterward. Cheap, decisive signals: the per-layer gradient norm (a layer whose gradients vanish is not learning), the fraction of dead ReLU channels per epoch, and the drift of first-layer peak frequencies over time (they should migrate toward the signal band and then stabilize).

Why. A vanishing first-layer gradient with a still-falling loss means the deeper layers are memorizing while the front end stays random: the network is not building the reusable low-level features you wanted, and it will transfer poorly to the self-supervised and foundation-model settings of Chapter 17. Catching it at epoch two costs a rerun; catching it at deployment costs a recall.

How. A backward hook that records each layer's gradient norm, plus the dead-channel and peak-frequency reports from the earlier snippet logged once per epoch, gives you a three-line dashboard that turns silent representation failures into visible ones. When you see peak frequencies that never leave DC, revisit input normalization; when you see gradient norms that collapse, revisit initialization, learning rate, or the residual paths of Section 13.6.

What's Next

In Chapter 14, we leave the purely convolutional view and give the network explicit memory. Recurrent cells and temporal convolutional networks carry state across a stream, which raises new inspection questions: instead of asking what a single filter detects, we will ask what a hidden state remembers, how far back its influence reaches, and how to keep that memory honest under streaming, stateful inference.