From Pixels to Class Scores

LeNet's recipe was conv, pool, conv, pool, dense. VGG's building block was a few 3×3 convolutions followed by a pool. Here you run a tiny network made of one VGG-style block (two 3×3 convolutions, then a pool) and a dense head, end to end, on a grayscale image.

The network, in order:

1. Conv 1. k1 holds $F_1$ filters, each a 3×3 grid, and b1 holds one bias per filter. Each filter slides over the image with no padding and stride 1. At every position, multiply each pixel by the filter value sitting on top of it, then add the nine products and the bias. That gives $F_1$ feature maps. Apply ReLU.
2. Conv 2. k2 holds $F_2$ filters, with biases b2. Each filter spans the full depth of its input, so it is a list of $F_1$ grids of 3×3, one grid per Conv 1 map. At every position, add up the products over all $F_1$ maps, then add the bias. That gives $F_2$ feature maps. Apply ReLU.
3. Max pool. 2×2 windows with stride 2, on each map separately. If a map has an odd number of rows or columns, the leftover last row or column is dropped.
4. Flatten. All of pooled map 0 row by row, then all of pooled map 1 row by row, and so on.
5. Dense head. w has one row of weights per class and b one bias per class. Class $c$ scores $\sum_i w_{ci} \, \text{flat}_i + b_c$.

Task: write cnn_forward(image, k1, b1, k2, b2, w, b) returning the list of class scores (no softmax), each rounded to 4 decimal places.

The image is a list of rows of numbers. Every test passes an image large enough to survive both convolutions and the pool, and a w whose rows match the flattened length.