Conv 1D — Machine Learning/Neural Networks

Conv 1D

Machine Learning / Neural Networks

Slides one kernel along the input column:

y_i = b + Σ_j w_j · u_{iS + jD − P}, with u read as 0 outside the signal, and L_out = ⌊(L + 2P − span) ÷ S⌋ + 1 where span = (K−1)D + 1

The front end of any 1-D CNN or temporal convolutional network. Stack several with Dilation 1, 2, 4, 8 and you have a TCN: the receptive field doubles per layer while the parameter count does not.

This is cross-correlation – the kernel is not reversed – which is what torch.nn.Conv1d and Keras Conv1D compute under the name convolution. A block that reversed it to be mathematically pedantic would disagree with every set of trained weights you paste in.

Ports

• u – the sequence, a column [L,1]. L + 2P must be at least the kernel's span, or there is no complete window and the block is reported.
• Output – y, a column [L_out,1] as above. The block resizes its output when L or any of the geometry changes, so a downstream block sees the new length.

Parameters

• Kernel – w, the [K,1] filter taps, in signal order. layer.weight[0][0] for a single-channel PyTorch Conv1d.
• Bias – b, one scalar added to every output. Use 0 for a layer trained with bias=False.
• Stride – S, how far the window advances per output; a whole number ≥ 1.
• Padding – P, how many implicit zeros are placed at each end; a whole number ≥ 0. P = (span−1)/2 with S = 1 is the "same" padding that keeps L_out = L.
• Dilation – D, the gap between taps; a whole number ≥ 1. D = 1 is an ordinary convolution; larger values spread the same K 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 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.

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. (Discrete FIR Filter is a different thing: it filters along time, one sample in and one out, where this slides along a vector within one sample.) 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 column, not from past samples. This convolves across the vector, not across time – for a filter over TIME use Discrete FIR Filter.
• Linear in u, but it deliberately carries no state space: an [L_out,L] 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. One kernel, one input column, one output column. A multi-channel convolution – and the depthwise variant that goes with it – would need a three-dimensional weight tensor, which a two-dimensional config cannot carry without a flattening convention this block does not define.
• The tail is dropped, exactly as in every framework: if (L + 2P − span) is not a multiple of S, the samples past the last complete window are not read.