Temporal convolutional network (TCN)

Overview

A temporal convolutional network (TCN) processes a sequence with one-dimensional convolutions instead of a recurrent cell. Dilation widens the reach of each layer, so the receptive field grows with depth. Seven cards on the wiki describe a block of this kind or a library that ships one. A forecasting library, Darts, ships a TCN model whose output layer is a likelihood 2110.03224 §3. A self-supervised activity model is also linked to this page, but its convolutions are not dilated 1907.11879 §3.3. In a forecaster, the convolutions are causal and a dense layer maps the window to the forecast horizon 2103.12057 §3.2.1 2103.12057 §2.3.1. In a skeleton action recognizer, a multi-scale temporal block follows each graph layer 2107.12213 §3.4. In a traffic forecaster, dilated temporal convolutions sit before and after a graph ODE block 2106.12931 §4.3 2106.12931 §4.4. A survey of spatio-temporal graph networks describes the gated, causal form of the same block without experiments 2303.14483 §5.3. A second traffic survey names STGCN's sandwich of temporal convolutions and Graph WaveNet's causal convolutions, again without experiments 2101.11174 §4.2. A study of forearm EMG regression for prosthesis control uses a causal TCN whose kernel, dilations and depth are not stated 2412.17991 §2.1.6. The original TCN papers are not on the wiki, so this page relies on the cards only.

What the variants share is a one-dimensional convolution along the time axis, dilated to reach further back. The forecaster 2103.12057 §2.3.1 and the gated survey block 2303.14483 eq. 11 describe causal convolutions. The EMG study calls its TCN strictly causal, so each prediction uses only earlier input 2412.17991 §2.1.6. The skeleton paper does not say whether its convolutions are causal. The traffic paper describes zero padding that keeps the length without saying whether the padding is causal 2106.12931 §4.3.

Variants

Single-stack TCN in a univariate forecasting benchmark

The benchmark builds the TCN from stacks residual blocks, with filters channels, a kernel size and a list of dilations 2103.12057 §3.2.1 models.py. The paper calls stacks the "number of TCN layers" 2103.12057 §3.2.1. The grid is 1 or 3 layers, 32 or 64 filters, dilations 1, 2, 4, 8 or 1, 2, 4, 8, 16, kernel 3 or 6, and return-sequence true or false, 32 configurations in all [arxiv:2103.12057 tab. 9]. Across the grid, the receptive field (layers × kernel × last dilation) spans 24 to 288 steps 2103.12057 §3.2.1. Card: An Experimental Review on Deep Learning Architectures for Time Series Forecasting.

The paper does not run a TCN against any other baseline. Its only comparisons are the other six architectures in the same grid 2103.12057 §3.2.

Multi-scale temporal block in a skeleton action recognizer

CTR-GCN puts a temporal module after each spatial graph module. The module has four parallel branches. Each starts with a 1x1 convolution that reduces the channels. Two branches apply dilated temporal convolutions, one applies max pooling over time, and one stays a plain 1x1 convolution. The four outputs are concatenated 2107.12213 §3.4. The paper takes this multi-scale design from MS-G3D 2107.12213 §3.4.

The paper does not call this block a TCN. The card links it to this concept because the block is a stack of dilated temporal convolutions. In the paper's ablation, replacing the temporal convolution with temporal pooling drops the top-1 accuracy from 84.9% to 72.8%. The ablation's dataset and modality are not stated in the supplement [arxiv:2107.12213 supp. Ablation Study]. Card: Channel-wise Topology Refinement Graph Convolution for Skeleton-Based Action Recognition.

Dilated temporal convolution around a graph ODE block in traffic forecasting

STGODE predicts the next hour of traffic flow from the previous hour. Each of its blocks is a sandwich: a temporal convolution, a tensor ODE solver that propagates over a road graph, and a second temporal convolution [arxiv:2106.12931 §4.4] fig. 5. Each temporal convolution is a one-dimensional convolution over time with dilation 2^(l−1), zero padding that keeps the length, and a residual structure 2106.12931 §4.3. The paper does not give the kernel size, the number of layers or the activation of these convolutions [arxiv:2106.12931 §4.3]. The paper's own code uses different values; the card records them 2106.12931 §4.3.

The paper does not test the temporal convolutions on their own. Its ablation compares graph-convolution variants, and its depth experiment varies the input window or the number of convolution layers in a different model. Neither isolates the TCN 2106.12931 §5.6.1 2106.12931 §5.6.2. Card: Spatial-Temporal Graph ODE Networks for Traffic Flow Forecasting.

Gated causal dilated convolution in a spatio-temporal survey

The survey runs no experiments. It describes a gated block: a tanh branch multiplied by a sigmoid branch, both built from convolutions over time 2303.14483 eq. 10 2303.14483 §5.3.1. Its convolution is causal and dilated, so each output reads only past inputs 2303.14483 eq. 11 2303.14483 §5.3.2. The printed sum leaves out its lower limit, so the implementer must set the kernel range 2303.14483 eq. 11. In the graph-plus-time pattern the survey describes, two temporal convolutions sit on either side of one graph convolution 2303.14483 eq. 13 2303.14483 §5.5.1. It also notes multi-scale TCNs with several kernel sizes, as in MTGNN 2303.14483 §6.2.1. Card: Spatio-Temporal Graph Neural Networks for Predictive Learning in Urban Computing: A Survey.

The survey gives no result for any TCN, so this variant makes no performance claim on this page.

Causal TCN regressor for EMG with online updates

A forearm EMG study reads 16 channels at 2000 Hz, computes five time-domain features per channel over 50 ms windows, and regresses seven wrist and finger angles 2412.17991 §2.1.2 2412.17991 tab. 1. The TCN takes a sequence of 40 feature frames (unit not stated), and its output is a sigmoid trained with mean squared error 2412.17991 tab. 1 [arxiv:2412.17991 §2.1.6]. The paper lists M = 128 and d = 25 for the TCN but does not define them, and it gives no kernel size, dilation schedule or layer count 2412.17991 §2.1.6. Its receptive field therefore cannot be worked out from the card.

The model is trained on one minute of cued or free movement. It is then tested on each of 15 thirty-second trials and updated on that trial's data 2412.17991 §2.1.5. The paper gives no optimizer, learning rate or epoch count for the update 2412.17991 §2.1.5.

Results are author-reported on 9 non-amputees, and the authors say the experiments are ongoing 2412.17991 §3.1. In the standard split the TCN has angular RMSE 8.4° against 8.0° for the LSTM and 11.3° for SVR. In the free-form offline split the figures are 10.4°, 9.9° and 15.4° 2412.17991 §3.1 2412.17991 §3.2. In the standard split both sequential models respond within one 25 ms step 2412.17991 §3.1. Online updating lowers RMSE by about 4° over a session for both the TCN and the LSTM 2412.17991 §3.3. The paper gives no inference time for either model 2412.17991 §3.2. Card: Online Adaptation for Myographic Control of Natural Dexterous Hand and Finger Movements.

Sandwich and causal temporal blocks in classic traffic GNNs, as surveyed

The traffic GNN survey describes two earlier models with TCN-style blocks. STGCN places two temporal convolutions around one graph convolution 2101.11174 §4.2. Graph WaveNet uses causal convolutions over time and learns a self-adaptive adjacency matrix, which the survey says is fixed after training 2101.11174 §4.2. The survey runs no experiments and copies results from other papers, so this variant makes no performance claim here. Card: Graph Neural Network for Traffic Forecasting: A Survey.

TCN model with a likelihood output in a forecasting library

The Darts library builds its TCN from an input length, an output length and a likelihood. Its paper shows one example: 24 input steps, 12 output steps, a Laplace likelihood, 100 epochs, and a 48-step forecast with 500 Monte Carlo samples, trained on two series together 2110.03224 §3. The paper calls the example's settings "default hyper-parameters" but does not list them. The card takes the defaults from the code at a later commit: kernel size 3, three filters, dilation base 2, dropout 0.2, batch size 32, and a depth worked out from the input length, kernel size and base tcn_model.py tcn_model.py. The likelihood replaces the mean-squared-error loss tcn_model.py.

The paper reports no accuracy result for this model, so this variant makes no performance claim. When the forecast horizon is longer than the output length, the model forecasts in chunks, one after another. The example does this, but the paper does not discuss it 2110.03224 §3 tcn_model.py. Card: Darts: User-Friendly Modern Machine Learning for Time Series.

Plain 1-D CNN in a self-supervised activity model (not dilated)

The card links this paper to the concept because its network convolves over time, but the trunk is not a TCN. It has three convolutional blocks with kernel sizes 24, 16 and 8, stride 1, each followed by ReLU and dropout, then global max pooling. The paper states no dilation, and it does not say whether the padding is causal 1907.11879 §3.3.

The trunk is pretrained on eight binary transformation-prediction tasks and then reused for activity classification. Across six smartphone datasets, its frozen features reach kappa 0.73 to 0.88, against 0.68 to 0.88 for a supervised network trained end to end. Frozen features trail supervised training on UniMiB, WISDM and MotionSense 1907.11879 tab. 2. These are author-reported results for a plain CNN, so they are not evidence for the TCN variants above. Card: Multi-task Self-Supervised Learning for Human Activity Detection.

When to use which

The evidence on this page is one univariate forecasting benchmark, one skeleton action-recognition paper, one traffic-forecasting paper and one EMG regression study with nine participants. The tasks differ, so their numbers are not comparable. Each row is a starting point, not a verdict.

Implementation sketch

The sketch follows the benchmark's TCN. Dilated causal convolutions are stacked in residual blocks, and a dense layer maps the result to the horizon. The paper does not define the residual block in detail, so the block itself is left as a placeholder.

# Temporal convolutional forecaster  [arxiv:2103.12057 §3.2.1]
def tcn_forecaster(inputs, filters, kernel, stacks, dilations,
                   return_sequences, horizon):
    # inputs has shape (batch, past_history, 1)
    x = inputs
    # `stacks` residual blocks, each with dilated causal convolutions
    # [arxiv:2103.12057 §2.3.1] [code: experiments/models.py#L228-L266]
    x = tcn_block(x, filters, kernel, stacks, dilations)
    if return_sequences:
        # Flatten the sequence before the output layer
        # [code: experiments/models.py#L54-L55]
        x = flatten(x)
    # One output neuron per horizon step  [arxiv:2103.12057 §3.2.1]
    return dense(horizon)(x)

Receptive field: layers × kernel × last_dilation. With one layer, kernel 6 and dilations up to 16, this gives 96 steps 2103.12057 §3.2.1.

The Darts TCN takes the same kind of arguments, and its depth is derived from the input length, kernel size and dilation base 2110.03224 §3 tcn_model.py. Changing the input length therefore changes the depth and the receptive field without an explicit edit to the layer count.

The skeleton variant's four-branch block is sketched on its card 2107.12213 §3.4, where it sits inside a larger network. The traffic variant's temporal convolution is a dilated convolution with a residual, placed on either side of an ODE block 2106.12931 §4.4. The paper leaves its kernel and depth open, so an implementation must choose them. The survey's gated form is a tanh branch times a sigmoid branch, each over causal convolutions 2303.14483 eq. 10. It gives no sizes for either branch. The EMG study's causal TCN is not sketched, because its kernel, dilations and depth are not stated 2412.17991 §2.1.6.

Contradictions

• Return-sequence for TCN. The paper's text says that returning the full sequence before the dense layer hurts TCN 2103.12057 §4.5 2103.12057 §4.4.3. Its TCN selection table lists return-sequence as true at the one-star level 2103.12057 tab. 17. The best TCN in the per-configuration table has return-sequence false 2103.12057 tab. 15. The card does not settle which is right.
• Traffic paper's text against its code. The paper describes a residual dilated stack for every temporal convolution 2106.12931 §4.3. A reading of the released code, which was not run, finds that some of these convolutions return a ReLU of their input when the channel counts match, so the dilated stack does not run for them. The card records the details. The card does not settle which is right, and the reported results are from the paper.
• Between the cards. None known. The cards measure different tasks, so no result from one is set against another.

Papers

• Graph Neural Network for Traffic Forecasting: A Survey: a traffic GNN survey that describes the sandwich and causal-convolution blocks of STGCN and Graph WaveNet. It runs no experiments.
• An Experimental Review on Deep Learning Architectures for Time Series Forecasting: benchmarks seven deep architectures, including a TCN, on 12 public univariate datasets with a shared grid-search protocol.
• Channel-wise Topology Refinement Graph Convolution for Skeleton-Based Action Recognition: a skeleton action recognizer whose temporal module is a four-branch multi-scale block with dilated temporal convolutions. The paper does not call it a TCN.
• Spatial-Temporal Graph ODE Networks for Traffic Flow Forecasting: a traffic forecaster that places dilated temporal convolutions around a graph ODE block. The paper calls them temporal convolutions and does not isolate them in its results.
• Spatio-Temporal Graph Neural Networks for Predictive Learning in Urban Computing: A Survey: a survey that describes gated, causal dilated convolutions as one temporal block. It runs no experiments.
• Online Adaptation for Myographic Control of Natural Dexterous Hand and Finger Movements: a causal TCN and an LSTM regress seven wrist and finger angles from forearm EMG, and update during a free-form session. Author-reported on 9 non-amputees.
• Darts: User-Friendly Modern Machine Learning for Time Series: a forecasting library whose example trains a TCN with a Laplace likelihood on two series. The paper reports no accuracy results.
• Multi-task Self-Supervised Learning for Human Activity Detection: a self-supervised 1-D CNN for accelerometer activity recognition. Its trunk is not dilated, so the card's link to this page is by tag only.