Steerable Networks
Steerable networks build rotation handling into the filters themselves. Each filter mixes fixed basis patterns, so a rotated input just remixes the coefficients instead of breaking the response.
Why Does This Exist?
Discrete group CNNs click into four orientations and improvise between them. For applications where every angle occurs — rotated text, aerial tracking, molecular imaging — those gaps are where the errors live. Finer sampling (eight, sixteen orientations) closes the gaps by brute force and multiplies memory each time.
Steerable networks solve rotation continuously. Filters are built from basis functions with known rotation behavior (circular harmonics), so steering a filter to any angle is an exact change of coefficients, not an interpolation. The discrete sibling is group equivariant CNNs; the shared principle is geometric deep learning.
The one idea you need first. A steerable basis is a small filter set closed under rotation: rotating any basis filter yields a linear mix of the set, never something outside it. The classic order-one basis on the circle is and . A filter steered to direction is exactly , obtained by setting and — no resampling, no approximation.
Think of It Like This
Mixing paint from three primaries
A paint shop does not stock every shade. It stocks primaries and a mixing formula: any color on the wall chart is an exact ratio of the same few cans. Ask for an in-between shade and the mixer computes new ratios rather than guessing from the nearest stocked can.
Steerable filters are mixed, not stocked. The basis patterns are the primaries; a filter aimed at degrees is the ratio of the cosine and sine cans. Any angle gets its exact mix on demand, which is why there are no gaps between detents — there are no detents at all.
The analogy stops at the palette: real steerable bases need higher harmonics for complex patterns, and each harmonic costs feature channels the way extra primaries cost shelf space.
How It Actually Works
Each layer stores features as geometric types: scalars (unchanged by rotation), vectors (rotate as arrows), and higher-order tensors. Convolution kernels are expanded in a basis matched to the input and output types, with learnable coefficients per basis element. Because the basis transforms exactly, the whole layer commutes with continuous rotation.
Nonlinearities must respect types: a pointwise ReLU applied to vector components independently breaks equivariance, so steerable networks use norm-based gating (scale the vector by a function of its length, which preserves direction). Pooling over orientation at the end yields invariance when the task needs it.
Worked example
Steer the order-one filter to degrees. Coefficients: , . The steered filter is . Evaluate where it peaks by testing :
Test (ninety degrees away): , , so . Peak exactly at the steering angle, zero exactly orthogonal — the continuous guarantee in two lines of arithmetic.
Code
The point of this snippet is the steering law: two coefficients reproduce the filter at any angle, and the numbers confirm the peak and the null.
import math
def steered_response(theta_deg: float, phi_deg: float) -> float: a = math.cos(math.radians(phi_deg)) # basis weights for the target angle b = math.sin(math.radians(phi_deg)) t = math.radians(theta_deg) return a * math.cos(t) + b * math.sin(t)
print(round(steered_response(30, 30), 6)) # -> 1.0print(round(steered_response(120, 30), 6)) # -> 0.0Watch Out For
Bandlimited bases blur sharp patterns
An order-one basis spans only smooth sinusoids. A sharp corner or thin edge needs higher harmonics, and each added harmonic order multiplies the feature types and the compute. Teams that copy a steerable layer with the default basis onto edge-heavy data get mysteriously soft responses.
Match the maximum harmonic order to the pattern sharpness, and budget channels per order before going deep. Smooth blobs steer cheaply; corners cost.
Ordinary ReLU silently breaks equivariance
Applying ReLU separately to each component of a vector feature treats the coordinate frame as meaningful, which rotation immediately invalidates. The network still trains — it just quietly loses the equivariance guarantee the architecture was chosen for, and diagonal-angle accuracy sags exactly like a discrete model.
Use norm nonlinearities (scale by a learned function of the vector length) or gated activations on scalar side-channels. Test with a continuous rotation sweep after any custom activation change.
The Quick Version
- Steerable networks expand filters in rotation-closed bases, so any angle is an exact coefficient remix.
- The worked fixture steers to degrees with weights , peaking at on target and orthogonal.
- Unlike discrete group CNNs, there are no gaps between sampled angles.
- Sharp patterns need higher harmonics, each costing channels, so match basis order to the data.
- Nonlinearities must preserve feature type; plain per-component ReLU voids the guarantee.