Intuition The one core idea
Both DenseNet and EfficientNet are recipes for building an image-recognition network out of the same handful of Lego bricks — the feature map , the convolution , and the channel . DenseNet's trick is let every layer see every earlier layer's output ; EfficientNet's trick is grow a network in three directions at once, in balance . Everything on the parent page is just those two ideas expressed in symbols — and this page earns every symbol.
Before we can read a single line of the parent note, we need a shared picture of what a CNN actually moves around. Let us build the vocabulary brick by brick, each brick resting on the one before.
Definition Pixel grid, height
H , width W
An image is a rectangle of tiny coloured squares called pixels . Count the rows: that number is the height H . Count the columns: that is the width W . A "224 × 224 " image means H = 224 rows and W = 224 columns of pixels.
Look at the left panel of the figure below: a grey grid, H tall and W wide. That is one flat sheet of numbers.
But a colour image is not one sheet — it is three sheets stacked: how red each pixel is, how green, how blue. Each sheet is called a channel .
C and feature map
A channel is one flat H × W grid of numbers. A colour photo has C = 3 channels (Red, Green, Blue). After a network processes it, each channel is no longer "redness" — it becomes "how strongly some learned pattern (an edge, a texture, a fur-like blob) is present at each spot". Such a processed grid is called a feature map . So a feature map is one channel of learned evidence , and a stack of them has shape H × W × C .
Why does the topic need this? Every quantity the parent talks about — "64 channels", "256 channels", "1024 -d vector" — is just how many of these grids are stacked at that point in the network . When DenseNet says a layer "produces k feature maps", it means it adds k new grids to the stack.
Intuition Why a convolution and not a plain multiply?
A face can appear top-left or bottom-right of a photo. We want a detector that finds "an eye" wherever it is . A plain fully-connected multiply learns a separate weight for every pixel position — huge and position-locked. A convolution instead learns ONE small stamp and slides it over every position, so the same pattern is found everywhere. That sharing is the whole reason CNNs exist.
Definition Kernel / filter, size
3 × 3
A kernel (also called a filter ) is a tiny grid of weights, usually 3 × 3 or 1 × 1 or 5 × 5 . You lay it on a patch of the input, multiply each weight by the number under it, add the results into a single output number, then slide one step and repeat. The stream of output numbers forms one new feature map.
Look at the middle figure: the small magenta 3 × 3 stamp sits on the input; the single violet dot on the right is the one number it produces for that position. Slide the stamp across all positions to fill the whole output grid.
1 × 1 convolution
A ==1 × 1 convolution== is a stamp of size one pixel. It does not look at neighbours — it only mixes the C channels at a single spot into a new set of channels. Its whole job is to change the number of channels (e.g. squeeze 256 channels down to 128 ). This is exactly the "reduce dimensionality before the expensive 3 × 3 " trick the parent invokes in bottleneck and transition layers. Prerequisite depth on this lives in 3.4.8-Inception-and-GoogLeNet .
Definition Depthwise convolution
A normal 3 × 3 conv mixes all input channels into each output. A depthwise convolution gives each channel its own private 3 × 3 stamp and never mixes channels — far fewer multiplications. EfficientNet's MBConv block is built from these; the full story is in 3.4.9-MobileNet-and-Depthwise-Separable-Convolutions .
Why the topic needs it: the parent's parameter counts (like 36 k 2 for a 3 × 3 conv, or the MBConv "expand t , depthwise, project" pipeline) are literally counting the weights inside these stamps.
A parameter is one learnable number the network stores. A 3 × 3 kernel that maps m input channels to n output channels holds m × n × 3 × 3 parameters — because it needs a separate 3 × 3 stamp for every (input-channel, output-channel) pair. This is the exact formula behind the parent's "m × k × 3 × 3 ".
Definition FLOP (floating-point operation)
A FLOP is one multiply-or-add the machine performs when running the network (not stored — executed ). For one conv layer the count scales as (number of layers) × (channels)2 × (spatial size), because you slide the stamp over H × W positions and each position mixes channels. That is precisely EfficientNet's FLOPs ∝ d ⋅ w 2 ⋅ r 2 .
Common mistake Parameters
= FLOPs
Parameters = memory the model stores . FLOPs = work it does per image. A 1 × 1 conv on a big image has few parameters but many FLOPs (it runs at every pixel). Keep them separate — the parent uses parameters for DenseNet bottlenecks and FLOPs for EfficientNet scaling.
H ℓ — a composite layer
The parent writes H ℓ for "the whole processing at layer ℓ ". The subscript ℓ (Greek letter ell ) is just a counter: layer number 1 , 2 , 3 , … . In DenseNet H ℓ means the chain BN → ReLU → Conv . Three sub-tools live inside it:
Definition BN = Batch Normalization
Batch Normalization rescales each channel so its numbers have a tidy spread (mean near 0 , spread near 1 ) before the next stamp. It keeps training stable. Full derivation: 3.4.3-Batch-Normalization-and-Regularization .
ReLU ("rectified linear unit") is the rule ReLU ( x ) = max ( 0 , x ) : keep positive numbers, turn negatives into 0 . It is the "bend" that lets the network learn non-straight-line patterns. See the figure — a flat floor then a 4 5 ∘ rise.
Definition Pooling (AvgPool / MaxPool, stride 2)
Pooling shrinks a feature map by summarising each little 2 × 2 block into one number — its average (AvgPool) or its maximum (MaxPool). Stride 2 means "step two pixels at a time", which halves H and W . This is how the parent goes 112 → 56 → 28 … . Pooling shrinks space ; the 1 × 1 conv beside it shrinks channels — together they are the transition layer.
[ ⋅ , ⋅ ]
The brackets [ x 0 , x 1 , … ] mean stack these feature maps on top of each other along the channel axis. If x 0 has 16 channels and x 1 has 8 , then [ x 0 , x 1 ] has 24 channels — nothing is blended, everything is kept side by side.
Contrast with addition (+ ), used by ResNet : adding two 16 -channel stacks gives 16 channels where each number is a sum — the originals are merged and lost . The figure shows both: concatenation grows the stack, addition overlays it.
k and k 0
k 0 = channels entering a dense block. k = channels each layer adds to the shared stack (the growth rate , e.g. 12 or 32 ). Because layers concatenate, after L layers the stack holds k 0 + L k channels — the parent's headline formula, and now you can see why : every layer piles on exactly k more grids.
Definition The three scaling knobs
d , w , r
==depth d == — how many layers stacked (taller network).
==width w == — how many channels per layer (fatter network).
==resolution r == — how big the input image is (finer detail).
A picture: depth = number of pancakes; width = diameter of each pancake; resolution = fineness of the batter grain.
ϕ , α , β , γ — the compound-scaling letters
ϕ (Greek phi ) is a single dial you turn to make a bigger model (B0, B1, … B7). α , β , γ (alpha, beta, gamma) are fixed rates found by search: raise them to the power ϕ to get how much to grow depth, width, resolution. The pieces α ϕ , β ϕ , γ ϕ are just "growth factors" — numbers ≥ 1 that multiply the baseline. The search that finds them is 3.4.11-Neural-Architecture-Search .
Recall Why the exponent, not a plain multiply?
Turning the dial ϕ → ϕ + 1 should double the FLOPs each time. Repeated doubling is exponential, so growth must be α ϕ (exponent), giving total FLOP factor ( α β 2 γ 2 ) ϕ . Setting α β 2 γ 2 = 2 makes each step a clean 2 × .
Convolution sliding stamp
1x1 conv changes channels
Concatenation vs addition
DenseNet and EfficientNet
State each aloud; if you cannot, re-read that section.
What does a feature map represent, and what shape does a stack of them have? One channel of learned evidence, an H × W grid; a stack has shape H × W × C .
Why do we use convolution instead of a full multiply? One small kernel slides over all positions, so a pattern is detected wherever it appears and weights are shared.
What is the ONLY job of a 1 × 1 convolution? To change the number of channels by mixing them at each single pixel (no neighbours).
How many parameters in a 3 × 3 conv from m to n channels? 9 mn (that is m ⋅ n ⋅ 3 ⋅ 3 ).
Difference between a parameter and a FLOP? A parameter is a stored learnable number; a FLOP is one multiply/add executed while running.
What does ReLU ( x ) do to − 3 and to 5 ? Sends − 3 → 0 and keeps 5 → 5 (max of 0 and x ).
What does stride-2 pooling do to H and W ? Halves both by summarising each 2 × 2 block into one number.
Concatenation vs addition of two 16-channel stacks — resulting channel count? Concatenation → 32 channels (kept side by side); addition → 16 channels (merged, originals lost).
After L layers of growth rate k starting from k 0 , how many channels? k 0 + L k .
What do d , w , r scale, and what constraint links α , β , γ ? Depth, width, resolution; constraint α ⋅ β 2 ⋅ γ 2 ≈ 2 .