# CATP: Context-Aware Trajectory Prediction with
Competition Symbiosis

Jiang Wu  Zhejiang UniversityHangzhouChina<EMAIL_ADDRESS>,  Dongyu
Liu  UC DavisDavisCAUSA<EMAIL_ADDRESS>,  Yuchen Lin  Zhejiang
UniversityHangzhouChina<EMAIL_ADDRESS>and  Yingcai Wu  Zhejiang
UniversityHangzhouChina<EMAIL_ADDRESS>
(2018; 20 February 2007; 12 March 2009; 5 June 2009)

###### Abstract.

Contextual information is vital for accurate trajectory prediction. For
instance, the intricate flying behavior of migratory birds hinges on their
analysis of environmental cues such as wind direction and air pressure.
However, the diverse and dynamic nature of contextual information renders it
an arduous task for AI models to comprehend its impact on trajectories and
consequently predict them accurately. To address this issue, we propose a
“manager-worker” framework to unleash the full potential of contextual
information and construct CATP model, an implementation of the framework for
Context-Aware Trajectory Prediction. The framework comprises a manager model,
several worker models, and a tailored training mechanism inspired by
competition symbiosis in nature. Taking CATP as an example, each worker needs
to compete against others for training data and develop an advantage in
predicting specific moving patterns. The manager learns the workers’
performance in different contexts and selects the best one in the given
context to predict trajectories, enabling CATP as a whole to operate in a
symbiotic manner. We conducted two comparative experiments and an ablation
study to quantitatively evaluate the proposed framework and CATP model. The
results showed that CATP could outperform SOTA models, and the framework could
be generalized to different context-aware tasks.

context-aware trajectory prediction, training algorithm, ensemble learning

††copyright: acmlicensed††journalyear: 2018††doi: XXXXXXX.XXXXXXX††conference:
Make sure to enter the correct conference title from your rights confirmation
emai; June 03–05, 2018; Woodstock, NY††isbn: 978-1-4503-XXXX-X/18/06††ccs:
Computing methodologies Machine learning algorithms††ccs: Computing
methodologies Neural networks

##  1\. Introduction

Trajectory prediction is widely applied in many scenarios, such as traffic
forecast (Fang et al., 2021; Lu et al., 2022), pedestrians’ movements
prediction (Bartoli et al., 2018), and sports player position prediction
(Lindström et al., 2020). In most scenarios, contextual information can
significantly affect the trajectories. For example, pedestrians will give way
to each other and avoid obstacles (Bartoli et al., 2018). Thus, many
trajectory prediction models integrate contextual information to improve
prediction accuracy.

However, as big data science evolves, contextual information has become
diverse and dynamic, bringing new challenges. Diversity: The trajectory is
affected by a combination of different types of contextual factors. For
example, birds’ migratory trajectories are affected by wind direction,
temperature, air pressure, etc. Multiple contextual factors collectively and
interactively influence the trajectories. Dynamic: The contextual factors are
ever-changing, leading to varied moving strategies and resulting trajectories.
For example, birds may change their migratory routes as the wind directions
change, since birds prefer to fly with a tailwind (Liechti et al., 1994).
Video game players may change their trajectory when their opponents move to
different places, to implement their counter competition plan.

Given such rich contextual information, AI models usually struggle to maximize
its use to improve prediction accuracy, especially when we lack a large amount
of labeled data recording how the contextual information affects trajectories.
Models based on single components tailored for encoding contextual information
(SC) (Lu et al., 2022; Yu et al., 2021; Lindström et al., 2020) can accurately
learn the impacts of contexts on trajectories. However, such models suffer
from increasingly complex contextual characteristics (Dong et al., 2020).
Models based on ensemble learning (EL) (Li et al., 2022; Jiang et al., 2017;
Zhang et al., 2020) train multiple base learners on manually split sub-
datasets and combine their results by weights, increasing prediction accuracy
in diverse contexts. However, the performance of EL-based models depends
heavily on how to split the dataset and assign weights reasonably, requiring a
high level of domain expertise. Models based on reinforcement learning (RL)
design rewards based on contexts and predict the trajectories that can gain
the highest rewards. However, designing a reward function aligned with the
predicted objects’ individual preferences for moving is challenging.

To tackle these challenges, we propose CATP, a Context-Aware Trajectory
Prediction model. The innovation of CATP lies in the design of the MW
framework, consisting of a Manager model, multiple Worker models, and a
tailored training mechanism. Inspired by the two-part design of GAN
(Goodfellow et al., 2020) but unlike the two opposing parts in GAN, the
manager and the workers are trained with competition symbiosis. We expect each
worker to perform downstream tasks in specific contexts as accurately as
possible (with competition), and the manager to select the most suitable
worker in the given context to achieve high overall performance (with
symbiosis). Taking CATP as an example, multiple workers need to compete with
each other for training data to develop their advantages in predicting
trajectories with specific moving patterns. Meanwhile, the manager selects the
best worker in the given context to perform trajectory prediction.

The MW framework can be further generalized to other tasks with context-
awareness requirements. For example, we can adopt time-series forecasting
models, such as TimesNet (Wu et al., 2022), as the workers to support context-
aware traffic prediction. Each worker can learn the traffic patterns in
certain contexts, and the manager can select the best worker based on
contextual information like time, traffic lights, accidents, and weather
conditions, etc.

We conducted three quantitative experiments to comprehensively evaluate CATP
model and the MW framework. First, we compared CATP with SOTA models on
context-aware trajectory prediction tasks. The results proved that our work
outperformed the SOTA models, especially when the contextual information
became complicated. Second, an ablation study further explored the performance
of CATP under different model settings and training hyperparameters, to guide
on training a robust CATP model. Third, we used sequential models as the
worker and compared MW-based models with SOTA models on context-aware time-
series prediction tasks, which proved the generalizability of the MW
framework.

In summary, the contributions of this work are as follows:

  * •

We propose the novel MW framework and the tailored training mechanism, which
can be generalized to handling different context-aware tasks.

  * •

We implement the proposed framework into context-aware trajectory prediction
and develop the CATP model.

  * •

We conducted two comparative experiments and an ablation study to
comprehensively evaluate the effectiveness of CATP and the generalizability of
the MW framework.

##  2\. Related Work

This work is most relevant to the context-aware prediction of trajectory data,
or more generally, that of sequential data.

SC-based models were end-to-end – from contextual information and past
trajectories to predicted trajectories – with specific components that could
encode the contextual information (Lu et al., 2022; Yu et al., 2021; Fang et
al., 2021; Jin et al., 2022). Such models inherited the strengths and
limitations of end-to-end learning (Glasmachers, 2017). A well-trained model
can accurately know the impacts of contextual information on trajectories.
However, due to a lack of explainability and diagnosability, such models can
be hard to train, especially when the data at both ends are complex.

Compared with these models, CATP simplifies the training process with the two-
part model design. Each worker only learns specific moving patterns, without
interactions with the complicated contextual information. The manager only
selects the most suitable worker in the given context, rather than knowing the
final trajectories. While it may not surpass a well-tuned single context-aware
model in every instance, CATP has a greater potential for achieving optimal
training outcomes.

EL-based models trained multiple basic trajectory prediction models and
applied weights on the prediction results of each model, resulting in a final
prediction (Dong et al., 2020; Li et al., 2022; Jiang et al., 2017; Zhang et
al., 2020; Wang and Tan, 2021). Such models benefited from advanced techniques
in adapting each basic model to a subset of training data (Xu et al., 2022).
However, there still exist two key issues, namely, how to split the dataset to
ensure each basic model is different and how to adjust the weights. Compared
with existing methods, our method can automatically address these two issues
in a data-driven manner.

For dataset partition, Jiang et al. (Jiang et al., 2017) and Lin et al. (Lin
et al., 2019) split the dataset from the spatial and temporal dimensions,
respectively. Instead of splitting the dataset by specific rules constructed
manually, CATP utilizes the manager model to filter the most suitable data
samples for training each worker model.

For model weight adjustment, Li et al. (Li et al., 2022) averaged the
predictions of most models predicting the same direction by plurality voting.
Fazla et al. (Fazla et al., 2022) transferred side information into
constraints on model weights. Le et al. (Le Borgne et al., 2007) continuously
deleted basic models (weight is 0) with high prediction loss and added new
ones (weight is 1) to adapt to the context changes. Instead of combining the
results of every base learner by weights, CATP allocates the most suitable
worker for a specific trajectory prediction task.

RL-based models designed rewards based on contextual information and predicted
the values that could gain the highest rewards (Co-Reyes et al., 2018; Milani
et al., 2023). Thus, the results are quantifiable and thereby interpretable.

The premise of applying such models is that the subject to predict will move
on the optimal path in most cases. For example, most car drivers follow the
best routes provided by navigation APPs, which will be highly rewarded by RL-
based models obviously. However, the subject may not always know which route
is optimal in practice. For example, birds may be disturbed by some
environmental factors and become disoriented during migration. Video game
players may take diverse routes due to the uncertainty caused by not being
able to observe the opponent’s state at all times. In these cases, it is hard
for RL-based methods to determine the reward functions. Compared to RL-based
models, CATP is data-driven – workers learn the real moving patterns in the
dataset, and the manager selects workers based on their performance – without
relying on domain knowledge.

##  3\. Preliminaries

###  3.1. Data Description

Our study mainly considers two types of data, namely, trajectory data and
context data. See the glossary table in Appendix A.

Trajectory Data. A trajectory of a unit $u$ records the locations of $u$ at
certain moments. Given the current time $t$, we denote the past trajectory as
$T^{u}_{t,\Delta t,L}=(loc^{u}_{t-(L-1)\Delta t},loc^{u}_{t-(L-2)\Delta
t},...,loc^{u}_{t})$, where $\Delta t$ stands for the time interval between
two consecutive records, and $L$ is the length of the trajectory. Each
location record $loc^{u}_{i}$ in trajectory $T^{u}_{t,\Delta t,L}$ is a
coordinate (e.g., a 2D one can be $loc^{u}_{i}=(x^{u}_{i},y^{u}_{i})$).
Similarly, we denote the predicted trajectory after $t$ as
$\hat{T}^{u}_{t+L\Delta t,\Delta t,L}=(\hat{loc}^{u}_{t+\Delta
t},\hat{loc}^{u}_{t+2\Delta t},...,\hat{loc}^{u}_{t+L\Delta t})$, where
$\hat{loc}^{u}_{i}$ is the predicted location of $u$ at time $i$.

Context Data. The context data records the latest observed data frames,
denoted $C_{t,\Delta t,L}=\\{df_{t-(L-1)\Delta t},df_{t-(L-2)\Delta
t},...,df_{t}\\}$, where each data frame $df_{t}$ records $N$ contextual data
states (e.g., air pressure) at time $t$, denoted
$df_{t}=\\{ds^{1}_{t},ds^{2}_{t},...,ds^{N}_{t}\\}$. To align different data
states, we normalize each data state $ds^{i}_{t}$ in our datasets based on
their value types.

  * •

Ranged data state is numerical data, of which the value must be in a specific
range $[MIN^{i},MAX^{i}]$ (e.g., the time of day). Thus, we adopt a linear
projection normalization function $(ds^{i}_{t}-MIN^{i})/(MAX^{i}-MIN^{i})$.

  * •

Unlimited data state is also numerical data, of which the value starts from 0
and has no specific upper limit but only a “soft” upper limit $\hat{MAX}^{i}$
(e.g., the wind speed). The data value will fall within $[0,\hat{MAX}^{i}]$ in
most cases (80% in this work). We normalize the unlimited data state by
$tanh(ds^{i}_{t}/\hat{MAX}^{i})$, so that our model can adapt to most changes
in the data state.

  * •

Boolean data state is categorical data with two opposing states (e.g., daytime
or nighttime). We simply use 0 for one state and 1 for the other.

  * •

Enumerated data state is nominal data with discrete values (e.g., the bird
type). In this work, enumerated data states with less than 10 categories are
encoded by one-hot vectors. Others are encoded with shorter embedding vectors
(Mikolov et al., 2013), which are trained along with CATP (see Section CATP),
for the sake of saving memory.

###  3.2. Problem Formulation

Figure 1. A data sample consists of three parts, all in matrix form. The
shapes of $C$, $TX$, and $TY$ are $LC\times(N+\sum(LE^{i}-1))$, $LX\times
2|U|$, and $LY\times 2$, respectively.

The problem can be formulated as, given a set $U$ of $|U|$ units and a target
object $o\in U$, our model attempts to predict the future trajectory of ${o}$
based on the past trajectories of all units in $U$, with the assistance of the
context data observed. Shown as Figure 1, the input consists of two parts,
namely, the observed context data $C=C_{t,\Delta t,LC}$ and a set of the past
trajectories $TX=\\{T^{u}_{t,\Delta t,LX}|u\in U\\}$, where $LC$ and $LX$ are
the number of data frames in context data and the length of past trajectories,
respectively. Note that we also regard the past positions of all units as
important contextual information, so we record them in both $C$ and $TX$.
Given $C$ and $TX$, our model is expected to output the predicted trajectory
of ${o}$ after moment $t$, denoted $\hat{TY}=\hat{T}^{o}_{t+LY\Delta t,\Delta
t,LY}$, where $LY$ is the length of predicted trajectory. The predicted
trajectory $\hat{TY}$ should be as close as possible to the actual trajectory
$TY=T^{o}_{t+LY\Delta t,\Delta t,LY}$.

##  4\. CATP

This section outlines the model structure and training process of CATP, which
is adaptable to models based on the MW framework for other context-aware
tasks.

###  4.1. Modeling

Figure 2. CATP consists of a manager model (layers L1-L4) and multiple worker
models (layers L5-L9). The manager selects the optimal worker in a given
context $C$, and the selected worker predicts $\hat{TY}$ based on $TX$
accurately.

CATP consists of a manager model $M$ and $K$ worker models from $W_{1}$ to
$W_{K}$, shown as Figure 2. First, $M$ predicts the probability that each
worker can accurately predict the trajectory in the context $C$. Then, the
worker with the highest probability will be selected to predict $\hat{TY}$
based on $TX$.

####  4.1.1. Manager model

The manager model performs a $K$ classification task, mapping the context data
$C$ to one of the $K$ workers. Shown as Figure 2, the manager model is built
based on the well-known Transformer model (Vaswani et al., 2017; Han et al.,
2021), with sinusoidal positional embedding (L1) and 12 Transformer encoders
(L2) by default. There exist two customized parts as follows. First, the
embedding layer (L1) also encodes the enumerated data state in each $df_{t}$.
Second, following the works using Transformer for classification tasks (Chen
et al., 2021; Zhang et al., 2021), we add a Global Average Pooling layer (L3)
and a Softmax layer (L4) to output a probability distribution over $K$
classes.

####  4.1.2. Worker model

The selected worker model predicts $\hat{TY}$ based on $TX$, shown as Figure
2. Our MW framework can accommodate any sequential prediction model as the
worker model. CATP selects the Transformer model due to its excellent
performance and widespread adoption across various domains (Han et al., 2021;
Ren et al., 2021). The model uses sinusoidal positional embedding (L5 and L7),
12 Transformer encoders (L6) learning the moving patterns in $TX$, and 12
decoders (L8) predicting the displacement at each $\Delta t$ duration by
default. The displacement between $t+(i-1)\Delta t$ and $t+i\Delta t$, denoted
$\hat{dis}_{i}$, is predicted based on the start location $loc^{o}_{t}$ and
previous predicted trajectory from $\hat{loc}^{o}_{t+\Delta t}$ to
$\hat{loc}^{o}_{t+(i-1)\Delta t}$. To ensure the predicted trajectory is
reasonable, we add a constraint layer (L9) to limit the Euclidean distance
$||\hat{dis}_{i}||_{2}$ not to exceed the maximum moving speed $MaxMS$:

(1) $\displaystyle scale={}$ $\displaystyle
Sigmoid(||\hat{dis}_{i}||_{2})\times MaxMS~{}/~{}||\hat{dis}_{i}||_{2},$
$\displaystyle\hat{loc}^{o}_{t+i\Delta t}={}$
$\displaystyle\hat{loc}^{o}_{t+(i-1)\Delta t}+scale\times\hat{dis}_{i}.$

###  4.2. Training Mechanism

We propose an iterative training algorithm to train the manager and workers
with competition symbiosis, shown as Figure 3 and Algorithm 1. The competition
is reflected in that the workers need to compete with each other to be
selected by the manager and gain more training data for advancement. The
symbiosis is reflected in that we use the results of the manager and workers
to enhance each other to improve the overall performance of CATP. The main
training process and some details are as follows.

####  4.2.1. Main training process

At each iteration, we first train the workers, shown as the black and orange
arrows in Figure 3 and lines 4-15 in Algorithm 1. For each data sample, the
manager firstly predicts a probability $\hat{P}$ in context $C$ (arrow
\raisebox{-0.9pt}{1}⃝). Then, only the worker $W_{i}$ with the highest
probability is trained (arrow \raisebox{-0.9pt}{2}⃝), to predict $\hat{TY}$
based on $TX$ (arrow \raisebox{-0.9pt}{3}⃝), with $TY$ as target. We expect to
train each worker with data samples in specific contexts so that different
workers can master the moving patterns in different contexts.

Figure 3. The proposed training mechanism. We first train workers based on the
manager’s results and then train the manager based on workers’ performance.
Algorithm 1 The iterative training process.

Input: training dataset $D$, the number of workers $K$, the number of steps
for training manager $T$, and batch size $b$
Output: a manager and $K$ workers

1: $M=ManagerModel(K)$

2: $W_{1},...,W_{K}=WorkerModel()\times K$

3: for number of training iterations do

4: // Fix the manager and train the workers

5: for $\alpha$ steps do

6: $S=sample\\_batch(D,b)$

7: $c,tx,ty=parse(S)$

8: $\hat{P}=M(c)$

9: for each worker $W_{i}$ do

10: $sub\\_batch=[]$

11: for each sample $s_{j}$ in $S$ do

12: if $\hat{P}[j][i]==max(\hat{P}[j])$ then

13: $sub\\_batch.append(s_{j})$

14: train $W_{i}$ with trajectories in $sub\\_batch$

15: $V_{i}+=|sub\\_batch|$

16: // Fix the workers and train the manager

17: $S=sample\\_batch(D,b)$

18: $c,tx,ty=parse(S)$

19: for each worker $W_{i}$ do

20: $L^{W}_{i}=ADE(W_{i}(tx),ty)$

21: $model\\_loss=Regularize(L^{W},V)$

22: train $M$ with $model\\_loss$

23: return $M,W_{1},...,W_{K}$

Then, we train the manager (the black and blue arrows in Figure 3 and lines
16-22 in Algorithm 1) to predict the probability distribution $\hat{P}$ based
on $C$ (arrow \raisebox{-0.9pt}{1}⃝). The key issue is to find the target
probability distribution $P$ because there exists no ground truth. A basic
idea is that the worker with a low prediction loss should have a high
probability of being selected. Thus, we use each worker to predict the
trajectories (arrow \raisebox{-0.9pt}{3}⃝) and obtain the prediction loss
$L^{W}_{I}$ of each model $W_{i}$ (arrows
\raisebox{-0.9pt}{4}⃝-\raisebox{-0.9pt}{5}⃝). Based on each worker’s loss, we
can construct the simplest target probability distribution $P$ as a candidate:

(2) $\displaystyle MaxL$ $\displaystyle=\max_{1\leq i\leq K}L^{W}_{i},$
$\displaystyle P$ $\displaystyle=Softmax(\frac{MaxL}{L^{W}}).$

Detail #1: training order. We train the manager after the workers because the
manager needs to learn about the workers’ performance. At the beginning of
training, when the workers can hardly predict the trajectory, training the
manager is meaningless.

Detail #2: training regularization. A key of training CATP is to balance the
training of each worker. In a bad competition, as long as a worker $W_{i}$
performs better than other workers, whether accurate or not, the manager tends
to select it and assign more data samples to train $W_{i}$ at the next
iteration. In contrast, other workers, unable to improve due to lack of
training data, are more difficult to be selected by the manager in the future.
Finally, only one dominant worker is well trained and selected, resulting in a
lack of model diversity and context data becoming useless.

Monte-Carlo Tree Search (Browne et al., 2012) (MCTS) faces a similar issue –
whether to select the node with the highest winning rate or the ones without
sufficient exploration. Inspired by MCTS, we add a training regularization
term (arrow \raisebox{-0.9pt}{6}⃝, line 21, Equation 3) to consider the
training volume $V_{i}$ – the number of data samples used to train each worker
model $W_{i}$ (line 15):

(3) $\displaystyle MaxV$ $\displaystyle=\max_{1\leq i\leq K}V_{i},$
$\displaystyle P$
$\displaystyle=Softmax(e^{-\frac{L^{W}}{MaxL}}+\beta\times\frac{MaxV-V}{MaxV}),$

where $e^{-L^{W}/MaxL}$ is the new loss term (TNewLoss), different from the
one $MaxL/L^{W}$ in Equation 2 (TOriginLoss), and $(MaxV-V)/MaxV$ is the
regularization term (TReg).

For the regularization term, we expect it to be large at the beginning – so
that each worker is sufficiently trained – and small at the end – so that the
manager can accurately learn the workers’ performance. TReg satisfies our
expectation because $MaxV$ usually increases faster than $MaxV-V$, making TReg
become small. Parameter $\beta$ can also control the weight of TReg.

For the loss term, we change TOriginLoss to TNewLoss, since TReg ranges from 0
to 1, but TOriginLoss ranges from 1 to infinity, which may overshadow the
impact of TReg on $\hat{P}$. In contrast, TNewLoss has a similar range ($1/e$
to 1) to TReg, ensuring both terms can affect $\hat{P}$.

Detail #3: batch training. Figure 3 demonstrates how we train CATP with only
one data sample, which may be easy to understand but not efficient. Actually,
our algorithm supports batch training, shown as lines 5-15 in Algorithm 1. The
key is that, given a batch of data samples, we split the batch into $K$ sub-
batches. For the $i$-th sub-batch, we require that worker $W_{i}$ has the
lowest loss on each data sample. We further train each worker $W_{i}$ on the
$i$-th sub-batch so that it better predicts trajectories occurring in the sub-
batch. To ensure the workers are adequately trained, we repeatedly train the
workers $\alpha$ times (line 5) at each iteration.

Detail #4: loss function selection. For workers, there exist two widely used
measures for evaluating the predicted trajectory, namely, the Average
Displacement Error (ADE, Equation 4) and the Final Displacement Error (FDE,
Equation 5). ADE computes the average L2 distance of all pairs of predicted
and ground truth locations, while FDE computes the L2 distance of the final
pair of locations. In this paper, we adopt ADE as the default loss function
and denote the ADE loss of $W_{i}$ as $L^{W}_{i}$.

(4) $\displaystyle ADE(TY,\hat{TY})$
$\displaystyle=\frac{\sum_{i=1}^{LY}\parallel\hat{loc}_{t+i\Delta
t}-loc_{t+i\Delta t}\parallel_{2}}{LY}$ (5) $\displaystyle FDE(TY,\hat{TY})$
$\displaystyle=\parallel\hat{loc}_{t+LY\Delta t}-loc_{t+LY\Delta
t}\parallel_{2}$

For the manager, we adopt Wasserstein distance (Arjovsky et al., 2017)
(Equation 6) to compute the loss of $\hat{P}$ from $P$. Compared to KL
divergence and JS divergence, Wasserstein distance is continuous and
differentiable, which can provide a linear gradient and prevent collapse mode.

(6) $\mathbb{W}(\hat{P},P)=\sup_{\parallel f\parallel_{L}\leq
1}\mathbb{E}_{x\sim\hat{P}}[f(x)]-\mathbb{E}_{x\sim P}[f(x)],$

where $f(x)$ is required to be a 1-Lipschitz continuous function that
satisfies $|f(x_{1})-f(x_{2})\leq|x_{1}-x_{2}|$, smoothing the loss function.

###  4.3. Full Objective

Our full objective is to minimize the prediction loss of the selected worker.
However, the most selected trajectory may not be necessarily selected in a
specific case. Thus, we propose top-$k$ loss – the minimum prediction loss of
$k$ workers with the highest probability. When using top-$k$ loss, our full
objective is:

(7) $\text{minimize~{}}\min_{1\leq i\leq k}ADE(TY,W_{top_{i}}(TX)),$

where $top_{i}$ is the index number of the worker model with the $i$-th
highest probability.

##  5\. Evaluation

We implemented CATP111Code for anonymous review:
https://anonymous.4open.science/r/CATP-0710 and tested its performance by
three quantitative experiments. Every model in our experiments was trained in
three days on a server with an NVIDIA GeForce RTX 3090 Graphics Card (24 GB)
using CUDA and PyTorch (Paszke et al., 2019). For each experiment, we
performed a 10-round evaluation for each model over each dataset to compare
model performance fairly (recorded in Appendix C). At each round, we re-
sampled the dataset and re-trained the model.

###  5.1. Comparative Experiment I

In this experiment, we compared CATP with five context-aware trajectory
prediction models over three datasets, to prove that CATP outperformed the
SOTA context-aware trajectory prediction models. The experimental setup and
results are shown as follows.

####  5.1.1. Datasets

We prepared three datasets, listed in Table 1. For each dataset, we put 80%,
10%, and 10% of data samples in the training, validation, and test set,
respectively.

  * •

DOTA is a dataset built on 1094 public DOTA 2 games on (OpenDOTA, 2023), which
records players’ trajectories and 273 contextual data status (e.g., the
opponents’ positions). We chose this dataset because the abundant contextual
information helped us understand the capabilities and limitations of CATP.
Since the virtual game has complex mechanisms, we designed tailored data
sampling rules to obtain data samples with good quality. For example, we set
$LC=5$ (smaller than $LX$) because it may be difficult to learn the effects of
excessive contextual information on trajectories. Details about the game and
the dataset can be found in Appendix B).

  * •

Bird-8 is based on an open bird migration dataset (Kranstauber et al., 2022),
which records the birds’ migratory trajectories in a geographic coordinate
system (leading the model loss to be calculated by spherical distance) and
many contextual data states, from 2008 to 2019. We randomly sampled 7,000
trajectories and preserved eight contextual data states most relevant to
trajectory prediction in Bird-8, e.g., the air temperature and the wind speed
(see Appendix B).

  * •

Bird-2 and Bird-8 are nearly identical, with only two contextual data states
(i.e., the timestamp and the season). We set up this dataset to test our
hypothesis that fewer contextual data states led to higher prediction loss.

Table 1. Trajectory datasets used in Section 5.1. $|S|$ is the number of data samples. Datasets | $|S|$ | $|U|$ | $N$ | $\Delta t$ | $LC/LX/LY$ | $MaxMS$
---|---|---|---|---|---|---
DOTA | $10^{5}$ | 10 | 273 | 0.5s | 5 / 30 / 10 | 275
Bird-8 | 7,000 | 1 | 8 | 300s | 30 / 30 / 10 | 4km
Bird-2 | 7,000 | 1 | 2 | 300s | 30 / 30 / 10 | 4km

####  5.1.2. Models

We compared four CATP variants with five baselines, including three SOTA ones.

Baselines. The five baselines are listed as follows.

  * •

LSTM (vanilla LSTM). We concatenated $TX$ and $C$ at each time step and input
the combined sequences into a model consisting of two LSTM layers with 128
units.

  * •

Trans (vanilla Transformer). We adopted a model consisting of six transformer
encoder layers and six transformer decoder layers, of which the embedding size
was 128 and the input was the same as that for LSTM.

  * •

DATF (Park et al., 2020) is a SOTA single context-aware trajectory prediction
model, which is capable of encoding multimodal contextual information and
accepts both $C$ and $TX$ as input.

  * •

Tjf (Trajformer (Bhat et al., 2020)) is also a SOTA trajectory prediction
model, which focuses on handling multiple agents’ trajectories. Thus, Tjf
accepts only $TX$ as input, which can be regarded as an advanced alternative
to our worker model.

  * •

IETP (Li et al., 2022) is a SOTA EL-based method for context-aware trajectory
prediction. We set its base learners as CATP’s worker model, to compare the
mechanism of CATP (selecting the best worker) with that of EL (combining the
results of all base learners). We reported the performance of IETP with 10
base learners (IETP-10) and 20 ones (IETP-20).

Our model. We reported the performance of four CATP variants, varying in the
number of workers (CATP-10 or CATP-20) and whether to use Tjf as the worker
(with or without Tjf suffixes). Detailed settings about CATP variants can be
found in Section 5.2.

In order to ensure that all models were compared fairly, we added the same
preprocessing layer (the enumerated data states embedding in our manager
model) and post-process layer (the constraint layer in our worker model) to
every model and trained them with a batch size of 64. The number of epochs was
30 with proper early stopping.

####  5.1.3. Results

We reported the top-1 ADE loss (MEAN) and the standard deviation (SD) in Table
2, which are analyzed as follows.

CATP outperformed baselines especially when the context was complex.
CATP-20-Tjf and CATP-10 are clearly the winners on DOTA and Bird-8,
respectively, where contextual information is richer. In contrast, DATF
performed the best on Bird-2, but CATP-10 and CATP-10-Tjf was just slightly
behind.

Table 2. Results of Comparative Experiments I. We compared CATP with four baselines using the ADE loss ($mean\pm sd$). Model | Dataset
---|---
DOTA |  Bird-8/km |  Bird-2/km
LSTM | 1279 | $\pm$ | 199 | 21.22 | $\pm$ | 3.06 | 23.41 | $\pm$ | 4.63
Trans | 1227 | $\pm$ | 128 | 20.68 | $\pm$ | 2.76 | 24.42 | $\pm$ | 2.10
Tjf | 969 | $\pm$ | 100 | 19.43 | $\pm$ | 1.95 | 19.43 | $\pm$ | 1.95
DATF | 811 | $\pm$ | 116 | 15.90 | $\pm$ | 0.89 | 16.64 | $\pm$ | 0.86
IETP-10 | 625 | $\pm$ | 120 | 16.44 | $\pm$ | 0.81 | 20.27 | $\pm$ | 1.44
IETP-20 | 556 | $\pm$ | 49 | 13.78 | $\pm$ | 1.12 | 17.77 | $\pm$ | 1.64
CATP-10 | 563 | $\pm$ | 80 | 11.94 | $\pm$ | 0.45 | 17.74 | $\pm$ | 2.83
CATP-20 | 426 | $\pm$ | 33 | 17.08 | $\pm$ | 1.41 | 23.31 | $\pm$ | 2.58
CATP-10-Tjf | 538 | $\pm$ | 59 | 11.94 | $\pm$ | 1.01 | 17.26 | $\pm$ | 2.40
CATP-20-Tjf | 423 | $\pm$ | 39 | 18.35 | $\pm$ | 1.80 | 21.22 | $\pm$ | 3.36

Contextual information is crucial to trajectory prediction. On all datasets,
LSTM, Trans (which might underuse the contextual information), and Tjf
(without $C$ as input) had high ADE losses. Meanwhile, when predicting the
bird migration trajectories, most models performed better on Bird-8 than on
Bird-2, which meant that the contextual information facilitated trajectory
prediction.

Models with multiple base learners (CATP and IETP) tended to outperform single
context-aware models (DATF) when context was complex. DATF performed the best
on Bird-2, while CATP-10 and IETP-20 outperformed DATF on others. These
results suggested that a single model might struggle to learn an effective
representation of complex contextual information and understand how it
affected trajectories.

Models with competition symbiosis (CATP) usually outperformed traditional EL-
based models (IETP). CATP models had a lower ADE loss than IETP on DOTA and
Bird-8, respectively. On Bird-2, CATP-10 achieved a similar accuracy as IETP.
This indicated that the competition symbiosis enhanced CATP’s performance in
diverse contexts.

CATP can empower models to be context-aware. The two transformer-based CATP
models and the two with Tjf suffixes outperformed Trans and Tjf, respectively.
It proved that CATP could significantly improve the performance of models
without context-aware designs, even SOTA ones, by automatically splitting the
dataset for each worker based on contextual information.

More comparison among multiple CATP variants can be found in Section 5.2,
where we answered why CATP-10 performed better than CATP-20 on Bird dataset
and how Tjf affected CATP’s performance as a worker.

###  5.2. Ablation Study

Table 3. Results of ablation study. There existed two control groups (CATP-10 and CATP-20) and seven experimental groups (from A to G), varying in the number of worker models ($K$), whether to train with competition symbiosis (CSTrain), training parameters ($\alpha$ and $\beta$), the regularization function (Reg.), the loss functions (LossM and LossW), and the worker models (Worker). The empty cells were filled with the same settings of CATP-20. These model variations were evaluated by the top-1/top-3 ADE loss ($MEAN\pm SD$) and manager accuracy (MngAcc, whether the top 3 workers had the lowest loss among all workers).  Group | $K$ | CSTrain | $\alpha$ | $\beta$ | Reg. | LossM | LossW | Worker | Top-1 ADE | Top-3 ADE | MngAcc
---|---|---|---|---|---|---|---|---|---|---|---
CATP-20 | 20 | ✓ | 100 | 0.1 | Eq. 3 | Wasserstein | ADE | Transformer-based | 426 | $\pm$ | 33 | 375 | $\pm$ | 28 | 81% |
CATP-10 | 10 | ✓ | 50 |  |  |  |  |  | 564 | $\pm$ | 81 | 483 | $\pm$ | 65 | 83% |
A | 1 |  | 5 |  |  |  |  |  | 1228 | $\pm$ | 129 |  | / |  | 100% | $\curlywedge$
30 |  | 150 |  |  |  |  |  | 453 | $\pm$ | 28 | 392 | $\pm$ | 25 | 75% |
B |  | ✗ |  |  |  |  |  |  | 1104 | $\pm$ | 106 | 1029 | $\pm$ | 91 | 8% | $\thickapprox$
C |  |  | 1 |  |  |  |  |  | 983 | $\pm$ | 82 | 910 | $\pm$ | 77 | 10% | $\thickapprox$
|  | 500 |  |  |  |  |  | 554 | $\pm$ | 47 | 521 | $\pm$ | 40 | 86% |
D |  |  |  | 0 |  |  |  |  | 1054 | $\pm$ | 91 | 958 | $\pm$ | 83 | 93% | $\curlywedge$
|  |  | 1 |  |  |  |  | 879 | $\pm$ | 72 | 844 | $\pm$ | 67 | 12% | $\thickapprox$
E |  |  |  |  | Eq. 2 |  |  |  | 941 | $\pm$ | 124 | 883 | $\pm$ | 105 | 98% | $\curlywedge$
|  |  |  | Eq. 8 |  |  |  | 793 | $\pm$ | 110 | 714 | $\pm$ | 96 | 94% | $\curlywedge$
F |  |  |  |  |  | Cross Entropy |  |  | 603 | $\pm$ | 53 | 539 | $\pm$ | 48 | 62% |
|  |  |  |  |  | FDE |  | 502 | $\pm$ | 47 | 474 | $\pm$ | 39 | 77% |
G |  |  |  |  |  |  |  | Trajformer (Bhat et al., 2020) | 423 | $\pm$ | 39 | 362 | $\pm$ | 23 | 83% |

We conducted this study to better know the impacts of each key hyperparameter
on CATP’s performance, thereby guiding how to build and train a robust CATP
model.

####  5.2.1. Training Traps

Before analyzing the detailed results of each experimental group, we prefer to
introduce two common training traps of CATP that occurred in many experimental
groups. When CATP falls into these two traps, the manager model cannot work
properly, leading the whole model to almost degenerate into a vanilla
Transformer model.

  1. T1

One dominant worker was used in all contexts, marked by $\curlywedge$ in Table
3. When the regularization term had little effect on the training process, the
manager tended to only select the worker with the lowest ADE loss and train it
only, using it in all contexts. In this case, the manager’s accuracy is higher
than 90%.

  2. T2

All workers were trained equally, marked by $\thickapprox$ in Table 3. When
the regularization term had an overweight effect on the training process, the
manager tended to train each worker equally. Therefore, each worker could not
learn unique moving patterns, and the manager could not know the suitable
context for each worker, leading the manager’s accuracy to be lower than 20%.

The manager’s selection indicates what happened during the training process,
helping model developers fine-tune the hyper-parameters. For example, when the
manager always selects the same worker, we can enhance the weight of the
regularization term.

####  5.2.2. Results

After knowing the two training traps above, we elaborated the analysis of each
experimental group as follows.

Group A: a large $K$ did not always result in lower prediction losses. We
changed $K$ and $\alpha$ correspondingly so that the number of data samples
used to train each worker remains roughly the same. Due to the training
regularization term, the manager model tends to use all worker models.
However, when the number of worker models is small, one worker needs to learn
many moving patterns, leading to high losses. When the number of worker models
is large, many workers learn similar moving patterns and compete for the same
training data, resulting in insufficient training data.

Group B: competition symbiosis helps improve model performance. We compared
training algorithms with and without competition symbiosis (CSTrain) to
examine its effects. For the one without CSTrain, we split the dataset
randomly into $K$ subsets, each for one worker. After all the workers finished
training, we trained the manager model based on the workers’ performance.
Without CSTrain, the workers were trained equally, leading CATP to fall into
Trap T2.

Group C: $\alpha$ should be fine-tuned during training. When $\alpha=1$, each
worker obtained insufficient training data at each iteration and could not
quickly converge at the beginning of training. Meanwhile, since every worker
has a large loss, the manager model mainly relied on the regularization term,
falling into Trap T2. A large $\alpha$ makes workers converge quickly but
eventually causes them to overfit. It is better to start with a large $\alpha$
and keep reducing it.

Group D: $\beta$ is crucial for avoiding the two traps. When $\beta$ was zero,
the manager model completely relies on the loss, falling into Trap T1. In
contrast, when $\beta$ was one, the manager model relied more on the training
counts, falling into Trap T2.

Group E: appropriate regularization functions help avoid Trap T1. We tested
two more regularization functions. One was Equation 2, which had no training
regularization term. The other was Equation 8, which directly added a
regularization term to Equation 2, without normalizing the loss term into
$[0,1]$. Both of these two regularization functions led CATP to fall into Trap
T1.

(8) $P=Softmax(\frac{MaxL}{L^{W}}+\beta\times\frac{MaxV-V}{MaxV})$

Group F: loss functions affect model accuracy. We tested cross entropy and FDE
as the loss functions for training the manager model and worker models,
respectively. Cross entropy underperformed Wasserstein loss, probably because
Wasserstein loss allows the manager to converge quickly and consistently. FDE
loss undoubtedly caused a higher ADE loss, but also a lower manager accuracy,
probably because two moving strategies with the same destination, but
different trajectories were regarded as the same. Thus, many workers had to
learn similar moving patterns, similar to the issue when setting $K$ to 30 in
Group A.

Group G: CATP supports continuous performance improvement with SOTA model
integration. We replaced each worker model with Tjf and observed lower losses
and a higher manager accuracy. It proved that workers’ better performance can
benefit the training of the manager and the overall performance.

###  5.3. Comparative Experiment II

This experiment was conducted to prove the generalizability of the MW
framework. We adopted time-series prediction models as the workers to conduct
context-aware time-series prediction tasks. The experimental setup and results
are as follows.

####  5.3.1. Datasets

We tested our model on two open datasets, listed as follows and in Table 4.

  * •

SP222Solar Power: https://www.nrel.gov/grid/solar-power-data.html is a dataset
recording solar power data in 2006, with six contextual variables. We trained
the models using the data in California and New York to ensure different
changing patterns.

  * •

ET333ET: https://github.com/zhouhaoyi/ETDataset is a dataset used as a
benchmark by many recent models. We trained the models on the subset named
“ETT-h1” because of its rich contextual information. We set oil temperature
(OT) as the target channel and used the other eight channels as the contexts.

To obtain sufficient data samples, we used different lengths of stride and
time windows for data sampling, depending on the total length of the time
series. The data sampling proportions in the training, validation, and test
sets are 80%, 10%, and 10% respectively.

Table 4. Two time-series datasets used in Section 5.3. We obtained $|S|$ data samples from $Num$ original temporal sequences with length $Len$, at a certain Stride. Datasets |  $Len$ $\times$ $Num$ | Stride | |S| | $N$ | $LC/LX/LY$
---|---|---|---|---|---
SP | 105,120 $\times$ 2 | 12 | 17,490 | 5 | 96/96/96
ET | 17,420 $\times$ 1 | 10 | 1,731 | 8 | 60/60/60

####  5.3.2. Models

We compared three CATP variants with six time-series prediction models,
including four SOTA ones. All these models were trained with a batch size of
32. The number of epochs was set to 8 with proper early stopping.

Baselines. The first two baselines were LSTM and Trans, which were also used
in Comparative Experiment I. We also selected four SOTA models – Informer
(Zhou et al., 2021), Autoformer (Wu et al., 2021), FEDFormer (Zhou et al.,
2022), and TimesNet (Wu et al., 2022). Since these baselines have no
components for contextual channels, we concatenated the contextual channels
and the target channel to construct multivariate time-series data as the input
of these baseline models. Based on such considerations, we did not select
models designed to handle univariate time-series data as our baselines (e.g.,
ARIMA (Ariyo et al., 2014) and DeepAR (Salinas et al., 2020)).

Our model. We replaced the workers with time-series prediction models, namely,
LSTM, Trans, and TimesNet, and built MW-LSTM, MW-Trans, and MW-TN,
respectively. In contrast to the baselines, we used the contextual channels
and the to-be-predicted channel as the input of manager and workers,
respectively, so that we can highlight the capabilities and limitations of the
MW framework. Considering the complexity of each dataset, we set the number of
workers to 10, 20, and 15 for MSL, SP, and ET, respectively. Other
hyperparameters were set to the optimal values tested in our Ablation Study
(Section 5.2).

####  5.3.3. Results

We reported the top-1 MSE loss
($MSE=\frac{1}{n}\sum^{n}_{i=1}(y-\bar{y})^{2}$) in Table 5, which proved that
the MW framework could be applied to other context-aware tasks. Here are
detailed analysis. 1) The MW framework could significantly improve the
performance of simple models. MW-LSTM and MW-Trans ourperformed LSTM and Trans
and achieved a similar accuracy as Informer. 2) The MW framework and SOTA
models were mutually beneficial. MW-TN achieved better performance than both
TimesNet and other MW-based models. The framework provided a better training
set for SOTA models, while SOTA models enhanced the performance of the model
as a whole.

Table 5. Results of Comparative Experiment II. We compared our model with six baselines using the MSE loss (MEAN $\pm$ SD). Model | Dataset
---|---
SP | ET
LSTM | 5.69 | $\pm$ | 0.54 | 1.40 | $\pm$ | 0.12
Trans | 5.57 | $\pm$ | 0.63 | 1.23 | $\pm$ | 0.13
Informer | 4.81 | $\pm$ | 0.81 | 1.04 | $\pm$ | 0.12
Autoformer | 3.16 | $\pm$ | 0.31 | 0.50 | $\pm$ | 0.05
FEDFormer | 3.16 | $\pm$ | 0.32 | 0.46 | $\pm$ | 0.05
TimesNet | 2.93 | $\pm$ | 0.23 | 0.47 | $\pm$ | 0.05
MW-LSTM | 4.86 | $\pm$ | 0.39 | 0.99 | $\pm$ | 0.10
MW-Trans | 4.74 | $\pm$ | 0.56 | 1.00 | $\pm$ | 0.11
MW-TN | 2.86 | $\pm$ | 0.13 | 0.45 | $\pm$ | 0.04

##  6\. Discussion

Generalizability. Although CATP mainly focuses on trajectory prediction, the
MW framework – the core contributions of our research – can be generalized to
many context-aware tasks. The MW framework essentially provides a data-driven
method to automatically split the training dataset based on contextual factors
and workers’ performances. Such a method uses the manager model to perceive
contextual information and allows the replaceable workers to focus only on
downstream tasks. Meanwhile, using SOTA models as the worker could enhance the
overall model performance, resulting in continuous improvement on CATP as the
SOTA models evolve.

Why the MW framework. Increasingly dynamic and complex contextual information
results in inefficiencies for a single model to fully leverage such
information. As outlined in our Introduction and Related Work sections,
ensemble methods are outperforming single-model approaches. The main challenge
with ensemble methods is the considerable effort and expertise required to
partition training samples so that the “workers” can effectively learn the
intended knowledge. Our solution automates this process, enabling the
“manager” to allocate the most appropriate training data to each worker and
harness the potential of existing sequential models. The experimental results
confirm our design’s efficacy.

Limitations and future works. The number of worker models is highly dependent
on the variety of trajectories to predict in different contexts. We usually
need to fine-tune this hyperparameter and re-train the whole model when the
trajectory patterns change (e.g., when applying to a new application). In the
future, we plan to study how to automatically and progressively fine-tune the
number of workers. One possible solution is to allow the manager to retire
underperforming workers and bring in new ones during training. It is also a
promising solution to use some pre-trained models as the workers and allow the
manager to fine-tune them quickly.

##  7\. Conclusion

We introduced a context-aware trajectory prediction model, which could
effectively use complex contextual information to improve prediction accuracy.
Similar to the GAN networks, our proposed model consisted of several worker
models for predicting trajectory and a manager model for selecting the best
worker model in the given context. We further proposed a training mechanism
with competition symbiosis, where the results of the manager and the workers
could be used to train each other, and the workers with lower prediction
losses can gain more training data to perform better in specific contexts. We
conducted two comparative experiments to evaluate the performance and
generalizability of CATP, where CATP effectively improved the prediction
accuracy of both trajectory and time-series data, especially when the context
data is complex. An ablation study further evaluated the performance of
several model variations and provided guidance on how to train a robust CATP
model.

## References

  * (1)
  * Ariyo et al. (2014) Adebiyi A. Ariyo, Adewumi O. Adewumi, and Charles K. Ayo. 2014.  Stock Price Prediction Using the ARIMA Model. In _2014 UKSim-AMSS 16th International Conference on Computer Modelling and Simulation_. 106–112.  https://doi.org/10.1109/UKSim.2014.67
  * Arjovsky et al. (2017) Martin Arjovsky, Soumith Chintala, and Léon Bottou. 2017\.  Wasserstein Generative Adversarial Networks. In _Proceedings of the 34th International Conference on Machine Learning_ , Vol. 70. PMLR, 214–223.  https://proceedings.mlr.press/v70/arjovsky17a.html
  * Bartoli et al. (2018) Federico Bartoli, Giuseppe Lisanti, Lamberto Ballan, and Alberto Del Bimbo. 2018.  Context-Aware Trajectory Prediction. In _24th International Conference on Pattern Recognition (ICPR)_. 1941–1946.  https://doi.org/10.1109/ICPR.2018.8545447
  * Bhat et al. (2020) Manoj Bhat, Jonathan Francis, and Jean Oh. 2020.  Trajformer: Trajectory Prediction with Local Self-Attentive Contexts for Autonomous Driving.  https://doi.org/10.48550/arXiv.2011.14910 arXiv:2011.14910 [cs.CV]
  * Browne et al. (2012) Cameron B. Browne, Edward Powley, Daniel Whitehouse, Simon M. Lucas, Peter I. Cowling, Philipp Rohlfshagen, Stephen Tavener, Diego Perez, Spyridon Samothrakis, and Simon Colton. 2012.  A Survey of Monte Carlo Tree Search Methods.  _IEEE Transactions on Computational Intelligence and AI in Games_ 4, 1 (2012), 1–43.  https://doi.org/10.1109/TCIAIG.2012.2186810
  * Chen et al. (2021) Chun-Fu Richard Chen, Quanfu Fan, and Rameswar Panda. 2021\.  CrossViT: Cross-Attention Multi-Scale Vision Transformer for Image Classification. In _IEEE/CVF International Conference on Computer Vision (ICCV)_. 347–356.  https://doi.org/10.1109/ICCV48922.2021.00041
  * Co-Reyes et al. (2018) John Co-Reyes, YuXuan Liu, Abhishek Gupta, Benjamin Eysenbach, Pieter Abbeel, and Sergey Levine. 2018\.  Self-consistent trajectory autoencoder: Hierarchical reinforcement learning with trajectory embeddings. In _International conference on machine learning_. PMLR, 1009–1018.  https://doi.org/10.48550/arXiv.1806.02813
  * Dong et al. (2020) Xibin Dong, Zhiwen Yu, Wenming Cao, Yifan Shi, and Qianli Ma. 2020.  A survey on ensemble learning.  _Frontiers of Computer Science_ 14 (2020), 241–258.  https://doi.org/10.1007/s11704-019-8208-z
  * Fang et al. (2021) Ziquan Fang, Lu Pan, Lu Chen, Yuntao Du, and Yunjun Gao. 2021.  MDTP: A Multi-Source Deep Traffic Prediction Framework over Spatio-Temporal Trajectory Data.  _Proc. VLDB Endow._ 14, 8 (apr 2021), 1289–1297.  https://doi.org/10.14778/3457390.3457394
  * Fazla et al. (2022) Arda Fazla, Mustafa Enes Aydin, Orhun Tamyigit, and Suleyman Serdar Kozat. 2022.  Context-Aware Ensemble Learning for Time Series.  https://doi.org/10.48550/arXiv.2211.16884
  * Glasmachers (2017) Tobias Glasmachers. 2017\.  Limits of end-to-end learning. In _Asian conference on machine learning_. PMLR, 17–32.  https://doi.org/10.48550/arXiv.1704.08305
  * Goodfellow et al. (2020) Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. 2020\.  Generative Adversarial Networks.  _Commun. ACM_ 63, 11 (2020), 139–144.  https://doi.org/10.1145/3422622
  * Han et al. (2021) Kai Han, An Xiao, Enhua Wu, Jianyuan Guo, Chunjing XU, and Yunhe Wang. 2021\.  Transformer in Transformer.  34 (2021), 15908–15919.  https://proceedings.neurips.cc/paper_files/paper/2021/file/854d9fca60b4bd07f9bb215d59ef5561-Paper.pdf
  * Jiang et al. (2017) Zhe Jiang, Yan Li, Shashi Shekhar, Lian Rampi, and Joseph Knight. 2017.  Spatial Ensemble Learning for Heterogeneous Geographic Data with Class Ambiguity: A Summary of Results. In _Proceedings of the 25th ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems_. Association for Computing Machinery, Article 23\.  https://doi.org/10.1145/3139958.3140044
  * Jin et al. (2022) Yilun Jin, Kai Chen, and Qiang Yang. 2022.  Selective Cross-City Transfer Learning for Traffic Prediction via Source City Region Re-Weighting. In _Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining_. Association for Computing Machinery, 731–741.  https://doi.org/10.1145/3534678.3539250
  * Kranstauber et al. (2022) B. Kranstauber, Hans van Gasteren, W. Bouten, and J.Z. Shamoun. 2022.  Dataset for predictive bird migration model.  (5 2022).  https://doi.org/10.21942/uva.19416215.v1
  * Le Borgne et al. (2007) Yann-Aël Le Borgne, Silvia Santini, and Gianluca Bontempi. 2007\.  Adaptive model selection for time series prediction in wireless sensor networks.  _Signal Processing_ 87, 12 (2007), 3010–3020.  https://doi.org/10.1016/j.sigpro.2007.05.015 Special Section: Information Processing and Data Management in Wireless Sensor Networks.
  * Li et al. (2022) Zirui Li, Yunlong Lin, Cheng Gong, Xinwei Wang, Qi Liu, Jianwei Gong, and Chao Lu. 2022.  An Ensemble Learning Framework for Vehicle Trajectory Prediction in Interactive Scenarios. In _IEEE Intelligent Vehicles Symposium (IV)_. 51–57.  https://doi.org/10.1109/IV51971.2022.9827070
  * Liechti et al. (1994) Felix Liechti, Anders Hedenström, and Thomas Alerstam. 1994\.  Effects of Sidewinds on Optimal Flight Speed of Birds.  _Journal of Theoretical Biology_ 170, 2 (1994), 219–225.  https://doi.org/10.1006/jtbi.1994.1181
  * Lin et al. (2019) Ziqian Lin, Jie Feng, Ziyang Lu, Yong Li, and Depeng Jin. 2019.  DeepSTN+: Context-Aware Spatial-Temporal Neural Network for Crowd Flow Prediction in Metropolis.  _Proceedings of the AAAI Conference on Artificial Intelligence_ 33, 1 (2019), 1020–1027.  https://doi.org/10.1609/aaai.v33i01.33011020
  * Lindström et al. (2020) Per Lindström, Ludwig Jacobsson, Niklas Carlsson, and Patrick Lambrix. 2020.  Predicting player trajectories in shot situations in soccer. In _Machine Learning and Data Mining for Sports Analytics_. Springer International Publishing, 62–75.  https://doi.org/10.1007/978-3-030-64912-8_6
  * Lu et al. (2022) Yuhuan Lu, Wei Wang, Xiping Hu, Pengpeng Xu, Shengwei Zhou, and Ming Cai. 2022\.  Vehicle Trajectory Prediction in Connected Environments via Heterogeneous Context-Aware Graph Convolutional Networks.  _IEEE Transactions on Intelligent Transportation Systems_ (2022), 1–13.  https://doi.org/10.1109/TITS.2022.3173944
  * Mikolov et al. (2013) Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. 2013.  Distributed Representations of Words and Phrases and their Compositionality. In _Advances in Neural Information Processing Systems_ , C.J. Burges, L. Bottou, M. Welling, Z. Ghahramani, and K.Q. Weinberger (Eds.), Vol. 26. Curran Associates, Inc.  https://proceedings.neurips.cc/paper_files/paper/2013/file/9aa42b31882ec039965f3c4923ce901b-Paper.pdf
  * Milani et al. (2023) Stephanie Milani, Arthur Juliani, Ida Momennejad, Raluca Georgescu, Jaroslaw Rzepecki, Alison Shaw, Gavin Costello, Fei Fang, Sam Devlin, and Katja Hofmann. 2023\.  Navigates Like Me: Understanding How People Evaluate Human-Like AI in Video Games. In _Proceedings of the 2023 CHI Conference on Human Factors in Computing Systems_. 1–18.  https://doi.org/10.1145/3544548.3581348
  * OpenDOTA (2023) OpenDOTA. Feb. 2, 2023 - March. 3, 2023.  https://www.opendota.com/.
  * Park et al. (2020) Seong Hyeon Park, Gyubok Lee, Jimin Seo, Manoj Bhat, Minseok Kang, Jonathan Francis, Ashwin Jadhav, Paul Pu Liang, and Louis-Philippe Morency. 2020.  Diverse and Admissible Trajectory Forecasting Through Multimodal Context Understanding. In _Computer Vision – ECCV_. Springer, 282–298.  https://doi.org/10.1007/978-3-030-58621-8_17
  * Paszke et al. (2019) Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. 2019.  PyTorch: An Imperative Style, High-Performance Deep Learning Library. In _Advances in Neural Information Processing Systems_ , Vol. 32. Curran Associates, Inc.  https://proceedings.neurips.cc/paper_files/paper/2019/file/bdbca288fee7f92f2bfa9f7012727740-Paper.pdf
  * Ren et al. (2021) Huimin Ren, Sijie Ruan, Yanhua Li, Jie Bao, Chuishi Meng, Ruiyuan Li, and Yu Zheng. 2021.  MTrajRec: Map-Constrained Trajectory Recovery via Seq2Seq Multi-task Learning. In _Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery & Data Mining_. Association for Computing Machinery, 1410–1419.  https://doi.org/10.1145/3447548.3467238
  * Salinas et al. (2020) David Salinas, Valentin Flunkert, Jan Gasthaus, and Tim Januschowski. 2020.  DeepAR: Probabilistic forecasting with autoregressive recurrent networks.  _International Journal of Forecasting_ 36, 3 (2020), 1181–1191.  https://doi.org/10.1016/j.ijforecast.2019.07.001
  * Vaswani et al. (2017) Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. 2017.  Attention is All you Need.  30 (2017).  https://proceedings.neurips.cc/paper_files/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf
  * Wang and Tan (2021) Ding Wang and Pang-Ning Tan. 2021.  JOHAN: A Joint Online Hurricane Trajectory and Intensity Forecasting Framework. In _Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery & Data Mining_. Association for Computing Machinery, 1677–1685.  https://doi.org/10.1145/3447548.3467400
  * Wu et al. (2022) Haixu Wu, Tengge Hu, Yong Liu, Hang Zhou, Jianmin Wang, and Mingsheng Long. 2022\.  TimesNet: Temporal 2d-variation modeling for general time series analysis.  _arXiv preprint arXiv:2210.02186_ (2022).  https://doi.org/10.48550/arXiv.2210.02186
  * Wu et al. (2021) Haixu Wu, Jiehui Xu, Jianmin Wang, and Mingsheng Long. 2021\.  Autoformer: Decomposition transformers with auto-correlation for long-term series forecasting.  _Advances in Neural Information Processing Systems_ 34 (2021), 22419–22430.  https://doi.org/10.48550/arXiv.2106.13008
  * Xu et al. (2022) Yuan Xu, Jiajie Xu, Jing Zhao, Kai Zheng, An Liu, Lei Zhao, and Xiaofang Zhou. 2022\.  MetaPTP: An Adaptive Meta-optimized Model for Personalized Spatial Trajectory Prediction. In _Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining_. Association for Computing Machinery, 2151–2159.  https://doi.org/10.1145/3534678.3539360
  * Yu et al. (2021) Jian Yu, Meng Zhou, Xin Wang, Guoliang Pu, Chengqi Cheng, and Bo Chen. 2021\.  A dynamic and static context-aware attention network for trajectory prediction.  _ISPRS International Journal of Geo-Information_ 10, 5 (2021), 336.  https://doi.org/10.3390/ijgi10050336
  * Zhang et al. (2021) Hao Zhang, Yanbin Hao, and Chong-Wah Ngo. 2021.  Token Shift Transformer for Video Classification. In _Proceedings of the 29th ACM International Conference on Multimedia_. Association for Computing Machinery, 917–925.  https://doi.org/10.1145/3474085.3475272
  * Zhang et al. (2020) Xiaocai Zhang, Zhixun Zhao, Yi Zheng, and Jinyan Li. 2020\.  Prediction of Taxi Destinations Using a Novel Data Embedding Method and Ensemble Learning.  _IEEE Transactions on Intelligent Transportation Systems_ 21, 1 (2020), 68–78.  https://doi.org/10.1109/TITS.2018.2888587
  * Zhou et al. (2021) Haoyi Zhou, Shanghang Zhang, Jieqi Peng, Shuai Zhang, Jianxin Li, Hui Xiong, and Wancai Zhang. 2021.  Informer: Beyond efficient transformer for long sequence time-series forecasting. In _Proceedings of the AAAI conference on artificial intelligence_ , Vol. 35. 11106–11115.  https://doi.org/10.48550/arXiv.2012.07436
  * Zhou et al. (2022) Tian Zhou, Ziqing Ma, Qingsong Wen, Xue Wang, Liang Sun, and Rong Jin. 2022\.  FEDformer: Frequency enhanced decomposed transformer for long-term series forecasting. In _International Conference on Machine Learning_. PMLR, 27268–27286.  https://doi.org/10.48550/arXiv.2201.12740

##  Appendix A Glossary Table

Table 6. Glossary Table. Symbol |  Description |  Note
---|---|---
Input and Output
$TX$ |  the past trajectories of all recorded game units in $U$ |  $\\{T^{u}_{t,\Delta t,LX}|u\in U\\}$
$C$ |  the context data |  $C_{t,\Delta t,LC}$
$TY$ |  the real trajectory of the player to predict after $t$ |  $T^{p}_{t+LY\Delta t,\Delta t,LY}$
$\hat{TY}$ |  the predicted trajectory of the player to predict after $t$ |  $\mathbb{\hat{T}}^{p}_{t,\Delta t,LY}$
Data-Related Symbols
$t$ |  a time point |
$\Delta t$ |  the time interval of data capturing |  1 sec
$C_{t,\Delta t,L}$ |  the context data consisting of the latest $L$ data frames observed by $p$ |  $(df_{t-(L-1)\Delta t},...,df_{t})$
$df_{t}$ |  the data frame when observing the game at time $t$, consisting of $N$ data states |  $(ds^{1}_{t},...,ds^{N}_{t})$
$ds^{i}_{t}$ |  the $i$-th data state in data frame $df_{t}$ |
$T^{u}_{t,\Delta t,L}$ |  the trajectory of $u$ consisting of the latest $L$ locations |  $(loc^{u}_{t-(L-1)\Delta t},...,loc^{u}_{t})$
$\hat{T}^{u}_{t+L\Delta t,\Delta t,L}$ |  the predicted trajectory of $u$ consisting of the next $L$ locations |  $(loc^{u}_{t+\Delta t},...,loc^{u}_{t+L\Delta t})$
$u\in U$ |  a set of game units whose trajectories are recorded |
$p$ |  the player to predict |  $p\in U$
$loc^{u}_{t}$ |  the 2D coordinate of $u$ at time $t$ |  $(x^{u}_{t},y^{u}_{t})$
$s$ |  a sample |  $(C,TX,TY)$
$S$ |  a batch of samples |  $(s_{1},...,s_{|S|})$
$LC$ |  the number of data frames in context data |  5
$LX$ |  the length of past trajectories |  30
$LY$ |  the length of the trajectories to predict |  10
Model-Related Symbols
$K$ |  the number of worker models |  20
$k$ |  the top-$k$ worker models used to evaluate the model |  3
$L$ |  the loss of the whole model |
$M$ |  the manager model |
$\hat{P}$ |  the probability of each model selected by the manager model |
$L^{M}$ |  the loss of the manager model |
$W_{i}$ |  the $i$-th worker model |
$V_{i}$ |  the training volume of $W_{i}$ |
$L^{W}_{i}$ |  the loss of the $i$-th worker model |
$\hat{TY}_{i}$ |  $\hat{TY}$ of the $i$-th worker model |

##  Appendix B Datasets

###  B.1. DOTA

####  B.1.1. Introduction to the Game

DOTA 2 is a typical MOBA (Multiplayer Online Battle Arena) game. Two teams,
each with five players, need to compete against each other on a well-designed
map. To achieve effective teamwork in a highly competitive game, the players
usually need to make competition plans based on the game context, and the
competition plans require players to move to certain places on the map. For
example, when an allied tower (a type of building) is about to be destroyed by
the opponents (the contextual information), the players may move to the tower
to protect it (the trajectories). A full introduction can be found on the wiki
page: https://dota2.fandom.com/.

Why this dataset? Video games are becoming a new arena for researchers to gain
a better understanding of the capabilities and limitations of AI, for many
reasons:

  * •

High Data Volume. A popular video game, such as PUBG and LOL, may have tens of
millions of players. These players can generate a vast amount of game data
every day. These data can be adequate for training a deep neural network
optimally. We can get access to public data on OpenDOTA (OpenDOTA, 2023), an
open-source DOTA 2 data platform sponsored by OpenAI.

  * •

High Quality. For many video games, the data is stored in a well-organized
data structure. Except for rare cases of game bugs, the data can be considered
correct and accurate. We can hardly find missing or misrecorded values, which
may be common in a real-world dataset.

  * •

High Completeness. For a bird migration dataset, we may find much contextual
information not recorded. For example, the birds may consider where there is a
lake so that they can drink water. However, we cannot guarantee that all bird
migration datasets record the position of each water source along the
migration route. In contrast, the video game dataset is complete. Almost all
the information that motivates the players’ movements is recorded, except
their mental activity. Thanks to this point, we recorded hundreds of
contextual data states in our video game dataset, which greatly tested the
capabilities of our model.

####  B.1.2. Data Description

We provide our code for downloading and preprocessing the dataset in our code
repository. Finally, our dataset considered 99 game units and 273 contextual
data states, shown as follows.

Game Units. Shown as Table 7, the set $U$ includes 99 game units in total.
Note that although some game units are static, we record their trajectories as
POIs to improve the interpretability of our model, inspired by Bartoli et al.
(Bartoli et al., 2018) who involving static obstacles into the trajectory
prediction of pedestrian.

Table 7. All the game units in $U$. Game Unit |  Counts |  Static or Moveable
---|---|---
Heroes controlled by players |  2 $\times$ 5 |  Moveable
Couriers |  2 $\times$ 5
Lane Creeps (at the front) |  2 $\times$ 3
Roshan |  1
Towers |  2 $\times$ 11 |  Static
Barracks |  2 $\times$ 6
Base |  2
Outposts |  2
Runes |  4
Neutral Creeps Camps |  16
Ward Spots |  14

Contextual data states. Shown as Table 9, each data frame includes 283 data
states. According to how players observe these data states, we classify them
into three types, which determine how we record the value.

Table 8. All the data states considered as context data. Value Types |  Data States |  Normalization Params |  Note
---|---|---|---
Consensus data states are always known by all players
Ranged |  38 $\times$ Health of buildings |  MIN=0, MAX=3000 |  The health points of different buildings are also different. However, all are below 3000.
Unlimited |  Current time |  $\hat{MAX}$=2400s |
10 $\times$ Respawn time of heroes |  $\hat{MAX}$=60s |
Boolean |  Circadian state |  0: daytime, 1: nighttime |
10 $\times$ Survival states of heroes |  0: alive, 1: dead |
38 $\times$ Survival states of buildings |  0: alive, 1: dead |
|  2 $\times$ Which team controls the outposts |  0: Radiant, 1: Dire |
Categorical |  10 $\times$ Heroes picked |  embedding vector, $LE=5$ |
10 $\times$ Roles |  one-hot vector, $LE=10$ |
Vision-based data states are updated only when they can be observed by $p$
Ranged |  10 $\times$ Current positions of heroes |  MIN=(8240,8220), MAX=(24510,24450) |  Actually, a position can be regarded as two ranged numbers. For convenience, we regard it as one data state.
10 $\times$ Current positions of couriers |  same as above |
10 $\times$ Positions of wards |  same as above |
|  10 $\times$ Levels of heroes |  MIN=1,MAX=30 |
Unlimited |  10 $\times$ Health of heroes |  $\hat{MAX}$=3000 |
10 $\times$ Mana of heroes |  $\hat{MAX}$=1700 |
10 $\times$ Gold of heroes |  $\hat{MAX}$=15000 |
Health of Roshan |  $\hat{MAX}$=4000 |
Boolean |  2 $\times$ Existence of power runes |  0: without, 1: with |
Categorical |  2 $\times$ Power rune types |  one-hot vector, $LE=7$ |
60 $\times$ Items purchased |  embedding vector, $LE=7$ |
Knowledge-based data states are updated when the data states are observable
and can be known by players using their knowledge
Ranged |  6 $\times$ Positions of lane creeps |  same as the positions mentioned above |  Knowledge: The lane creeps move on certain paths.
Position of Roshan |  same as above |  Knowledge: Roshan will be respawned at a fixed place.
Boolean |  Survival state of Roshan |  0: alive, 1: dead |  Knowledge: There will be a broadcast when it is dead, and it must be respawned 12 minutes after its last death.
2 $\times$ Existence of bounty runes |  0: without, 1: with |  Knowledge: Every three minutes
2 $\times$ Existence of water runes |  0: without, 1: with |  Knowledge: At the 2nd and 4th minutes
16 $\times$ Existence of neutral creeps |  0: without, 1: with |  Knowledge: At the start of every minute

###  B.2. Bird

We constructed two datasets based on an open bird migration dataset
(Kranstauber et al., 2022). According to the number of contextual data states,
we named the two datasets as Bird-2 and Bird-8, respectively. Note that we set
$|U|$ as 1 because the dataset did not record many birds’ locations
simultaneously.

Bird-8 preserves eight contextual data states most relevant to birds’
migratory trajectories. For some data states, we were not sure whether it is
reasonable to classify them into the current types (e.g., regard temperature
as a ranged data state). But this is supposed to have little influence on our
model.

Bird-2 only preserves two time-related contextual data states, namely, the
timestamp and the season.

Table 9. All the data states considered as context data. Value Types |  Data States |  Normalization Params |  Note
---|---|---|---
Ranged |  surface temperature |  Min=250, MAX=320 |  May be in Kelvin.
air temperature |  Min=250, MAX=320 |  The average air temperature is between 400m and 1000m.
surface pressure |  MIN=97000, MAX=105000 |
timestamp |  MIN=0, MAX=525600 |  Considering that bird migration takes a year as a cycle, we convert the timestamp into the ordinal number of minutes in each year, obtaining a ranged data state from 0 to 365 * 24 * 60.
Unlimited |  wind speed in x direction |  $\hat{MAX}$=11 |
wind speed in y direction |  $\hat{MAX}$=8 |
bird density |  $\hat{MAX}$=6 |  The vertically integrated bird density
Boolean |  season |  0: Spring, 1: Autumn |  Birds usually migrate at these two seasons. The original dataset does not have data in the other two seasons.

##  Appendix C Complete Experiments Results

###  C.1. Comparative Experiment I

Table 10. The ADE loss of ten-round experiments on DOTA. Model | Round 0 | Round 1 | Round 2 | Round 3 | Round 4 | Round 5 | Round 6 | Round 7 | Round 8 | Round 9 | MEAN | SD
---|---|---|---|---|---|---|---|---|---|---|---|---
LSTM | 1476.79 | 1393.91 | 1495.63 | 900.35 | 1185.02 | 1187.28 | 1048.58 | 1203.04 | 1555.00 | 1347.27 | 1279.29 | 199.89
Trans | 1080.47 | 1222.13 | 1316.80 | 1053.44 | 1027.95 | 1317.84 | 1224.36 | 1420.34 | 1243.66 | 1370.29 | 1227.73 | 128.74
Tjf | 1172.08 | 936.51 | 876.07 | 920.63 | 905.60 | 1061.73 | 1060.32 | 1030.19 | 861.18 | 869.66 | 969.40 | 99.73
DATF | 749.47 | 867.41 | 724.00 | 1011.85 | 591.48 | 798.94 | 721.36 | 838.30 | 851.53 | 959.48 | 811.38 | 116.48
IETP-10 | 723.15 | 809.29 | 593.37 | 603.25 | 497.87 | 839.06 | 570.39 | 621.59 | 540.13 | 456.66 | 625.48 | 120.66
IETP-20 | 479.89 | 524.78 | 615.08 | 489.99 | 605.00 | 574.85 | 583.03 | 579.90 | 502.46 | 614.51 | 556.95 | 49.95
CATP-10 | 567.74 | 657.37 | 636.25 | 650.59 | 440.55 | 444.40 | 554.02 | 651.52 | 486.70 | 548.33 | 563.74 | 80.61
CATP-20 | 442.69 | 476.61 | 434.66 | 364.47 | 385.90 | 408.36 | 433.83 | 399.40 | 451.29 | 463.97 | 426.12 | 33.87
CATP-10-Tjf | 525.01 | 569.00 | 623.32 | 479.20 | 525.51 | 635.43 | 553.09 | 428.19 | 521.44 | 521.29 | 538.15 | 58.61
CATP-20-Tjf | 410.35 | 414.58 | 442.17 | 453.31 | 401.12 | 415.52 | 495.63 | 333.98 | 449.04 | 417.91 | 423.36 | 36.94
Table 11. The ADE loss of ten-round experiments on Bird-8. Model | Round 0 | Round 1 | Round 2 | Round 3 | Round 4 | Round 5 | Round 6 | Round 7 | Round 8 | Round 9 | MEAN | SD
---|---|---|---|---|---|---|---|---|---|---|---|---
LSTM | 23.99 | 19.33 | 17.21 | 23.65 | 19.08 | 19.13 | 19.26 | 25.81 | 25.85 | 18.93 | 21.22 | 3.06
Trans | 21.97 | 18.41 | 18.21 | 18.46 | 23.74 | 18.42 | 22.21 | 24.74 | 16.79 | 23.81 | 20.68 | 2.76
Tjf | 18.20 | 21.81 | 17.28 | 16.70 | 19.67 | 22.80 | 17.16 | 20.52 | 19.81 | 20.38 | 19.43 | 1.95
DATF | 15.98 | 13.99 | 16.03 | 16.86 | 16.28 | 15.08 | 17.30 | 15.26 | 15.97 | 16.25 | 15.90 | 0.89
IETP-10 | 17.25 | 18.13 | 16.27 | 16.85 | 15.43 | 16.75 | 15.47 | 16.46 | 15.59 | 16.19 | 16.44 | 0.81
IETP-20 | 15.91 | 13.14 | 13.09 | 13.78 | 14.56 | 12.65 | 14.46 | 12.41 | 12.68 | 15.09 | 13.78 | 1.12
CATP-10 | 10.93 | 11.60 | 12.16 | 12.51 | 12.31 | 12.01 | 11.72 | 12.09 | 12.39 | 11.65 | 11.94 | 0.45
CATP-20 | 17.20 | 15.93 | 19.52 | 19.22 | 17.20 | 16.19 | 14.76 | 16.21 | 16.59 | 17.97 | 17.08 | 1.41
CATP-10-Tjf | 11.67 | 12.92 | 12.22 | 9.68 | 12.34 | 12.04 | 12.09 | 12.92 | 12.95 | 10.59 | 11.94 | 1.01
CATP-20-Tjf | 20.49 | 17.48 | 20.31 | 18.84 | 19.28 | 20.28 | 14.81 | 16.44 | 18.65 | 16.95 | 18.35 | 1.80
Table 12. The ADE loss of ten-round experiments on Bird-2. Model | Round 0 | Round 1 | Round 2 | Round 3 | Round 4 | Round 5 | Round 6 | Round 7 | Round 8 | Round 9 | MEAN | SD
---|---|---|---|---|---|---|---|---|---|---|---|---
LSTM | 24.49 | 24.28 | 28.95 | 16.71 | 21.21 | 17.37 | 21.89 | 28.86 | 19.81 | 30.55 | 23.41 | 4.63
Trans | 22.85 | 26.99 | 26.09 | 24.55 | 23.91 | 24.32 | 21.01 | 21.21 | 26.22 | 27.01 | 24.42 | 2.10
DATF | 17.91 | 15.75 | 14.95 | 16.27 | 16.11 | 17.36 | 17.58 | 17.13 | 16.64 | 16.69 | 16.64 | 0.86
IETP-10 | 18.63 | 17.53 | 20.50 | 20.75 | 20.54 | 22.41 | 22.22 | 19.53 | 21.15 | 19.48 | 20.27 | 1.44
IETP-20 | 17.56 | 17.92 | 16.68 | 17.95 | 14.84 | 16.40 | 18.04 | 19.80 | 17.50 | 21.05 | 17.77 | 1.64
CATP-10 | 15.28 | 15.13 | 17.79 | 20.90 | 18.31 | 22.32 | 19.27 | 14.22 | 13.90 | 20.25 | 17.74 | 2.83
CATP-20 | 20.52 | 27.77 | 27.57 | 24.69 | 22.28 | 21.59 | 22.67 | 19.93 | 21.91 | 24.21 | 23.31 | 2.58
CATP-10-Tjf | 18.21 | 16.31 | 18.64 | 21.20 | 18.02 | 16.34 | 11.53 | 17.77 | 18.64 | 15.92 | 17.26 | 2.40
CATP-20-Tjf | 21.55 | 15.93 | 21.66 | 18.01 | 22.48 | 25.40 | 22.03 | 15.79 | 25.48 | 23.85 | 21.22 | 3.36
*Note: Since Tjf accepted only $TX$ as the input, it was unnecessary to repeat the experiments for Tjf on Bird-2.

###  C.2. Comparative Experiment II

Table 13. The MSE loss of ten-round experiments on SP. Model | Round 0 | Round 1 | Round 2 | Round 3 | Round 4 | Round 5 | Round 6 | Round 7 | Round 8 | Round 9 | MEAN | SD
---|---|---|---|---|---|---|---|---|---|---|---|---
LSTM | 5.43 | 5.91 | 4.97 | 5.28 | 5.72 | 6.15 | 6.56 | 4.98 | 5.40 | 6.46 | 5.69 | 0.54
Trans | 5.85 | 5.25 | 5.08 | 5.85 | 5.23 | 6.96 | 5.03 | 5.67 | 6.17 | 4.67 | 5.57 | 0.63
Informer | 4.48 | 5.77 | 4.52 | 3.97 | 4.33 | 5.35 | 6.62 | 4.77 | 4.11 | 4.17 | 4.81 | 0.81
Autoformer | 2.70 | 3.29 | 3.45 | 3.22 | 3.84 | 3.10 | 2.81 | 3.16 | 2.99 | 3.06 | 3.16 | 0.31
FEDformer | 3.12 | 2.81 | 3.92 | 3.36 | 2.97 | 2.99 | 2.76 | 3.15 | 3.34 | 3.13 | 3.16 | 0.32
TimesNet | 2.97 | 3.06 | 2.73 | 2.98 | 3.16 | 3.16 | 2.48 | 2.62 | 2.90 | 3.22 | 2.93 | 0.23
MW-LSTM | 5.27 | 4.02 | 4.96 | 4.42 | 5.03 | 5.13 | 4.84 | 5.25 | 4.58 | 5.13 | 4.86 | 0.39
MW-Trans | 4.52 | 4.70 | 4.70 | 5.89 | 3.85 | 4.42 | 5.49 | 4.86 | 4.17 | 4.81 | 4.74 | 0.56
MW-TN | 2.90 | 2.70 | 2.78 | 3.01 | 2.84 | 3.05 | 2.91 | 2.84 | 2.61 | 2.92 | 2.86 | 0.13
Table 14. The MSE loss of ten-round experiments on ET. Model | Round 0 | Round 1 | Round 2 | Round 3 | Round 4 | Round 5 | Round 6 | Round 7 | Round 8 | Round 9 | MEAN | SD
---|---|---|---|---|---|---|---|---|---|---|---|---
LSTM | 1.25 | 1.44 | 1.59 | 1.19 | 1.43 | 1.36 | 1.46 | 1.32 | 1.52 | 1.38 | 1.40 | 0.12
Trans | 1.28 | 1.38 | 1.31 | 1.24 | 1.05 | 1.03 | 1.39 | 1.23 | 1.09 | 1.31 | 1.23 | 0.13
Informer | 1.26 | 1.03 | 0.95 | 0.81 | 1.11 | 1.07 | 1.05 | 0.98 | 1.16 | 1.01 | 1.04 | 0.12
Autoformer | 0.48 | 0.53 | 0.53 | 0.52 | 0.44 | 0.53 | 0.53 | 0.46 | 0.56 | 0.41 | 0.50 | 0.05
FEDformer | 0.48 | 0.49 | 0.46 | 0.48 | 0.42 | 0.53 | 0.52 | 0.41 | 0.39 | 0.42 | 0.46 | 0.05
TimesNet | 0.60 | 0.42 | 0.47 | 0.46 | 0.41 | 0.47 | 0.42 | 0.48 | 0.48 | 0.45 | 0.47 | 0.05
MW-LSTM | 0.86 | 1.01 | 0.89 | 0.82 | 0.89 | 1.09 | 1.05 | 1.11 | 1.10 | 1.06 | 0.99 | 0.10
MW-Trans | 1.09 | 0.97 | 1.09 | 0.89 | 0.94 | 1.11 | 1.16 | 0.76 | 0.99 | 1.04 | 1.00 | 0.11
MW-TN | 0.51 | 0.48 | 0.39 | 0.45 | 0.46 | 0.45 | 0.46 | 0.43 | 0.36 | 0.50 | 0.45 | 0.04