How do you compute a dilated temporal convolution stack's receptive field in time steps?

## The counting rule One convolution of width `k` and dilation `d` touches input offsets `{0, d, ..., (k-1)d}`, so it reaches `(k-1)*d` steps beyond its anchor. Stack layers and the reaches add: ``` rf = 1 + sum_over_layers( (k - 1) * d ) ``` (assuming stride 1 throughout - a stride multiplies the reach of everything above it, which is why temporal stacks usually keep stride 1 and buy their coverage with dilation instead). Work the canonical case: `k = 3`, dilations `1, 2, 4, 8, 16`. ``` rf = 1 + 2*(1 + 2 + 4 + 8 + 16) = 1 + 2*31 = 63 ``` Sixty-three input steps feed one output step. Repeat the same cycle a second time - dilations `1,2,4,8,16,1,2,4,8,16` - and you get `1 + 2*62 = 125`. ## Why doubling With dilation fixed at 1, `L` layers of width 3 give `rf = 1 + 2L`: coverage is linear in depth, so a 1000-step horizon needs 500 layers. With dilation doubling, the sum of a geometric series means `L` layers give roughly `2^L` coverage - exponential in depth, linear in parameters. That trade is the reason dilated stacks displaced deep undilated ones for long-range temporal modelling. A reasonable worry is whether doubling leaves holes: a layer at dilation 16 skips 15 of every 16 inputs. It does not leave holes, because the layers below it at dilations 1, 2, 4 and 8 have already blended every intermediate position into the values it reads. The gap-free property depends on that full cycle being present. Skipping levels - going 1, 4, 16 - genuinely does leave positions that contribute to some outputs and not others, which shows up as a periodic patterning of the output sometimes called gridding. ## Blocks, not layers Most practical temporal stacks use a residual block with **two** dilated convolutions at each dilation level rather than one. Each block then contributes `2*(k-1)*d`, so the same cycle `1,2,4,8,16` at width 3 covers `1 + 4*31 = 125` steps rather than 63. Count what your architecture actually contains; being off by a factor of two on the receptive field is the difference between covering the dependency and missing half of it. ## Convert to physical units Steps are not the unit anyone cares about. - 50 Hz wrist sensor: 63 steps is 1.26 s - comfortably more than a single arm swing, so a one-cycle stack is plausible for activity recognition on 2.56 s windows. - 16 kHz raw audio: 63 samples is 3.9 ms, which is nothing. A causal audio stack in the WaveNet style uses width 2 with dilations doubling `1, 2, 4, ... 512`; that gives `1 + 1*(1+2+...+512) = 1024` samples, or 64 ms, per cycle, and several cycles are stacked to reach a useful span. The same architecture drawing therefore means completely different things at different sampling rates. Always report the receptive field in seconds alongside steps. ## Sizing it The design procedure is: 1. Name the longest dependency the task requires - one gait cycle, one respiratory cycle, the lag at which a control action shows an effect. 2. Express it in time steps at your sampling rate. 3. Add dilation cycles until `rf` comfortably exceeds it. Comfortably, because a dependency sitting at the very edge of the field is seen through one tap of one kernel. Undershooting is a hard ceiling: information that never enters the field cannot be used, no matter how much data you collect or how long you train. Overshooting is a soft cost - more parameters and compute, and at inference in a streaming setting a longer history buffer must be retained before the model can emit anything at all, which is a real latency and memory constraint on device. If the field is short and you cannot add depth, the other levers are a wider kernel (linear in parameters), a larger maximum dilation, or downsampling the input so each retained step represents more time - which trades temporal resolution for span and is usually the right call when the signal is oversampled relative to the phenomenon.