Conv 2D — Machine Learning/Neural Networks

Conv 2D

Machine Learning / Neural Networks

Slides one kernel over the input matrix in both axes:

y_a,b = B + Σ_i Σ_j W_i,j · u_{aSR+iDR−PR, bSC+jDC−PC}, with u read as 0 outside the matrix, and R_out = ⌊(R + 2P_R − span_R) ÷ S_R⌋ + 1, C_out = ⌊(C + 2P_C − span_C) ÷ S_C⌋ + 1, where span_R = (K_R−1)D_R + 1 and span_C = (K_C−1)D_C + 1

The front end of any 2-D CNN: an image, a spectrogram, or any grid of features a convolution is meant to scan. It is Conv 1D in both axes, and it pairs with Pooling 2D exactly as Conv 1D pairs with Pooling 1D.

This is cross-correlation – the kernel is not reversed, and it is not transposed – which is what torch.nn.Conv2d and Keras Conv2D compute under the name convolution. A trained kernel pastes straight into the config.

Ports

• u – the grid, any matrix [R,C]. R + 2P_R must be at least the kernel's row span and C + 2P_C at least its column span, or there is no complete window and the block is reported.
• Output – y, a matrix [R_out,C_out] as above. The block resizes its output when the input size or any of the geometry changes, so a downstream block sees the new shape.

Parameters

• Kernel – W, the [K_R,K_C] filter taps, in grid order (row 0 is the top of the window). layer.weight[0][0] for a single-channel PyTorch Conv2d. The kernel need not be square, and the block is single channel: one kernel, one input matrix, one output matrix.
• Bias – B, one scalar added to every output cell. Use 0 for a layer trained with bias=False.
• Row Stride / Column Stride – S_R, S_C, how far the window advances per output down and across; whole numbers ≥ 1.
• Row Padding / Column Padding – P_R, P_C, how many implicit zeros are placed at each end of that axis; whole numbers ≥ 0. P = (span−1)/2 with a stride of 1 is the "same" padding that keeps the output the size of the input.
• Row Dilation / Column Dilation – D_R, D_C, the gap between taps along that axis; whole numbers ≥ 1. D = 1 is an ordinary convolution; larger values spread the same taps over a wider span without adding parameters.
• Sampling Time (s) – zero or less inherits the solver's rate; a positive value runs the block at that period.

Code export

All ten targets: Python, MATLAB, Java, Rust, C, C++, VHDL, Verilog, SystemVerilog and PLC Structured Text. Every window is unrolled at export time, and each tap that falls in the padding of either axis is resolved to a literal zero and dropped from the emitted expression rather than guarded at run time – so the generated code contains no bounds check anywhere. The kernel and bias are baked in at full setprecision(17); there is no tunable parameter, because a trained tap is not something to retune on the target.

The three HDL targets are ordinary Q16.16 fixed point and are offered for synthesis: the whole block is multiply-accumulate, with no transcendental and no division. Note that an unrolled 2-D convolution emits K_R·K_C products per output cell, so a large kernel over a large grid is a large amount of straight-line hardware.

Simulink bridge

None. Simulink's convolution layers live inside its Deep Learning blocks, which take a trained network object rather than a kernel, and no config value can carry an object across the bridge. (2-D FIR Filter in DSP System Toolbox performs the same arithmetic, but it is a filter over an image rather than a layer, and it does not carry a bias, a dilation or a per-axis stride.) The bridge reports the block rather than dropping it silently, and it has no parity testbench, which is the documented consequence of Support::None rather than a gap.

Notes

• Algebraic and stateless: the whole window comes from the current input matrix, not from past samples. This convolves across the grid, not across time.
• Linear in u, but it deliberately carries no state space: an [R_outC_out, RC] feed-through matrix is not what ICoreStateSpace's merge rules are for, and model reduction requires a SISO form this block does not have.
• Single channel. A multi-channel convolution would need a [C_out,C_in,K_R,K_C] weight tensor, which a two-dimensional config cannot carry without a flattening convention this block does not define.
• The tail is dropped in each axis independently, exactly as in every framework: if (R + 2P_R − span_R) is not a multiple of S_R, the rows past the last complete window are not read, and likewise for the columns.