---
kind: concept
slug: temporal-convolutional-network
title: Temporal convolutional network (TCN)
summary: >-
  Dilated 1D convolutions over time in residual blocks, or gated and causal in a survey. Seen in a forecaster, a skeleton recognizer, a traffic graph model, an EMG regressor and a forecasting library, and described in two GNN surveys. Receptive field is set by layers, kernel and dilation. The papers measure different tasks, so their numbers are not comparable.
tags: [time-series, forecasting, convolutional-networks, action-recognition, spatio-temporal]
papers: ["2101.11174", "2103.12057", "2107.12213", "2106.12931", "2303.14483", "2412.17991", "2110.03224", "1907.11879"]
related: [recurrent-neural-network, long-short-term-memory, convolutional-recurrent-network, convolutional-neural-network, graph-neural-network, neural-ode, time-series-forecasting, support-vector-machine]
status: draft
updated_at: 2026-11-01
---

## 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 [arxiv:2110.03224 §3]. A self-supervised activity model is also
linked to this page, but its convolutions are not dilated
[arxiv:1907.11879 §3.3]. In a forecaster, the convolutions are causal and a dense
layer maps the window to the forecast horizon [arxiv:2103.12057 §3.2.1]
[arxiv:2103.12057 §2.3.1]. In a skeleton action recognizer, a multi-scale
temporal block follows each graph layer [arxiv:2107.12213 §3.4]. In a traffic
forecaster, dilated temporal convolutions sit before and after a graph ODE
block [arxiv:2106.12931 §4.3] [arxiv:2106.12931 §4.4]. A survey of
spatio-temporal graph networks describes the gated, causal form of the same
block without experiments [arxiv:2303.14483 §5.3]. A second traffic survey
names STGCN's sandwich of temporal convolutions and Graph WaveNet's causal
convolutions, again without experiments [arxiv: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 [arxiv: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 [arxiv:2103.12057 §2.3.1] and
the gated survey block [arxiv:2303.14483 eq. 11] describe causal convolutions.
The EMG study calls its TCN strictly causal, so each prediction uses only
earlier input [arxiv: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 [arxiv: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` [arxiv:2103.12057 §3.2.1]
[code: experiments/models.py#L228-L266]. The paper calls `stacks` the
"number of TCN layers" [arxiv: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 [arxiv:2103.12057 §3.2.1]. Card:
[An Experimental Review on Deep Learning Architectures for Time Series Forecasting](/papers/2103.12057).

The paper does not run a TCN against any other baseline. Its only comparisons
are the other six architectures in the same grid [arxiv: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 [arxiv:2107.12213 §3.4]. The paper takes this multi-scale
design from MS-G3D [arxiv: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](/papers/2107.12213).

### 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 [arxiv: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
[arxiv: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 [arxiv:2106.12931 §5.6.1] [arxiv:2106.12931 §5.6.2]. Card:
[Spatial-Temporal Graph ODE Networks for Traffic Flow Forecasting](/papers/2106.12931).

### 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
[arxiv:2303.14483 eq. 10] [arxiv:2303.14483 §5.3.1]. Its convolution is causal
and dilated, so each output reads only past inputs [arxiv:2303.14483 eq. 11]
[arxiv:2303.14483 §5.3.2]. The printed sum leaves out its lower limit, so the
implementer must set the kernel range [arxiv:2303.14483 eq. 11]. In the
graph-plus-time pattern the survey describes, two temporal convolutions sit on
either side of one graph convolution [arxiv:2303.14483 eq. 13]
[arxiv:2303.14483 §5.5.1]. It also notes multi-scale TCNs with several kernel
sizes, as in MTGNN [arxiv:2303.14483 §6.2.1]. Card:
[Spatio-Temporal Graph Neural Networks for Predictive Learning in Urban Computing: A Survey](/papers/2303.14483).

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 [arxiv:2412.17991 §2.1.2] [arxiv: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 [arxiv: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
[arxiv: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
[arxiv:2412.17991 §2.1.5]. The paper gives no optimizer, learning rate or epoch
count for the update [arxiv:2412.17991 §2.1.5].

Results are author-reported on 9 non-amputees, and the authors say the
experiments are ongoing [arxiv: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°
[arxiv:2412.17991 §3.1] [arxiv:2412.17991 §3.2]. In the standard split both
sequential models respond within one 25 ms step [arxiv:2412.17991 §3.1]. Online
updating lowers RMSE by about 4° over a session for both the TCN and the LSTM
[arxiv:2412.17991 §3.3]. The paper gives no inference time for either model
[arxiv:2412.17991 §3.2]. Card:
[Online Adaptation for Myographic Control of Natural Dexterous Hand and Finger Movements](/papers/2412.17991).

### 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
[arxiv: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 [arxiv: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](/papers/2101.11174).

### 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 [arxiv: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 [code: darts/models/forecasting/tcn_model.py#L270-L275]
[code: darts/models/forecasting/tcn_model.py#L207-L225]. The likelihood
replaces the mean-squared-error loss [code: darts/models/forecasting/tcn_model.py#L321-L324].

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 [arxiv:2110.03224 §3]
[code: darts/models/forecasting/tcn_model.py#L289-L296]. Card:
[Darts: User-Friendly Modern Machine Learning for Time Series](/papers/2110.03224).

### 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 [arxiv: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 [arxiv: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](/papers/1907.11879).

## 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.

| Situation | Use | Why |
|---|---|---|
| Univariate series, a modest tuning budget, and you want a deep baseline beside the recurrent models | A TCN from the grid above, with one layer, kernel 6 and 64 filters as the starting point | This configuration ranked first in the paper's TCN selection, and TCN was best on NN5 and SolarEnergy [arxiv:2103.12057 tab. 11] [arxiv:2103.12057 tab. 15] |
| Several datasets and you need the most consistent accuracy | Compare against the LSTM and CNN baselines first | The paper ranks CNN first and LSTM second on mean WAPE across configurations. TCN is not in those top two [arxiv:2103.12057 §4.1] [arxiv:2103.12057 §4.3] |
| Latency or training time matters most | Measure your own TCN; the card gives no TCN timing result | The paper names CNN as the most efficient deep model, and does not rank TCN for speed [arxiv:2103.12057 §4.2] |
| Long history with a need for a deep receptive field | Set layers, kernel and dilations so their product covers the history | Receptive field is layers × kernel × last dilation, as the paper defines it [arxiv:2103.12057 §3.2.1] |
| Skeleton or other per-joint sequences, with a graph layer already in the model | A multi-scale temporal block after the graph layer, as in CTR-GCN | Temporal convolution beat temporal pooling in the paper's ablation. The paper gives no standalone TCN result [arxiv:2107.12213 supp. Ablation Study] |
| Traffic or other sensor-network forecasting, with a fixed graph of sensors and a need for long-range context | Dilated temporal convolutions around a graph block, as in STGODE | The paper reports the lowest RMSE, MAE and MAPE on six PeMS datasets, but for the whole model. It gives no result for the temporal convolutions alone, and the margins are small in some rows [arxiv:2106.12931 tab. 2] [arxiv:2106.12931 §5.4] |
| Short sensor windows, a causal regressor that must answer live, and a user whose signals drift during a session | A causal TCN or LSTM on frame features, with trial-by-trial updates if you need adaptation | Both sequential models beat SVR in the paper, and the LSTM has a small RMSE edge over the TCN in both splits. Online updating gives about 4° for each. The study is small and ongoing, and the paper gives no TCN inference time [arxiv:2412.17991 §3.1] [arxiv:2412.17991 §3.2] [arxiv:2412.17991 §3.3] |
| A graph-based forecaster where you want a temporal block to compare against recurrent or attention blocks | Build the block in the survey's gated causal form, then measure it against the alternatives on your data | The survey lists recurrent, convolutional and attention blocks and reports no measured comparison between them [arxiv:2303.14483 §5.2] [arxiv:2303.14483 §5.3] [arxiv:2303.14483 §5.4] |
| Python forecasting with a probabilistic output, where you do not want to write the network yourself | The Darts TCN model with a likelihood, measured on your own series | The paper gives no accuracy benchmark. It documents the API and one example, and the card records the code defaults for that commit [arxiv:2110.03224 §3] [arxiv:2110.03224 §2.5] |

## 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.

```pseudocode
# 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 [arxiv: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 [arxiv:2110.03224 §3]
[code: darts/models/forecasting/tcn_model.py#L207-L225]. 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
[arxiv: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 [arxiv: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 [arxiv: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
[arxiv: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 [arxiv:2103.12057 §4.5]
  [arxiv:2103.12057 §4.4.3]. Its TCN selection table lists return-sequence as
  true at the one-star level [arxiv:2103.12057 tab. 17]. The best TCN in the
  per-configuration table has return-sequence false [arxiv: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 [arxiv: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](/papers/2101.11174): 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](/papers/2103.12057): 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](/papers/2107.12213): 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](/papers/2106.12931): 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](/papers/2303.14483): 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](/papers/2412.17991): 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](/papers/2110.03224): 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](/papers/1907.11879): 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.