One network, two clocks. A Slow pathway samples a few frames but thinks deeply about what is in them; a Fast pathway samples many frames but stays lightweight, watching how things move. Lateral connections fuse them — and it tops video benchmarks at a fraction of the cost.
You're building a model that watches short video clips and names the action: "clapping," "diving," "pouring," "shaking hands." A clip is 64 frames long. The obvious move is to treat it like a stack of images: feed all 64 frames into a 3D convolutional network and let it figure things out. This is exactly what the strong video models before 2019 did — I3D, C3D, the (2+1)D networks — they processed a dense stack of frames with a uniform, heavy 3D CNN.
It works. But look at where the compute goes. To recognize "clapping," the network needs two very different things. First, it needs to know what is in the frame — hands, a person, a room. That is spatial semantics, and it barely changes from one frame to the next. Two frames 1/30th of a second apart are almost identical pictures. Second, it needs to know how things are moving — the hands coming together and apart. That is motion, and it lives entirely in the differences between nearby frames.
Here is the waste. The dense 3D CNN spends the same expensive, high-capacity machinery on every single frame to re-extract the spatial semantics that hardly moved — 30 nearly-identical "what is in the room?" computations per second. Meanwhile the thing that actually changes fast, the motion, is processed by that same slow, heavy machinery, so you cannot afford to sample frames densely without the cost exploding.
A toy clip of a hand clapping. The spatial content (warm) — the person, the room — is almost constant frame to frame. The motion (teal) — the inter-frame change — spikes exactly when the hands move. Drag the slider to scrub through time and watch the two signals diverge.
Feichtenhofer et al. asked: what if we stopped using one clock for the whole video? What if two sub-networks ran in parallel, each tuned to one of those two needs?
The two pathways are fused by lateral connections that inject the Fast pathway's motion features into the Slow pathway. The name is a direct echo of the design: a Slow clock and a Fast clock, fused.
The payoff is real. With this factorization, the Fast pathway can sample frames 8× denser than the Slow pathway while costing only a small fraction of the total compute, because it is so thin. The full SlowFast network set state-of-the-art accuracy on the Kinetics action-classification benchmark and on the AVA action-detection benchmark — at lower computational cost than the dense models it beat.
The rest of this lesson builds the architecture piece by piece: the two pathways, the temporal stride that defines them, the channel-capacity asymmetry, the lateral fusion that ties them together, the headline results, and the ablations that prove each design choice earns its place.
Let's name the two pathways precisely, because the whole paper is an exercise in making them asymmetric on purpose. A single raw video clip enters the network. Both pathways read from that same clip — but they read it differently.
Suppose the raw clip is a long stretch of video. We pick a refresh rate τ for the Slow pathway: it samples one frame every τ frames. So the Slow pathway sees a sparse set of frames — the paper's instances use τ = 16, meaning the Slow pathway keeps roughly 2 frames per second from a 30 fps source.
The Fast pathway samples the same clip α times more densely. Its temporal stride is τ/α, so it keeps α times as many frames. The paper uses α = 8, so for every 1 frame the Slow pathway keeps, the Fast pathway keeps 8.
The second asymmetry is capacity. Let the Fast pathway use a fraction β of the channels (feature maps) that the Slow pathway uses, at every layer. The paper uses β = 1/8. So at a layer where the Slow pathway has, say, 256 channels, the Fast pathway has only 32. This is what keeps the Fast pathway cheap despite its dense temporal sampling.
| Property | Slow pathway | Fast pathway |
|---|---|---|
| Frame rate | Low — stride τ (sparse) | High — stride τ/α (α× denser) |
| Frames seen (T) | T (e.g. 4 or 8) | αT (e.g. 32 or 64) |
| Channel width | Full C (e.g. 64→2048) | βC (e.g. 8→256, with β=1/8) |
| Job | Spatial semantics — what | Motion / fine temporal change — how |
| Share of total FLOPs | ~80% | ~20% (despite 8× the frames) |
Concretely, take a 64-frame raw clip at τ = 16, α = 8. The Slow pathway keeps frames at indices 0, 16, 32, 48 → T = 4 frames. The Fast pathway keeps frames at stride τ/α = 16/8 = 2 → indices 0, 2, 4, …, 62 → αT = 32 frames. The Fast pathway processes 8× as many frames as the Slow pathway — exactly α.
Now the capacity. Suppose a given residual stage outputs C = 256 channels in the Slow pathway. The Fast pathway, at β = 1/8, outputs βC = 32 channels there. A 3D conv layer's cost scales with (channels in) × (channels out) × (frames) × (spatial size). The Fast pathway's channel cost is roughly β2 = 1/64 of the Slow pathway's per-frame, and it has α = 8× the frames, so its total cost ratio is about α · β2 = 8/64 = 1/8 of the Slow pathway. That is why dense temporal sampling becomes affordable.
The raw clip is the row of ticks at top. The Slow pathway (warm) samples every τ frames; the Fast pathway (teal) samples every τ/α frames. Move the sliders for τ and α and watch how many frames each pathway keeps — and how the Fast pathway always keeps exactly α× as many.
The single most important operation in SlowFast is also the simplest: temporal subsampling by stride. Before any convolution happens, the raw clip is reduced to two sampled clips — a sparse one for Slow and a dense one for Fast. Get this wrong and everything downstream is wrong. So let's trace it with real shapes.
A raw clip is a 4D tensor (ignoring the batch dimension): shape [Traw, H, W, 3] — Traw frames, each H×W pixels, 3 color channels. Sampling with temporal stride s means: keep frames at indices 0, s, 2s, 3s, …. The result has ⌈Traw/s⌉ frames.
Take Traw = 64 raw frames, τ = 16, α = 8. The Slow input is [4, 224, 224, 3]; the Fast input is [32, 224, 224, 3]. Both pathways look at the same span of real time — the same ~2 seconds of video — but the Fast one samples it 8× more finely.
Motion is the change between consecutive sampled frames. If you sample sparsely (large stride), a fast movement can happen entirely between two of your samples — you literally never see it. This is temporal aliasing, the time-domain cousin of the jagged edges you get when you under-sample an image. A hand that claps and re-opens in 1/8th of a second is invisible to a pathway that only samples 2 frames per second; it is clearly resolved by one that samples 16 per second.
So the Fast pathway's whole reason to exist is its high temporal sampling rate. Strip that away and there is nothing left for it to specialize in. This is also why the paper is careful to keep the Fast pathway at high temporal resolution all the way through the network — it deliberately uses no temporal downsampling (no temporal stride > 1) in the Fast pathway's pooling, so the dense time signal survives to the very end. The Slow pathway, by contrast, can afford to keep time small because it isn't responsible for fine motion.
A dot oscillates fast (the true motion, faint line). The Slow sampler (warm dots) takes a sample every τ ticks; the Fast sampler (teal dots) takes α× as many. Increase the motion frequency and watch the Slow samples completely miss the oscillation — that's temporal aliasing — while the Fast samples still trace it.
python # Temporal sampling: the FIRST thing SlowFast does to a raw clip. import torch raw = torch.randn(1, 64, 3, 224, 224) # [B, T_raw, C, H, W] tau, alpha = 16, 8 slow_stride = tau # 16 fast_stride = tau // alpha # 2 # Subsample along the time axis (dim=1) by stride. slow_in = raw[:, ::slow_stride] # indices 0,16,32,48 -> 4 frames fast_in = raw[:, ::fast_stride] # indices 0,2,...,62 -> 32 frames print(slow_in.shape) # [1, 4, 3, 224, 224] print(fast_in.shape) # [1, 32, 3, 224, 224] -> alpha x more frames assert fast_in.shape[1] == alpha * slow_in.shape[1]
We've established the temporal asymmetry: Fast samples α× more frames. Now comes the second, equally deliberate asymmetry that makes the whole thing affordable: the capacity ratio β. The Fast pathway uses only a fraction β of the channels the Slow pathway uses, at every single layer. The paper's default is β = 1/8.
"Channels" here means feature-map count — the depth of the tensor that a 3D conv layer produces. A Slow stage that outputs C channels has a Fast counterpart that outputs βC channels. So if the Slow pathway's stages output 64, 256, 512, 1024, 2048 channels (a ResNet-50 backbone), the Fast pathway's stages output 8, 32, 64, 128, 256 channels — exactly 1/8 of each.
A natural worry: won't a pathway with only 1/8 the channels be too weak? The answer is no — because the Fast pathway has a narrow job. It does not need to represent thousands of object categories with rich spatial detail. It needs to represent motion: temporal patterns of change. Motion is lower-dimensional than appearance. A few channels, sampled densely in time, capture "things are moving left-to-right" or "the hands are oscillating" perfectly well. The high-capacity spatial understanding is delegated to the Slow pathway, and injected into the Fast pathway only indirectly through the data.
This is the crux of the FLOP argument. The compute of a 3D conv layer is proportional to Cin · Cout · T · H · W · (kernel size). For the Fast pathway, Cin and Cout are each scaled by β, so the channel term shrinks by β2. Its T is α× larger. Net layer-cost ratio vs. the Slow pathway:
So even though the Fast pathway processes 8× the frames, it costs only about 1/8 as much as the Slow pathway. The Fast pathway ends up being roughly 20% of the network's total FLOPs, the Slow pathway about 80%. You buy dense motion sampling for a 20% surcharge.
For a single residual stage, the bars show the relative compute. Slow (warm) = full channels, few frames. Fast (teal) = few channels (scaled by β²), many frames (scaled by α). Drag β and α and watch the Fast cost — it stays small even as frames climb. The total cost split is printed live.
Take one conv stage. Slow: Cin = Cout = 256, T = 4 frames. Fast: Cin = Cout = 256·(1/8) = 32, T = 32 frames. The channel product is 256·256 = 65,536 for Slow vs. 32·32 = 1,024 for Fast — a 64× reduction (that's the β2). The frame count is 4 vs. 32 — an 8× increase (that's α). Net: Fast/Slow = (1,024/65,536) · (32/4) = (1/64) · 8 = 1/8. The Fast pathway costs one-eighth of the Slow pathway at this stage. Exactly as the formula predicted.
Both pathways are 3D ResNets — the same backbone family (e.g. ResNet-50), just instantiated with different temporal and channel settings. Let's look closely at what makes the Fast pathway special beyond "thin and dense," because the paper makes two precise design choices that are easy to miss.
The Fast pathway uses no temporal downsampling. Standard image-CNN intuition says you progressively shrink resolution as you go deeper. The Fast pathway breaks that rule for the time axis: it keeps all αT frames through the entire network, performing no temporal striding in its convolutions or pooling until the very end. This preserves fine motion information all the way to the classifier. If you downsampled time, you'd throw away exactly the signal the Fast pathway exists to capture.
The Slow pathway, in its early stages, uses temporal kernels of size 1 (it convolves only in space). The intuition: with so few, far-apart frames, "motion" between Slow frames is meaningless, so don't bother modeling time early — just do spatial 2D-style convs and reserve temporal mixing for later. The Fast pathway does the opposite: it uses non-degenerate temporal kernels (size > 1) throughout, because its densely-sampled frames carry real, learnable motion that's worth convolving over from the very first layer.
Let's trace shapes through the Fast pathway for a ResNet-50-style backbone, αT = 32 input frames, 224×224, β = 1/8. Recall the Slow pathway would start at 64 channels; the Fast pathway starts at 64·β = 8 channels.
| Stage | Fast tensor [T, H, W, C] | Note |
|---|---|---|
| Input | [32, 224, 224, 3] | αT = 32 frames, dense |
| conv1 / pool | [32, 56, 56, 8] | spatial down, time stays 32, C = 64β = 8 |
| res2 | [32, 56, 56, 32] | C = 256β = 32 |
| res3 | [32, 28, 28, 64] | spatial down, time stays 32 |
| res4 | [32, 14, 14, 128] | C = 1024β = 128 |
| res5 | [32, 7, 7, 256] | C = 2048β = 256, time STILL 32 |
Notice the second column's first number: it is 32 from top to bottom. Spatial dimensions shrink (224→7), channels grow (3→256), but time never shrinks. That invariant is the Fast pathway's signature.
As you advance through the network stages, watch the three quantities. In the Fast pathway (teal) the temporal length T holds flat while channels grow modestly. In the Slow pathway (warm) channels grow large while T stays small from the start. Click "Next Stage" to walk through res2→res5.
python import torch import torch.nn as nn class FastStem(nn.Module): """Fast pathway stem: thin (beta) channels, NON-degenerate time kernel, NO temporal downsampling — keep all alpha*T frames.""" def __init__(self, base_c=64, beta=8): super().__init__() c = base_c // beta # 64 // 8 = 8 channels # kernel (t,h,w) = (5,7,7): temporal extent 5 -> models motion. # temporal stride = 1 -> time is preserved. self.conv = nn.Conv3d(3, c, kernel_size=(5,7,7), stride=(1,2,2), padding=(2,3,3)) # spatial pool only — temporal stride stays 1 self.pool = nn.MaxPool3d(kernel_size=(1,3,3), stride=(1,2,2), padding=(0,1,1)) def forward(self, x): # x: [B, 3, 32, 224, 224] x = self.conv(x) # [B, 8, 32, 112, 112] time UNCHANGED x = self.pool(x) # [B, 8, 32, 56, 56] time UNCHANGED return x
So far the two pathways are independent — Slow does its thing, Fast does its thing. The crucial ingredient that makes them a single network is the lateral connection: at several stages, the Fast pathway's features are transformed and added into the Slow pathway's features. This lets the spatial-semantics pathway also benefit from the motion the Fast pathway computed.
The direction matters and is a deliberate choice: fusion goes Fast → Slow (one way). The paper found this is what helps; they also tested Slow→Fast and bidirectional, and one-way Fast→Slow was the cleanest win. So the Slow pathway is enriched by motion; the Fast pathway is left thin and undistracted.
Here is the engineering wrinkle. You cannot just add the two pathways' tensors — their shapes don't match. At a given stage:
Two mismatches: the time axis (αT vs T — Fast has α× more frames) and the channel axis (βC vs C — Fast has β× fewer). The lateral connection must reconcile both before the add. The paper's main fusion ("time-strided convolution") does it like this:
After the time-strided conv, the lateral feature has T frames (matching Slow) and 2βC channels. In the paper's default these are concatenated onto the Slow features rather than summed, so the Slow stage that follows sees C + 2βC channels — its own semantics plus a compact motion summary. (The paper studied summation, concatenation, and a time-to-channel reshape; the strided-conv variant works best.)
Worked numbers: α = 8, T = 4, βC = 32. Fast lateral input: [32 frames, H, W, 32 ch]. Time-strided conv with stride 8 in time → 32/8 = 4 frames. Output channels 2·32 = 64. So [4, H, W, 64], which concatenates onto the Slow stage's [4, H, W, 256] → [4, H, W, 320]. Time now matches; the Slow pathway carries a 64-channel motion digest alongside its 256 appearance channels.
The Fast feature (teal, many thin frames) is squeezed in time by stride α and widened in channels, then fused into the Slow feature (warm, few wide frames). Step through the three stages and watch the αT frames collapse to T while the βC channels grow — until both sides are addable.
python import torch import torch.nn as nn class LateralFastToSlow(nn.Module): """Time-strided conv fusion: reduce Fast's alpha*T frames to T, widen channels, then concat into the Slow pathway.""" def __init__(self, fast_c, alpha=8): super().__init__() # temporal kernel 5, temporal STRIDE = alpha -> alpha*T frames become T self.conv = nn.Conv3d(fast_c, fast_c * 2, kernel_size=(5,1,1), stride=(alpha,1,1), padding=(2,0,0)) def forward(self, slow, fast): # slow: [B, C, T, H, W] # fast: [B, beta*C, alpha*T, H, W] f = self.conv(fast) # [B, 2*beta*C, T, H, W] time matched! return torch.cat([slow, f], dim=1) # concat on channel axis # Example shapes: alpha=8, T=4, beta*C=32, C=256 slow = torch.randn(1, 256, 4, 14, 14) fast = torch.randn(1, 32, 32, 14, 14) fused = LateralFastToSlow(32, alpha=8)(slow, fast) print(fused.shape) # [1, 256+64, 4, 14, 14] = [1, 320, 4, 14, 14]
Now assemble the whole network. One clip in; one action label out. The data flow, end to end:
The two backbones run in parallel. Each is a 3D ResNet (the paper reports ResNet-50 and ResNet-101 variants). At several intermediate stages a lateral connection injects Fast motion into Slow. At the end, each pathway is globally average-pooled to a single feature vector; the two vectors are concatenated and fed to one fully-connected classifier with a softmax over action classes.
A configuration is written as SlowFast T×τ. For example, SlowFast 4×16 means the Slow pathway sees T = 4 frames with stride τ = 16; with α = 8 the Fast pathway sees 32 frames. SlowFast 8×8 means Slow sees 8 frames at stride 8, and Fast sees 64. Larger T and smaller τ (more frames, denser) cost more and score higher.
| Component | Setting (paper default) |
|---|---|
| Backbone | 3D ResNet-50 / ResNet-101 (both pathways) |
| τ (Slow stride) | 16 |
| α (Fast denser by) | 8 |
| β (Fast channel ratio) | 1/8 |
| Fusion direction | Fast → Slow only |
| Fusion op | Time-strided 3D conv, then concat |
| Slow early temporal kernel | 1 (space-only early) |
| Fast temporal kernel | > 1 throughout, no temporal downsampling |
| Head | Global avg pool each pathway → concat → FC → softmax |
SlowFast 4×16, ResNet-50, α=8, β=1/8, input 64 raw frames at 224×224:
| Stage | Slow [T,H,W,C] | Fast [αT,H,W,βC] |
|---|---|---|
| Input | [4, 224, 224, 3] | [32, 224, 224, 3] |
| conv1 | [4, 56, 56, 64] | [32, 56, 56, 8] |
| res2 (+lateral) | [4, 56, 56, 256] | [32, 56, 56, 32] |
| res3 (+lateral) | [4, 28, 28, 512] | [32, 28, 28, 64] |
| res4 (+lateral) | [4, 14, 14, 1024] | [32, 14, 14, 128] |
| res5 (+lateral) | [4, 7, 7, 2048] | [32, 7, 7, 256] |
| global pool | [2048] | [256] |
| concat | [2304] → FC → softmax over classes | |
Read the trace as a story: the Slow column grows fat in channels (3→2048) while staying short in time (always 4). The Fast column stays thin (3→256) while staying long in time (always 32). At the end, 2048 + 256 = 2304 features — overwhelmingly Slow appearance, lightly seasoned with Fast motion — go to one classifier.
Both pathways drawn side by side. The Slow stack (warm) is wide; the Fast stack (teal) is tall (more frames) but thin. Purple arrows are the lateral Fast→Slow connections. Click "Fast→Slow" to highlight the fusion, "Heads" to highlight the concat+classifier.
A design this clean is only worth it if it wins. SlowFast did — across multiple video benchmarks, and crucially, at lower compute than the dense models it beat.
Kinetics-400 is the standard large-scale action-recognition benchmark: ~240k training clips across 400 action classes. SlowFast set a new state of the art on Kinetics-400 top-1 accuracy at the time of publication, with the deeper SlowFast-101 (plus non-local blocks) reaching the high seventies in top-1 — surpassing the previous best dense 3D-CNN models while using fewer FLOPs per clip. It also led on Kinetics-600.
The headline comparison is not just accuracy — it is accuracy per FLOP. SlowFast lands on a better point of the accuracy-vs-compute curve: for a given compute budget it is more accurate, and for a given accuracy it is cheaper. That Pareto improvement is the paper's central empirical claim.
A schematic accuracy-vs-FLOPs plot. Prior dense 3D-CNNs (gray) and SlowFast configurations (warm) — bigger SlowFast dots are larger T×τ settings. SlowFast sits up and to the left: more accurate at equal cost. Drag to scrub through SlowFast configs of increasing size and watch it climb the frontier.
AVA is harder: instead of labeling a whole clip, you must detect which person is doing which action, localized in space and time (a bounding box per actor, multi-label actions). SlowFast, used as the backbone feeding a detection head, set a large new state of the art on AVA — a substantial jump in mean average precision (mAP) over prior methods. This mattered because AVA actions are heavily motion-dependent (e.g., "stand up," "open door," "hand-shake"), exactly where the dense Fast pathway pays off.
Recall the FLOP split: Slow ~80%, Fast ~20%. The Fast pathway delivers a meaningful accuracy boost (several points of top-1 on Kinetics in the ablations) for that ~20% surcharge. Compare with the naive alternative — a single dense pathway sampling αT frames at full width — which would cost roughly α× the Slow pathway (8×) for similar temporal coverage. SlowFast achieves comparable-or-better temporal modeling for a fraction of that.
| Benchmark | Task | SlowFast result (qualitative) |
|---|---|---|
| Kinetics-400 | Clip action classification | New SOTA top-1 at lower FLOPs than prior dense 3D-CNNs |
| Kinetics-600 | Clip action classification | Leading top-1 accuracy |
| Charades | Multi-label activity | Strong gains on long-range multi-label activities |
| AVA v2.1 | Spatiotemporal action detection | Large new SOTA mAP — biggest jump on motion-heavy actions |
A paper like this lives or dies by its ablations — controlled experiments that remove or vary one ingredient to prove it earns its place. SlowFast's ablations are unusually clean, and they're the best way to internalize why each design choice exists.
Take the Slow pathway alone (no Fast, no laterals) and measure accuracy. Then add the thin Fast pathway and the laterals. The Fast pathway adds several points of top-1 accuracy on Kinetics for only ~20% more FLOPs. This is the load-bearing result: a tiny, cheap pathway dedicated to motion gives a large, cheap accuracy boost. Slow-only is a strong appearance model but blind to fine motion; adding Fast fixes exactly that gap.
Vary α (1, 2, 4, 8). Accuracy rises as α grows — denser temporal sampling captures more motion — and the paper's sweet spot is α = 8. Beyond that, returns diminish while cost climbs. This directly validates the temporal-aliasing argument from Chapter 2: more frames per second → less motion missed → higher accuracy, up to a point.
Vary β (the channel ratio). Remarkably, a very small β (like 1/8) already captures most of the benefit. Making the Fast pathway wider (larger β) adds cost faster than accuracy. This is the "motion is low-dimensional" claim made empirical — you do not need a fat motion pathway.
They compare fusion operations (sum, concatenation, the time-strided conv, a time-to-channel reshape) and fusion directions (Fast→Slow, Slow→Fast, bidirectional, none). Findings: (a) lateral connections matter — removing them hurts; (b) the time-strided-conv fusion works best; (c) one-way Fast→Slow is the clean winner. Bidirectional fusion didn't help enough to justify bloating the Fast pathway.
A schematic of the four ablation curves. Pick which knob to vary; the chart shows accuracy (warm) rising and FLOPs (teal) rising as you push that knob. Watch how accuracy saturates while cost keeps climbing — that's how the paper picked α=8, β=1/8.
| Knob varied | What happens | Paper's choice |
|---|---|---|
| Fast pathway on/off | +several pts top-1 for ~20% FLOPs | On (it's the whole idea) |
| α (Fast density) | Accuracy ↑ with density, saturating | α = 8 |
| β (Fast width) | Tiny β already gets most gain; wide is wasteful | β = 1/8 |
| Fusion op | Time-strided conv > reshape > sum | Time-strided conv |
| Fusion direction | Fast→Slow > bidirectional > none | Fast→Slow only |
Time to put it all together. Below is a live SlowFast simulator. A scene plays at top — a person performing an action with both a slowly-changing background (spatial semantics) and a fast-oscillating limb (motion). You control the two clocks (τ, α), the Fast pathway's width (β), and you can toggle the lateral fusion on and off. Watch, in real time:
Top: the playing scene + the two sampling tracks. Middle: captured-motion meter and the FLOP split. Bottom: recognition confidence. Starve the Fast pathway (drop α or turn off fusion) and motion confidence collapses; over-widen it (raise β) and cost balloons for little gain. The paper's sweet spot (τ=16, α=8, β=1/8, fusion ON) is the green zone.
Play with it until the relationships are intuitive:
SlowFast is elegant, but it is not the end of video understanding. Knowing where it stops is as important as knowing how it works.
The two-pathway / multi-rate idea echoes through later work, and the Fast/Slow capacity-vs-rate trade-off is a reusable design pattern far beyond video. SlowFast itself became a standard backbone for action detection and a strong baseline that video Transformers had to beat. The authors went on to MViT (multiscale vision Transformers) and the broader move to attention-based video models.
Related Veanors and Gleams on this site:
| Symbol / term | Meaning | Paper default |
|---|---|---|
| τ | Slow pathway temporal stride (frames between samples) | 16 |
| α | Fast is α× denser in time than Slow | 8 |
| β | Fast channel ratio (Fast width = β × Slow width) | 1/8 |
| T / αT | Frames seen by Slow / Fast pathway | e.g. 4 / 32 |
| Slow pathway | Low rate, high capacity — spatial semantics (what) | ~80% FLOPs |
| Fast pathway | High rate, low capacity — motion (how) | ~20% FLOPs |
| Lateral connection | Time-strided conv, fuses Fast→Slow at each stage | Concat after conv |
| FLOP ratio Fast/Slow | ≈ α·β2 | 8·(1/8)2 = 1/8 |
| Head | Global pool each pathway → concat → FC → softmax | 2048+256 = 2304 |
| Benchmarks | Kinetics (classify), AVA (detect), Charades | SOTA at lower FLOPs |
"The two pathways are designed to capture distinct temporal speeds: a Slow pathway operating at low frame rate to capture spatial semantics, and a Fast pathway operating at high frame rate to capture motion at fine temporal resolution." — Feichtenhofer et al., 2019