Spread the same nine weights further apart and the receptive field grows without any downsampling and without any extra parameters.
Overview
The problem it solves
A network has two ways to grow its receptive field: stack more layers. This Is slow because growth is linear, or downsample, which is fast but throws away detail.
For classification, throwing away detail is fine. The answer is one label. For segmentation it isn't. The output has to be the same size as the input, and detail destroyed by pooling has to be rebuilt by a thing.
Dilated convolution is the third way. It grows the receptive field geometrically, adds no params, and doesn't reduce detail at all.
Dilated Convolutions
This module needs JavaScript: the
images are computed in the page rather than downloaded.
Worth knowing
Dilation inserts gaps between the kernel's taps. A 3×3 at dilation 2 spans 5×5 while still holding nine weights.
The parameter count does not change. The receptive field does.
It buys reach without pooling, so the output stays at full resolution — which is what segmentation needs.
Stacking the same rate repeatedly leaves gaps that nothing samples. Vary the rate instead.
Dilated Convolutions
How to see further without downsampling, and the gridding artefact that comes with it.
What dilation does
Take a 3×3 kernel. Instead of reading nine adjacent pixels, read nine pixels spaced d apart, leaving gaps between them. The weights are unchanged; only where they're sampled from moves.
The effective size of a k×k kernel at dilation d is:
effective = k + (k - 1) * (d - 1)
So a 3×3 at dilation 1 spans 3, at dilation 2 spans 5, at dilation 4 spans 9. Drag the dilation control and the readout confirms it: nine weights, spanning what you asked for.
That is the whole trick, and its appeal is that all about the layer's cost is unchanged. Same weights, same number of times, wider view.
Stacking
Drag the layers control up. Two dilated layers reach further than two plain ones, and the growth compounds, because each layer's reach is measured in the already-expanded units of the layer beneath it.
The standard setup uses a rising sequence. Dilation 1, then 2, then 4, then 8 — which gives exponential receptive-field growth at constant detail. A stack of four such layers sees a 33×33 region using 36 weights per channel pair and no pooling at all.
The gridding problem
There's a defect, and it follows right from the gaps.
Stack a few layers all at dilation 2, and some input spots are never sampled by any of them. The kernel taps land on even offsets at each level, so odd spots in between are simply not read. The output develops a checkerboard-like inconsistency, and the network is blind to fine detail that happens to fall in the gaps.
The fix is to vary the rate so that the gaps of one layer are covered by another. Rates like 1, 2, 5 or 1, 2, 3 are chosen so their sampling patterns interlock, and the *hybrid dilated convolution* literature is about picking such sequences. The simple version of the rule: don't repeat the same dilation rate a few times in a row.
Where it is used
DeepLab made dilated convolution central to semantic segmentation, and its ASPP module runs a few rates in parallel and concatenates them, giving the network a few scales at once from one feature map.
WaveNet used dilation in one dim over audio. Here The receptive field has to span thousands of samples and downsampling would destroy the waveform.
Dense guess often — depth estimation, optical flow, any of it whose output is an image. Uses it for the same reason segmentation does.
The reach a dilated stack buys
The whole point is receptive field without downsampling, and the math shows how fast it grows. A dilated k×k kernel spans k + (k-1)(d-1), and stacked layers build up (k-1)·d at each step. Take four 3×3 layers at the standard rising rates 1, 2, 4, 8.
layer
dilation
reach added
running receptive field
1
1
2
3
2
2
4
7
3
4
8
15
4
8
16
31
Four layers reach a 31-pixel window — in effect 33×33 counting the kernel — using 4 × 9 = 36 weights per channel pair and *no pooling at all*. A stride-1 stack of plain 3×3 layers would need fifteen layers to see as far, because its reach grows by 2 per layer instead of doubling. That exponential growth at constant detail is why DeepLab put dilation at the centre of segmentation. The catch is in those same gaps: repeat one rate and some input spots are never sampled by any layer, making the gridding artefact, which is why the rates are varied (1, 2, 5) so their sampling patterns interlock.
Where dilation earns its place is dense guess — segmentation, depth, optical flow — any of it whose output must be the same size as the input, so detail can't be thrown away by pooling. DeepLab's ASPP module runs a few rates in parallel and concatenates them, giving the network a few scales from one feature map, and WaveNet used the one-dimensional version over audio, where the receptive field has to span thousands of samples. The one cost that isn't free is memory: a network that never downsamples holds full-detail activations at each layer, which is often the binding constraint on a segmentation model, so the params are free but the memory isn't.
The gridding fix is worth stating as a rule of its own: never repeat the same dilation a few times in a row. Rates chosen so their sampling patterns interlock — 1, 2, 5, or 1, 2, 3. Cover the spots any single rate would skip, and the hybrid-dilated-convolution literature is largely about picking such sequences so that each input spot is read by some layer in the stack.
Where it goes wrong with Dilated Convolutions
Repeating one rate. Gridding artefacts, and detail that falls in the gaps is never seen.
Using it where pooling would do. For classification, downsampling is cheaper and reduces work. Dilation keeps the feature map large, and large feature maps cost memory at each layer.
given it's free. The params are free. The memory isn't. A network that never downsamples holds full-detail activations throughout, which is often the binding constraint on segmentation models.
Questions people ask about Dilated Convolutions
What is a dilated convolution? A convolution whose kernel taps are spaced apart by a dilation rate, with gaps in between. A 3x3 kernel at rate 2 covers a 5x5 area using still only nine weights.
Why use dilation instead of a bigger kernel? It enlarges the receptive field without adding parameters or cost. A bigger kernel grows quadratically in both.
What is the gridding problem? Stacking layers with the same dilation rate samples the input on a sparse checkerboard and misses pixels in between. Mixing rates, such as 1, 2 and 5, fills the gaps.
Where are dilated convolutions used? In semantic segmentation such as DeepLab, in WaveNet for audio and in other models that need wide context at full resolution.
How does dilation compare with pooling or striding? Pooling and striding shrink the feature map to reach further, losing resolution. Dilation keeps the resolution, which matters for per-pixel outputs.
What is the effective kernel size for a given dilation? It is k + (k - 1)(d - 1) for kernel size k and dilation d. A 3x3 kernel with d = 4 spans 9x9.
Skipping pixels to see further for the same price
A dilated convolution reads the same number of weights from a wider spread of spots. That one change buys receptive field growth that is exponential rather than linear -- and brings a gridding artefact that the fix for it's named after.
example_01.pyNumPy
import numpy as np
print("A 3x3 KERNEL reads 9 positions. WHERE those positions are is set")
print("by the dilation rate:")
for d in (1, 2, 3):
span = 2 * d + 1
grid = [["." for _ in range(span)] for _ in range(span)]
for i in range(3):
for j in range(3):
grid[i * d][j * d] = "#"
print(" dilation %d -- 9 weights spread over %dx%d:" % (d, span, span))
for row in grid:
print(" " + " ".join(row))
print(" the weight count never changes. the SPAN does.")
print()
print("RECEPTIVE FIELD -- stack layers and track it. 3x3, stride 1:")
print("%-10s %14s %16s %18s"
% ("layer", "dilation", "RF (plain 3x3)", "RF (doubling)"))
rf_plain, rf_dil, d = 1, 1, 1
for layer in range(1, 7):
rf_plain += 2; rf_dil += 2 * d
print("%-10d %14d %16d %18d" % (layer, d, rf_plain, rf_dil))
d *= 2
print(" six plain layers reach %d; six doubling-dilation reach %d."
% (rf_plain, rf_dil))
print(" same %d weights per layer. plain grows LINEARLY, dilated" % 9)
print(" grows EXPONENTIALLY.")
print()
print("%-30s %14s %14s %16s" % ("method", "RF", "params", "output size"))
for r in (("one 3x3", 3, 9, "unchanged"), ("one 9x9", 9, 81, "unchanged"),
("4 stacked 3x3", 9, 36, "unchanged"),
("3x3, dilation 4", 9, 9, "unchanged"),
("3x3 after 2 poolings", 12, 9, "quartered")):
print("%-30s %14d %14d %16s" % r)
print(" pooling gets there but throws resolution away. dilation was")
print(" invented for the constraint: big context, full resolution.")
Output
Applying a dilated convolution to a signal with one spike shows how the response spreads, and what happens when the same dilation is repeated.
example_02.pyNumPy
import numpy as np
N = 25
sig = np.zeros(N); sig[12] = 9.0
k = np.ones(3) / 3.0
def dconv(x, k, d):
out = np.zeros_like(x)
for i in range(len(x)):
acc = 0.0
for t, w in enumerate(k):
j = i + (t - len(k) // 2) * d
if 0 <= j < len(x):
acc += w * x[j]
out[i] = acc
return out
print(" input: " + "".join("#" if v > 0 else "." for v in sig))
for d in (1, 2, 4):
o = dconv(sig, k, d)
print(" dilation %d: " % d
+ "".join("#" if v > 0 else "." for v in o)
+ " touches %d positions" % int((o > 0).sum()))
print(" at dilation 4 the kernel never looked at positions 9, 10, 11.")
print()
print("THAT IS THE GRIDDING ARTEFACT. two layers both at dilation 2")
print("only ever touch even offsets:")
two_same = dconv(dconv(sig, k, 2), k, 2)
print(" d=2,d=2: " + "".join("#" if v > 1e-9 else "." for v in two_same))
covered = set(np.where(two_same > 1e-9)[0])
gaps = [i for i in range(min(covered), max(covered) + 1) if i not in covered]
print(" reaches %d..%d but MISSES %s" % (min(covered), max(covered), str(gaps)))
print(" every missed index is odd -- THREE QUARTERS of the input")
print(" inside the receptive field is never read at all in 2D.")
print()
print(" now make the rates COPRIME -- 1, then 2, then 3:")
mixed = dconv(dconv(dconv(sig, k, 1), k, 2), k, 3)
cov2 = set(np.where(mixed > 1e-9)[0])
gaps2 = [i for i in range(min(cov2), max(cov2) + 1) if i not in cov2]
print(" d=1,2,3: " + "".join("#" if v > 1e-9 else "." for v in mixed))
print(" reaches %d..%d and misses %s"
% (min(cov2), max(cov2), str(gaps2) if gaps2 else "nothing"))
print(" full coverage, same cost. choose rates with no common factor.")
Output
Real architectures use dilation wherever downsampling is unacceptable, such as per-pixel labelling or audio waveform generation.
example_03.pyNumPy
print("WHERE YOU MEET IT:")
print("%-26s %s" % ("DeepLab (ASPP)", "parallel branches at 6, 12, 18"))
print("%-26s %s" % ("WaveNet", "1,2,4,...,512 over raw audio"))
print("%-26s %s" % ("dilated residual nets", "replaces the last poolings"))
print(" the common thread is a task where downsampling is unacceptable:")
print(" per-pixel labels, or a waveform where every sample is an output.")
print(" for plain classification, pooling is cheaper and dilation buys")
print(" little -- which is why you will not find it in a plain ResNet")
print(" classifier, and will find it in almost every segmentation")
print(" network built since 2016.")
Output
Check yourself
0 of 3
Answer without scrolling back up.
How wide does a 3x3 kernel at dilation 3 reach?
k + (k-1)(d-1) = 3 + 2*2 = 7. Nine weights spanning seven positions - the parameter count is unchanged.
What causes gridding artefacts?
The taps land on the same offsets at every level, leaving positions in between unread. Varying the rate so the sampling patterns interlock is the fix.
Why is dilation preferred over pooling in segmentation?
Detail destroyed by pooling has to be reconstructed by something. Dilation buys reach while the feature map stays full size - at the cost of memory.
Cheat sheet
Dilated Convolutions
Expand a kernel's field of view without adding parameters or pooling, and spot the gridding artefact that appears when rates are wrong.
Ashish Jangra builds and maintains VizLearn. Every module here is written and the visualisation behind it hand-built, so the numbers in a readout come from the same code that draws the picture. Corrections are genuinely welcome and get priority over everything else — if a page states something wrong, or an animation misrepresents what the algorithm does, get in touch.