[Question, possible BUG] Output of _TCNModule is a function of input_chunk_length, not output_chunk_length

[DanielBergThomsen]

Hello!

I've been working with the _TCNModule of the library, and only noticed now that the size of the output is the following shape:
x = x.view(batch_size, self.input_chunk_length, self.target_size, self.nr_params)
This strikes me as a bit odd; why would we want to produce target predictions for the past? In that case the model ought to just output the targets it has access to directly.

Best regards,
Daniel

[DanielBergThomsen]

To be more specific, this is the part of the code I am referencing:

darts/darts/models/forecasting/tcn_model.py

Lines 234 to 248 in 6096968

	def forward(self, x_in: Tuple):
	x, _ = x_in
	# data is of size (batch_size, input_chunk_length, input_size)
	batch_size = x.size(0)
	x = x.transpose(1, 2)
	for res_block in self.res_blocks_list:
	x = res_block(x)
	x = x.transpose(1, 2)
	x = x.view(
	batch_size, self.input_chunk_length, self.target_size, self.nr_params
	)
	return x

The reason this is working right now is that input_chunk_length is passed as the length parameter in TCNModel:

darts/darts/models/forecasting/tcn_model.py

Lines 478 to 493 in 6096968

	def _build_train_dataset(
	self,
	target: Sequence[TimeSeries],
	past_covariates: Optional[Sequence[TimeSeries]],
	future_covariates: Optional[Sequence[TimeSeries]],
	max_samples_per_ts: Optional[int],
	) -> PastCovariatesShiftedDataset:
	return PastCovariatesShiftedDataset(
	target_series=target,
	covariates=past_covariates,
	length=self.input_chunk_length,
	shift=self.output_chunk_length,
	max_samples_per_ts=max_samples_per_ts,
	use_static_covariates=self.uses_static_covariates,
	)

But this means that losses are calculated based on entries not related to output_chunk_length.

[DanielBergThomsen]

After reading the documentation I noticed the following comment, which seems to indicate that this is intentional behavior:

darts/darts/models/forecasting/tcn_model.py

Lines 177 to 183 in 6096968

	Outputs
	-------
	y of shape `(batch_size, input_chunk_length, target_size, nr_params)`
	Tensor containing the predictions of the next 'output_chunk_length' points in the last
	'output_chunk_length' entries of the tensor. The entries before contain the data points
	leading up to the first prediction, all in chronological order.
	"""

It seems different from other implementations of TCNs (https://github.com/locuslab/TCN for example).

The reason this could be a problem is that this indeed does result in the training losses being based on the targets of previous time steps. As a user, I don't particularly care for this I just want the model to be able to predict the future output_chunk_length number of targets accurately.

I would just like confirmation whether I've missed something, if I didn't miss anything I would be down to create a PR to try and change it.

[dennisbader]

Hi @DanielBergThomsen, and sorry for the late response.

Thanks for opening this issue. I think you are right, the loss shouldn't be computed on the target values that were fed to the model as input.

I raised PR #2006 to address this. Feel free to review, or suggest changes if you thought of a different way of solving it.

[entropicbloom]

Hi @DanielBergThomsen. While this might seem counter-intuitive, it should make sense given how the TCN model works and how its training data is structured.

The base TCN model (not specifically adapted to the forecasting use case) transforms a sequence of a given length into another sequence of the same length using causal convolutions. The way we adapt this to the forecasting use case is by shifting the output (target sequence) by the number of time steps we want to forecast (for more details check out our blog post https://unit8.com/resources/temporal-convolutional-networks-and-forecasting/). Because we use convolutions, the learned weights are the same regardless of which timestamp we are predicting. You can think of the convolutional kernel as learning to model the time series a given number of steps in advance, regardless of position. And, because the convolutions are causal, predictions are only dependent on datapoints that precede that time step. Thus, this kernel can be trained at any point in the time series, and it thus is ok to compute the loss on the whole sequence. There is a caveat: For the points at the beginning of the output sequence, a part of their input consists of zero-padding, so there is less learning happening there. But to utilize the data to its fullest extent, it still makes sense to train on them. As a side note, to my knowledge this is more or less how a lot of language transformers are trained as well.

When it comes to the actual prediction, however, we indeed only care about the last output_chunk_length timestamps of the output and disregard the rest.

TLDR: You didn't miss anything, this is intentional!