Conv 1D — Machine Learning/Neural Networks

Conv 1D

Machine Learning / Neural Networks

Slides a bank of kernels along the input channels:

y_i,co = b_co + Σ_ci Σ_j w_n(co,ci),j · u_{iS + jD − P, ci}, 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, [L,C_in]: one column per input channel, L rows along the sequence. A plain [L,1] column is the single-channel case and needs no setting. C_in is read off the signal, so there is nothing to configure that could disagree with it. L + 2P must be at least the kernel's span, or there is no complete window and the block is reported.
• Output – y, [L_out,C_out], one column per output channel. The block resizes its output when L, C_in or any of the geometry changes, so a downstream block sees the new shape.

Parameters

• Kernel – w, a [C_out·C_in, K] matrix: one row per (output, input) channel pair, row n = co·C_in + ci, each row carrying that pair's K taps in signal order. That is exactly layer.weight.reshape(-1, K) for a PyTorch Conv1d, so a trained tensor pastes in without being rearranged. In Depthwise there is no ci axis and it is [C_out, K].
  • A [K,1] column is also accepted, and only when C_out·C_in = 1: it is the same K taps written the other way round, it is the default, and it is what a project saved before this block was multi-channel loads as. With more than one channel pair a column is refused rather than reinterpreted – both readings would be possible, and the wrong one is a silently different network.
• Bias – b. Either a single value, added to every output channel, or a [C_out,1] column, one per output channel. Use 0 for a layer trained with bias=False.
• Output Channels – C_out, how many columns the output carries; a whole number ≥ 1, and 1 by default. In Depthwise it must be a positive multiple of C_in, and C_out/C_in is then PyTorch's channel multiplier.
• Channel Mode – whether the channels are mixed:
  • Standard (sum across channels) – the ordinary convolution: every output channel sums over all C_in input channels. The default.
  • Depthwise (one kernel per channel) – one kernel per input channel and no sum across them, PyTorch's groups = in_channels. Output channel co reads input channel co ÷ (C_out/C_in), which is PyTorch's own ordering. This is the depthwise half of a depthwise-separable convolution; the pointwise half is a second Conv 1D with K = 1.
• 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, in both the sequence and the channel axis, 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. Depthwise emits fewer terms rather than a guarded loop: the cross-channel products simply are not written. 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.
• Multi-channel, in both modes. The three-dimensional weight tensor is carried by the [C_out·C_in, K] flattening above, which is the convention this block defines and PyTorch's reshape produces. Depthwise Conv 1D is the Depthwise setting of Channel Mode, not a second block; a dilated convolution is the Dilation setting, for the same reason.
• 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.