Two Heads, One Backbone

VGG-16 carries 138 million weights, and its conv stack is only about 15 million of them. The rest sit in the dense layers bolted onto the end. Global average pooling later deleted almost all of that by averaging each feature map down to a single number, using no weights at all.

You are given a network description and asked to produce the ledger: what the backbone costs, what each of the two candidate heads costs, and how lopsided the result is.

Task: write weight_ledger(size, depth, stages, hidden, classes).

• The input is a size × size grid of depth channels.
• stages is a list of [num_convs, filters] pairs. A stage runs num_convs $3\times3$ convolutions one after another — each outputs filters feature maps, with "same" padding so the grid is unchanged — and then a $2\times2$ max pool with stride 2, which halves each side. Every stage ends with a pool, including the last. If a side is odd, the pool drops the leftover row and column ($\lfloor s/2 \rfloor$).
• A conv layer costs $3 \times 3 \times (\text{input depth}) \times (\text{filters})$ weights, plus one bias per filter. Pooling and activations cost nothing.
• Two candidate heads are then measured on whatever block comes out:
  • the dense head flattens the entire block, feeds it to a dense layer of hidden units, then to a dense layer of classes units;
  • the GAP head averages each feature map to one number — no weights — then feeds those to a single dense layer of classes units;
  • a dense layer costs $(\text{inputs}) \times (\text{units})$ weights, plus one bias per unit.

Return [backbone, dense_head, gap_head, share], where the first three are the weight counts as plain integers and share is the fraction of a dense-headed network's total that sits in its head,

$\text{share} = \frac{\text{dense\_head}}{\text{backbone} + \text{dense\_head}}$

rounded to 4 decimal places.

The first test is VGG-16's shape, right down to the block it finishes on. The last number you return is the one that explains why anyone bothered inventing global average pooling — and why a backbone transfers to a new task so much more readily than the thing sitting on top of it.