1D Convolution for Sensor Streams

From Edge Detectors to Sensor Streams

Open any introductory image-processing book and the first algorithm you meet is the Sobel edge detector: a tiny 3 × 3 weight matrix that, when slid across an image, lights up wherever brightness changes sharply. Gravitational-wave astronomers do the same with matched filters: a known waveform template is correlated against a noisy receiver stream, with peaks marking detections. Speech-recognition front-ends use 1-D filters to find vowel onsets in a microphone signal. These are the same operation: take a small set of weights, slide it along a signal, sum the products at every position.

Applied to a turbofan engine's sensor stream, the operation is called a 1D convolution — the workhorse of the first layer of every CNN-based prognostic model in this book. The kernel learns to detect local degradation patterns: sudden spikes, gradual trends, oscillations. The same architectural primitive that detects edges in photographs detects bearing wear in vibration signals.

The 1D Convolution Operation

Given an input signal $\mathbf{x} \in \mathbb{R}^{T}$ and a kernel $\mathbf{w} \in \mathbb{R}^{K}$, the (cross-) correlation that PyTorch and most deep-learning libraries call “convolution” is

$y_t \;=\; \sum_{k=0}^{K-1} w_k \, x_{t+k} \;+\; b.$

Three knobs control the geometry of the operation: kernel size $K$, stride $S$, and padding $P$. The output length is

$T_{\text{out}} \;=\; \left\lfloor \frac{T_{\text{in}} + 2P - K}{S} \right\rfloor + 1.$

With our default $K = 3$, $P = 1$, $S = 1$: $T_{\text{out}} = \lfloor (30 + 2 - 3)/1 \rfloor + 1 = 30$ — the time axis is preserved layer to layer, which is what we want when we stack three conv layers and then hand off to the BiLSTM.

Interactive: Watch the Kernel Slide

The visualization below uses a real C-MAPSS sensor (T30, total temperature at HPC outlet) and a 3-tap kernel. Press play and watch the kernel walk across the input; pause to inspect the weighted-sum at any position. The padding toggle shows you exactly what the zero-pad cycles look like at the edges.

Two things to take away. First, the output value at any position $t$ only depends on cycles $t$, $t+1$, $t+2$ — the receptive field. Cycles outside that window cannot affect $y_t$; this is why Section 9 will follow the conv with a BiLSTM that integrates over the whole window. Second, the same kernel applies at every position — the conv layer is translation-invariant. A spike at cycle 5 and a spike at cycle 25 both produce the same output magnitude; the model doesn't need to learn to detect spikes twice.

Multi-Channel: 17 Sensors at Once

Real sensor data has $F = 17$ channels (informative C-MAPSS sensors). The 1D convolution generalises trivially: each output channel $j$ uses a separate kernel $\mathbf{W}^{(j)} \in \mathbb{R}^{C_{\text{in}} \times K}$ that spans all input channels, then sums the contributions:

$y_t^{(j)} \;=\; \sum_{c=1}^{C_{\text{in}}} \sum_{k=0}^{K-1} W^{(j)}_{c,k} \, x_{t+k}^{(c)} \;+\; b^{(j)}.$

Each output channel is the weighted sum of all input channels across the kernel's temporal window. With $C_{\text{in}} = 17$, $C_{\text{out}} = 64$, $K = 3$ the layer holds $64 \times 17 \times 3 = 3{,}264$ weights plus 64 biases — 3,328 learnable parameters in one layer.

Interactive: Multi-Channel in Detail

The next visualization steps through a stacked 8 → 16 → 8 architecture. Click any output cell at any layer and the diagram shows you which input cells contributed to it — you can literally see the receptive field grow as you move up the stack.

Python: 1D Convolution From Scratch

Twenty-five lines of NumPy and the operation is fully transparent. We define conv1d_naive, run it on the 5-sample toy from above to verify the hand-computed numbers, then apply two well-known hand-crafted kernels — an edge detector and a three-tap smoother — to the same signal.

1import numpy as np
2
3# ----- A from-scratch 1D convolution -----
4# y[t] = sum_{k=0}^{K-1} w[k] * x[t + k] + b
5# Inputs may be padded with zeros to control output length.
6
7def conv1d_naive(x: np.ndarray,
8                 w: np.ndarray,
9                 stride: int = 1,
10                 padding: int = 0,
11                 bias: float = 0.0) -> np.ndarray:
12    """1-D cross-correlation. No batch / no channels yet."""
13    if padding > 0:
14        x = np.pad(x, padding)
15    K     = len(w)
16    L_in  = len(x)
17    L_out = (L_in - K) // stride + 1
18    y     = np.zeros(L_out, dtype=np.float32)
19    for t in range(L_out):
20        s = t * stride
21        y[t] = float(np.dot(x[s:s + K], w)) + bias
22    return y
23
24
25# ----- Run on a tiny signal with a 3-tap "smoother" kernel -----
26x = np.array([1.0, 3.0, 2.0, 4.0, 1.0])     # length 5
27w = np.array([0.5, 1.0, 0.5])               # length 3 - weighted average
28
29y_valid = conv1d_naive(x, w)
30y_same  = conv1d_naive(x, w, padding=1)
31
32print("input             :", x.tolist())
33print("kernel            :", w.tolist())
34print("y (no padding)    :", y_valid.tolist())     # [4.5, 5.5, 5.5]
35print("y (padding = 1)   :", y_same.tolist())      # [2.5, 4.5, 5.5, 5.5, 3.0]
36
37
38# ----- Edge detector and smoother on the same signal -----
39edge_kernel = np.array([-1.0,  2.0, -1.0])
40smooth_kernel = np.array([1/3, 1/3, 1/3])
41
42print("edge detector out :", conv1d_naive(x, edge_kernel).tolist())
43# edge detector out : [3.0, -3.0, 5.0]
44print("smoother out      :", conv1d_naive(x, smooth_kernel).tolist())
45# smoother out      : [2.0, 3.0, 2.333]

Verifying the hand-computation

The valid output $[4.5, 5.5, 5.5]$ matches the three-line worked example earlier in the section to the digit. The same kernel with padding$= 1$ emits five values instead of three — the input-length-preserving choice that lets us stack many conv layers without losing time-axis cycles.

PyTorch: nn.Conv1d (and the Axis Trap)

With that out of the way, the entire idiomatic PyTorch implementation is one nn.Conv1d instantiation plus the two transposes:

1import numpy as np
2import torch
3import torch.nn as nn
4
5# ----- nn.Conv1d on a multi-sensor batch -----
6# IMPORTANT: nn.Conv1d expects input shape (B, C_in, T) - NOT (B, T, C_in)!
7# Our CMAPSSDataset emits (B, T, F). We MUST .transpose(1, 2) before the conv.
8
9torch.manual_seed(0)
10B, T, F = 2, 30, 17                         # batch=2 engines, 30 cycles, 17 sensors
11
12# Step 1 - the dataset gives us (B, T, F)
13x_btf = torch.randn(B, T, F) * 5 + 100
14
15# Step 2 - permute to (B, F, T) for nn.Conv1d
16x_bft = x_btf.transpose(1, 2)               # (B, T, F) -> (B, F, T)
17
18# Step 3 - build the conv layer
19conv = nn.Conv1d(in_channels=17,
20                 out_channels=64,
21                 kernel_size=3,
22                 padding=1)                 # 'same' padding for K=3
23
24print("conv.weight.shape :", tuple(conv.weight.shape))   # (64, 17, 3)
25print("conv.bias.shape   :", tuple(conv.bias.shape))     # (64,)
26print("# params         :", sum(p.numel() for p in conv.parameters()))
27# # params         : 3328  (= 64*17*3 + 64)
28
29# Step 4 - forward pass
30y_bft = conv(x_bft)                         # (B, F=17, T) -> (B, 64, T)
31
32# Step 5 - permute BACK to (B, T, F') for the next layer / model section
33y_btf = y_bft.transpose(1, 2)               # (B, 64, T) -> (B, T, 64)
34
35print("x_btf.shape       :", tuple(x_btf.shape))    # (2, 30, 17)
36print("x_bft.shape       :", tuple(x_bft.shape))    # (2, 17, 30)
37print("y_bft.shape       :", tuple(y_bft.shape))    # (2, 64, 30)
38print("y_btf.shape       :", tuple(y_btf.shape))    # (2, 30, 64)
39print("y_btf[0, 0, :5]   :", y_btf[0, 0, :5].tolist())

What Kernels Actually Learn

Hand-coding kernels (Sobel, smoothing, Gaussian) is the classical approach. Modern deep learning learns kernels from data through back-propagation. Once trained, the learned weights tend to look like recognisable pattern detectors:

Three layers of these stacked become a hierarchy — layer 1 detects edges and gradients, layer 2 combines them into compound features (“spike followed by decay”), layer 3 produces high-level degradation signatures. Section 8 visualises exactly this hierarchy on a trained C-MAPSS model.

1D Convolution Beyond RUL

The same nine lines of code show up everywhere a model needs to detect local patterns in a 1-D signal. Each row in the table below is solved with an architecture that is, modulo the loader, identical to ours.

The mathematical machinery in this book transfers to every row of that table by changing only the loader and the input dimensions. The attention mechanism in Section 3.4, the loss function in Section 14, the gradient balancer in Section 18 — all applicable wherever a 1D conv frontend is the right entry point.

The Three Pitfalls

The pattern. A 1D convolution slides a learned kernel along the time axis and asks the same local question at every cycle. Stacking layers builds a hierarchy of questions. Coupling it with the BiLSTM in Section 3.3 gives the model both local pattern detection and long-range temporal dynamics — the architecture every model in this book uses.

Takeaway

• 1D convolution is one equation. $y_t = \sum_k w_k \, x_{t+k} + b$ — a weighted sum over a sliding window.
• Output length is mechanical. $T_{\text{out}} = \lfloor (T_{\text{in}} + 2P - K)/S \rfloor + 1$. Use $P = \lfloor K/2 \rfloor$ for same padding.
• Multi-channel is the same with one more sum. Each output channel sums contributions from all input channels and all kernel positions: $64 \times 17 \times 3$ weights per layer.
• PyTorch wants (B, C, T). Bridge from $(B, T, F)$ with x.transpose(1, 2) before nn.Conv1d; transpose back after.
• Translation invariance is free. The same kernel applies at every cycle — no need to teach the model about position. The BiLSTM in Section 3.3 will add position-aware temporal modelling on top.