A Contrastive Learning Framework for Vehicle Spatio-Temporal Trajectory Similarity in Intelligent Transportation Systems

Abstract

The rapid development of vehicular networks has facilitated the extensive acquisition of vehicle trajectory data, which serve as a crucial cornerstone for a variety of intelligent transportation system (ITS) applications, such as traffic flow management and urban mobility optimization. Trajectory similarity computation has become an essential tool for analyzing and understanding vehicle movements, making it indispensable for these applications. Nonetheless, most existing methods neglect the temporal dimension in trajectory analysis, limiting their effectiveness. To address this limitation, we integrate the temporal dimension into trajectory similarity evaluations and present a novel contrastive learning framework, termed Spatio-Temporal Trajectory Similarity with Contrastive Learning, aimed at training effective representations for spatio-temporal trajectory similarity. The STT-CL framework introduces the innovative concept of spatio-temporal grids and leverages two advanced grid embedding techniques to capture the coarse-grained features of spatio-temporal trajectory points. Moreover, we design a Spatio-Temporal Trajectory Cross-Fusion Encoder (STT-CFE) that seamlessly integrates coarse-grained and fine-grained features. Experiments on two large-scale real-world datasets demonstrate that STT-CL surpasses existing methods, underscoring its potential in trajectory-driven ITS applications.

1. Introduction

The widespread use of GPS-enabled devices and interconnected vehicular networks has revolutionized the ability to collect and analyze large volumes of vehicle trajectory data. These data form the backbone of various applications in intelligent transportation systems (ITSs), such as improving traffic flow, reducing congestion, and optimizing urban mobility [1,2,3]. By analyzing how vehicles move over time and space, ITS technologies aim to make transportation more efficient and improve the overall travel experience in modern cities [4,5,6,7].

A critical aspect of this analysis is understanding the similarities between vehicle trajectories, which plays a fundamental role in many ITS functions [8,9]. For example, in dynamic route optimization, trajectory similarity computation enables real-time identification of alternative paths by comparing current vehicle movements with historical traffic patterns, ensuring smoother and faster travel during congestion. Similarly, in traffic anomaly detection, analyzing trajectory similarities can help identify irregular behaviors, such as sudden stops or deviations, which may indicate accidents or hazardous conditions. By accurately measuring these similarities, transportation systems can uncover patterns, predict future movements, and respond to disturbances more effectively. Despite its importance, developing reliable and efficient methods for comparing trajectories remains a significant challenge and an active area of research within ITS.

For trajectory similarity computation, various conventional heuristic similarity methods have been proposed, such as DTW [10], EDR [11], Hausdorff [12], and Fréchet [13]. These methods rely on point-wise matching computation, thus resulting in high computational costs. Learning-based similarity methods [14] utilize deep neural networks to represent trajectories as d-dimensional vectors. The similarity between two trajectories is expressed directly as the Euclidean distance between the representation vectors. However, most of these methods only consider trajectories as sequences of spatial points, overlooking the significance of temporal information in real-world trajectories.

Why spatio-temporal similarity? For two trajectories with similar spatial structures, it is reasonable to expect them to be very close when using spatial similarity measures. However, in many real-world scenarios, the time at which these two trajectories occur can significantly influence their degree of similarity. For example, in urban settings, two trajectories with similar starting and ending points, as shown in Figure 1, but occurring at different times, may correspond to going to work and returning home, respectively. Given the varying traffic flow at different time periods of the day, these trajectories should be considered to have more significant dissimilarity than suggested by spatial similarity methods alone.

To effectively represent the influence of time on different trajectories, we introduce temporal information into trajectory similarity measurement. Moreover, considering the temporal information of the trajectories, we can analyze the movement patterns of objects from more aspects. This contributes to performance improvements in various trajectory-related tasks. Therefore, we use spatio-temporal rather than spatial similarity to measure different trajectories.

Why contrastive learning? Although the acquisition of trajectory data has become much easier these days, how to accurately annotate it remains a challenging problem. To avoid the problem of lacking precise temporal and spatial annotation for trajectories, we employ a self-supervised learning approach. Most self-supervised learning models adopt an encoder–decoder structure. The encoder encodes input samples into representations and the decoder reconstructs these representations back to their original forms. However, recent research [15,16] suggests that reconstruction is unnecessary when computing the similarity between samples. Since the encoder in an encoder–decoder structure aims to learn a representation suitable for reconstructing rather than evaluating similarity, this model is obviously not suitable for our specific task.

Contrastive learning exhibits remarkable generalizability and robustness. It has been widely applied in various fields due to its exceptional performance [17,18]. Contrastive learning is typically used to learn the similarity between data, so we use it to address the issue of trajectory similarity evaluation in self-supervised learning.

We introduce STT-CL, an innovative framework for evaluating Spatio-Temporal Trajectory similarity using Contrastive Learning. This approach considers views of the same trajectory as positive samples, while treating views of different trajectories as negative samples. By utilizing spatio-temporal grids to extract rich features of trajectories at different scales, our model trains a Spatio-Temporal Trajectory Cross-Fusion Encoder to generate representations by learning the similarity between different trajectories.

Our contributions can be summarized as follows.

• We propose STT-CL, a contrastive learning model for spatio-temporal trajectory computation. To the best of our knowledge, it is the first work to introduce the contrastive learning method in the study of spatio-temporal trajectory similarity.
• We innovatively introduce the concept of spatio-temporal grids and present two methods of spatio-temporal grid embedding to capture coarse-grained features.
• We design a spatio-temporal trajectory backbone encoder, namely, Spatio-Temporal Trajectory Cross-Fusion Encoder, which focuses on the correlations between coarse-grained features and fine-grained features of trajectories and fuses them into representation. It exhibits better performance for low-quality trajectories compared with previous encoders.
• We conduct extensive experiments on two real-world datasets. The experimental results illustrate that STT-CL surpasses existing baseline models in terms of performance, particularly in terms of robustness when dealing with low-quality trajectories.

2. Related Work

2.1. Spatial Trajectory Similarity

Spatial trajectory similarity methods can be divided into two types: heuristic methods and learning-based methods. The former typically involve point-wise matching between two trajectories and regard the distance between matched points as a similarity metric. The latter embed trajectories into similarity representation vectors, and the distance between these vectors reflects the similarity between the represented trajectories. Depending on the specific embedding methods, they can be further categorized into supervised learning-based methods and self-supervised learning-based methods.

Heuristic methods are characterized by their reliance on point-wise comparisons between trajectories, where the similarity is determined based on the distances between matched points. For example, DTW (dynamic time warping) [10] matches all points in one trajectory with one or more consecutive points in another trajectory and calculates the Euclidean distance. EDR (edit distance on real sequence) [11] is based on the concept of edit distance, counting the number of edit operations required to make the point sequences identical. The Hausdorff distance [12] measures the maximum distance from a point in one trajectory to the nearest point in another trajectory, treating the trajectory points as sets. The Fréchet distance [13], similar to the Hausdorff distance, considers trajectories as ordered curves while calculating the distance. Due to the necessity of traversing all point pairs between trajectories, heuristic methods have a quadratic computational complexity.

Supervised learning-based methods aim to train a model to approximately learn a heuristic method, which is the ground-truth for trajectory similarity. For example, T3S [19] first introduced structural and spatial features for trajectory similarity, which can adaptively learn various heuristic methods by the proportion of the two features. Aries [20] employs a bidirectional LSTM and aggregates multiple methods to enhance the performance of trajectory similarity in the top-k query task. TSNE [21] proposed a graph embedding method on the k-nearest neighbor graph (k-NNG) to improve the efficiency and interpretability of the model.

Self-supervised learning-based methods also learn trajectory representations but without heuristic method annotations. They compare similar trajectories to capture the implicit corrections between trajectories. For example, t2vec [14] first adopts an RNN-based encoder–decoder model, which reduces the spatial proximity-aware loss between the original trajectories and the reconstructed ones to train the model. AdvTraj2Vec [22] employs a GAN (generative adversarial network) structure, which is also an encoder–decoder structure, and improves the robustness of trajectory similarity computation by harnessing the perturbation with GAN momentum.

2.2. Spatio-Temporal Trajectory Similarity

In recent years, some studies have gradually realized the importance of the time dimension for trajectory similarity and have been used to fuse temporal and spatial features. TS-join [23] introduces the temporal dimension into trajectory similarity, obtaining spatio-temporal similarity methods by separately combining spatial and temporal similarity methods at different scales. STS [24] represents each point in a trajectory as a result observed from a probability distribution to calculate the spatio-temporal overlap. However, these artificially designed heuristic methods still suffer from issues such as high time consumption and ineffectiveness. Some studies have attempted to use deep neural networks for spatio-temporal trajectory similarity computation. ST2Vec [25] proposes a temporal modeling model to capture temporal features and a co-attention fusion module to fuse temporal and spatial features. GTS+ [26] proposes a graph-based framework for spatio-temporal trajectory similarity, which encodes the embeddings of each POI (point of interest) by a GNN. However, both ST2Vec and GTS+ additionally introduce urban road network information for spatio-temporal trajectory similarity.

In other trajectory mining tasks, some methods have also recognized the importance of time. For instance, START [27] acknowledges the importance of spatio-temporal characteristics in trajectories, such as temporal regularities and travel semantics. It extracts both temporal and spatial features from the trajectories and employs a self-supervised approach to embed these representations.

2.3. Contrastive Learning for Trajectory Similarity

Contrastive learning [28] is a prominent self-supervised learning approach that focuses on learning meaningful representations by comparing data instances. The fundamental principle behind contrastive learning is to encourage the model to bring the representations of similar objects (referred to as positive pairs) closer together in the feature space, while simultaneously pushing apart the representations of dissimilar objects (negative pairs). This is achieved without the need for labeled data, as positive and negative pairs are constructed directly from the input dataset. By learning these relationships, contrastive learning facilitates the training of a representation generation model, typically realized through a backbone encoder, which can then be leveraged for a variety of downstream tasks. Notably, this technique has been successfully applied to spatial trajectory similarity analysis, with methods such as CL-TSim [15] and TrajCL [29] integrating contrastive learning principles to improve the representation of trajectory data for better similarity measurements and related applications. CL-TSim is the first method to introduce contrastive learning for spatial trajectory similarity; however, it employs a simple LSTM encoder, which limits its performance in capturing complex trajectory patterns. TrajCL, a more recent approach, improves upon this by utilizing a dual-feature encoder, which significantly enhances the quality of trajectory similarity computation. The dual-feature encoder in TrajCL served as an inspiration for the method presented in this paper, as it effectively captures richer representations of trajectory data. In addition, we use TrajCL as a baseline in our experiments to compare and validate the performance of our proposed model.

3. Preliminaries

In this section, we present fundamental concepts and formally define the problem essential to understanding the subsequent analysis.

Definition 1 (Spatio-Temporal Trajectory).

A spatio-temporal trajectory is a recorded path that depicts the movement of an object in geographical space over time. Formally, it is represented as an ordered sequence:

$$T=\langle p_1,p_2,\dots ,p_{\left|T\right|}\rangle$$

(1)

where $\left|T\right|$ denotes the trajectory length. Each sampling point $p_i=(x_i,y_i,t_i)$ comprises spatial coordinates and the corresponding timestamp. This parametrization establishes a continuous mapping between spatial displacement and temporal progression.

Conventional learning-based methods for spatial trajectory similarity analysis predominantly employ discrete spatial decomposition with equally sized, non-overlapping, and adjacent grids. To capture temporal dynamics while preserving spatial granularity, we propose a dimensional extension of this paradigm into the spatio-temporal domain.

Definition 2 (Spatio-Temporal Grid).

This is created by partitioning the continuous space–time domain into discrete units using fixed spatial intervals and temporal durations. Trajectory points within the same grid unit occupy identical spatial regions and temporal intervals.

Problem 1.

Given a set of spatio-temporal trajectories $\mathcal{T}=\{T_1,T_2,\dots ,T_N\}$, learn an encoder function

$$\mathcal{E}:T\to \mathbf{r}\in {\mathbb{R}}^d$$

(2)

such that for any two trajectories $T_i,T_j\in \mathcal{T}$:

$$\parallel \mathcal{E}\left(T_i\right)-\mathcal{E}\left(T_j\right)\parallel \propto -\mathit{Sim}(T_i,T_j)$$

(3)

where $\mathit{Sim}(·,·)$ denotes the similarity between two trajectories.

4. The STT-CL Approach

4.1. Framework Overview

Figure 2 shows the framework overview of STT-CL. It follows the classical contrastive learning framework, similar to MOCO [28] and BYOL [30], both of which adopt a dual-branch structure.

Given a spatio-temporal trajectory T, first obtain two different views ($T_1^{\prime }$ and $T_2^{\prime }$) of T through the trajectory augmentation module. We employ trajectory down-sampling and trajectory distortion as augmentation methods. Furthermore, we adopt the latest trajectory truncation and simplification [29].

Then, the coarse-grained and fine-grained feature extraction modules produce point-wise features using the generated views $T^{\prime }$. Instead of structural features and spatial features [19], we distinguish point-wise features as coarse-grained features and fine-grained features based on their level of detail (more details are given in Section 4.3). These feature vectors form the coarse-grained feature matrix C and the fine-grained feature matrix F, respectively.

Next, the Spatio-Temporal Trajectory Cross-Fusion Encoder (STT-CFE) $\mathcal{E}$ takes in C and F, then outputs the representation r for $T^{\prime }$. The STT-CFE we designed is adapted from DualSTB [29], which fuses coarse-grained features and fine-grained features into representations of trajectories (more details are given in Section 4.4).

Finally, we train the STT-CFE through contrastive learning, which maximizes the similarity between $T_1^{\prime }$ and $T_2^{\prime }$ while maintaining dissimilarity between the views of different trajectories (more details are given in Section 4.5).

4.2. Trajectory Augmentation

Trajectory distortion. Trajectory distortion introduces minor spatial perturbations to each point in a trajectory, simulating the inherent noise in GPS data collection. Given a trajectory $T=\langle p_1,p_2,\dots ,p_{\left|T\right|}\rangle$, the distorted trajectory $T^{\prime }$ is generated as

$$T^{\prime }=\langle p_1^{\prime },p_2^{\prime },\dots ,p_{\left|T\right|}^{\prime }\rangle ,\mathrm{where}{p}_i^{\prime }=(x_i+∆x_i,y_i+∆y_i)$$

(4)

where $∆x_i$ and $∆y_i$ are random offsets sampled from a bounded Gaussian distribution.

Trajectory down-sampling. Trajectory down-sampling randomly removes a subset of points from the trajectory, simulating scenarios with missing data or varying sampling rates. For a trajectory T, the down-sampling trajectory $T^{\prime }$ is defined as

$$T^{\prime }=\langle p_{n_1},p_{n_2},\dots ,p_{n_{|T^{\prime }|}}\rangle$$

(5)

where $\{n_1,n_2,\dots ,n_{|T^{\prime }|}\}$ is a strictly increasing sequence of indices, and $|T^{\prime }| = \lfloor (1-{\rho }_d)·\left|T\right|\rfloor$. The masking ratio ${\rho }_d$ determines the proportion of points removed.

Trajectory truncation. Trajectory truncation generates partial trajectories by removing a prefix or suffix, simulating scenarios where only a portion of the trajectory is available. Given a trajectory T, the truncated trajectory $T^{\prime }$ is

$$T^{\prime }=\langle p_i,p_{i+1},\dots ,p_{i+\lfloor {\rho }_b·\left|T\right|\rfloor }\rangle$$

(6)

where i is a random starting index, and ${\rho }_b$ controls the proportion of points retained.

Trajectory simplification. Trajectory simplification reduces the number of points while preserving the overall shape and critical features of the trajectory. We adopt the Douglas–Peucker [29,31] simplification algorithm, which identifies and retains key points that contribute significantly to the structure of the trajectory. The simplified trajectory $T^{\prime }$ is defined as

$$T^{\prime }=Douglas\_Peucker\left(T\right)$$

(7)

4.3. Coarse-Grained and Fine-Grained Feature Extraction

In previous studies, point-wise features of a trajectory have been commonly categorized into structural and spatial attributes, focusing primarily on the spatial dimension of trajectory analysis. However, the true value of the trajectory data is not limited to the spatial aspect. The introduction of the temporal dimension offers additional insight into individual mobility patterns. In light of this, our research further refines point-wise features into coarse-grained and fine-grained features, enabling a more detailed and comprehensive analysis of spatio-temporal trajectories.

In order to better understand and characterize the complexities of spatio-temporal trajectories, we design two specific feature extraction modules, called Coarse-Grained Feature Extraction (CFE) and Fine-Grained Feature Extraction (FFE), which are capable of, respectively, extracting coarse-grained and fine-grained features.

4.3.1. Coarse-Grained Feature Extraction

The CFE module aims to capture coarse-grained features, emphasizing the overall movement trends and patterns of a trajectory. The CFE module partitions trajectory points into spatio-temporal grids and trains the grids embeddings to represent the points’ coarse-grained features. These embeddings collectively form the coarse-grained feature matrix C of the trajectory T, where $C\in {\mathbb{R}}^{l\times d_c}$, l denotes the trajectory length, and $d_c$ represents the dimensionality of the embedding of the grid. The key of the CFE module is the methodology of training spatio-temporal grid embeddings. To address the crucial issue, we introduce two improved training methods.

Grid embeddings as nodes. Intuitively, we consider the spatio-temporal grids as nodes within a graph framework, with their temporal and spatial adjacency relations representing the edges that connect these nodes. Using the node2vec algorithm, our aim is to train the embedding representations of these grid nodes. The optimization principle of node2vec is to maximize the probability of observing a node’s neighborhood by strategically sampling walks from the graph, thereby learning representations that encapsulate the structural nuances of the graph.

However, in previous studies [25,29], graphs have been constructed with edges of equal weight based solely on spatio-temporal adjacency between grids. Such an approach fails to accurately capture the actual topological structure of the spatio-temporal grid graph. To better reflect the genuine topological structure of the spatio-temporal grid graph, we propose a novel method for setting edge weights, which incorporates historical trajectory data. The formula for our designed weight calculation is as follows:

$$W(u,v)=\left\{\begin{array}{cc}1+\xi \left({\displaystyle \frac{H(u,v|\sigma )}{{\sum }_{x\in N\left(u\right)}H(u,x|\sigma )}}\right),\hfill & \mathrm{if}x\in N\left(u\right)\hfill \\ 0,\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(8)

where $W(u,v)$ denotes the weight of the edge from grid u to grid v, $\xi$ is a tuning factor, $H(u,v|\sigma )$ represents the hit rate at which grid v serves as an $\sigma$-step successor of grid u in historical trajectories, and $N\left(u\right)$ is the set of neighboring grids of v. Modulating the $\xi$ parameter allows for precise control over the impact of historical trajectory data on the discerned strength of connections between spatio-temporal grids. Additionally, the parameter $\sigma$ is defined as the temporal step used to determine the number of time intervals over which the hit rate is computed. This parameter plays a crucial role in defining the temporal depth of the historical trajectories engaged during the hit rate computation. A larger $\sigma$ can discover more complex relationships between spatio-temporal grids; however, it also incurs a greater computational time cost.

Grid embeddings as words. In the domain of trajectory analysis, some studies [14,15] have conceptualized spatio-temporal grids as words, with the sequence of grids traversed by trajectory points in a single trajectory forming a “sentence”. A corpus is constituted by a vast collection of such trajectory data, providing data support for training grids embeddings with algorithms such as Skip-gram and other word2vec models. However, when employing the Skip-gram model for embedding training, it is often found that the model performs suboptimally with newly emerging or rare words (grids). To address this issue, we adopt a morpheme-based word formation approach in conjunction with the word2vec method in the FastText framework [32].

Initially, spatio-temporal grid words are decomposed into three morphemic parts, representing the divisions of longitude, latitude, and time sequence numbers, such as “X10Y5T6”. Subsequently, we employ the FastText method for word embedding training on the constructed corpus. The optimization goal of FastText is similar to that of the conventional word2vec method, aiming to maximize the logarithmic probability of the context given a center word. However, FastText extends word embeddings to character-level n-grams. The optimization goal of FastText can be expressed as

$$\begin{array}{c}{\displaystyle \underset{\theta }{max}}{\displaystyle \frac{1}{T}}{\displaystyle \sum _{t=1}^T}{\displaystyle \sum _{c\in C\left(t\right)}}logPr\left(w_c\right|w_t,\theta )\\ Pr\left(w_c\right|w_t,\theta )={\displaystyle \frac{exp\left({\mathbf{v}}_{w_c}^{\top }{\mathbf{v}}_{w_t}\right)}{{\sum }_{w^{\prime }\in V}exp\left({\mathbf{v}}_{w^{\prime }}^{\top }{\mathbf{v}}_{w_t}\right)}}\end{array}$$

(9)

where T denotes the total number of words (grids) in the training corpus, $C\left(t\right)$ represents the set of context words surrounding the center word $w_t$, $w_c$ refers to a word within the context, and $\theta$ encapsulates the parameters of the module. Vector embeddings ${\mathbf{v}}_{w_c}$ and ${\mathbf{v}}_{w_t}$ correspond to the context and center words, respectively. V is the vocabulary (set of unique grids).

In this manner, the module is able to leverage the internal structural information of spatio-temporal grid words, enhancing its capability to recognize and process new or rare words.

4.3.2. Fine-Grained Feature Extraction

The FFE module manually enhances the features that reflect both the temporal cyclical patterns and physical characteristics of the trajectory points.

For a point $p_i$, that is, $(x_i,y_i,t_i)$, the enhanced fine-grained features can be represented as a tuple $(x_i,y_i,t_i,r_i,v_i)$. Here, $x_i,y_i$ correspond to the longitude and latitude coordinates, $t_i$ denotes the timestamps, $r_i$ represents the radian value of the segments before and after the point, and finally $v_i$ indicates the average speed of the segments.

Upon enhancement by the FFE module, the spatio-temporal trajectory T is transformed, producing a fine-grained feature matrix F, where $F\in {\mathbb{R}}^{l\times d_f}$, and $d_f$ denotes the length of the fine-grained features.

4.4. Spatio-Temporal Trajectory Cross-Fusion Encoder

Figure 3 illustrates the architecture of our proposed Spatio-Temporal Trajectory Cross-Fusion Encoder (STT-CFE). The encoder consists of three components: the position encoding section, the Bi-Feature Interaction Module (BFIM) section, and the fusion section. These components will be detailed in the following sections.

4.4.1. Position Encoding Section

Just like many modules that employ attention mechanisms for processing sequential data, our encoder also relies on positional encoding to endow features with relative positional information.

We employ the sine and cosine functions [33] for position encoding. The formula for position encoding is as follows:

$$PE(i,j)=\left\{\begin{array}{cc}sin\left({\displaystyle \frac{i}{{10000}^{j/d_p}}}\right),\hfill & \mathrm{if}j\mathrm{is}\mathrm{even}\hfill \\ cos\left({\displaystyle \frac{i}{{10000}^{(j-1)/d_p}}}\right),\hfill & \mathrm{if}j\mathrm{is}\mathrm{odd}\hfill \end{array}\right.$$

(10)

where $P{E}_{i,j}$ represents the encoded positional information for the i-th point in the trajectory, added to the j-th dimensional value of the feature embeddings, and d stands for the overall dimensionality of the feature embeddings. The coarse-grained and fine-grained feature matrices C and F are updated through position encoding as follows:

$${\tilde{C}}_0[i,j]=C[i,j]+PE(i,j){\tilde{F}}_0[i,j]=F[i,j]+PE(i,j)$$

(11)

where $[i,j]$ represents the position in the i-th row and j-th column of the matrices. ${\tilde{C}}_0$ and ${\tilde{F}}_0$ are the updated matrices obtained from C and F, respectively, and serve as input to the next BFIM.

4.4.2. BFIM Section

The BFIM module consists of multiple layers with identical structures, each mainly formed by a Transformer encoder module (TEM) and a cross-attention fusion module (CFM). Each layer of the BFIM receives two feature matrices from the previous layer and outputs the feature matrices after interactive fusion. The operation of the i-th layer is expressed by the following formula:

$$\{{\tilde{C}}_i,{\tilde{F}}_i\}={\mathcal{F}}_{BFIM}\left(\{{\tilde{C}}_{i-1},{\tilde{F}}_{i-1}\}\right)$$

(12)

where $\{{\tilde{C}}_i,{\tilde{F}}_i\}$ represents the output feature matrices of the i-th layer, ${\mathcal{F}}_{BFIM}(·)$ is a function that denotes the functionality of the BFIM module, interacting with the input feature matrices $\{{\tilde{C}}_{i-1},{\tilde{F}}_{i-1}\}$. The feature matrices ${\tilde{C}}_i,{\tilde{F}}_i\in {\mathbb{R}}^{l\times d_e}$, where $d_e$ denotes the final encoding representation length.

Taking the i-th layer as an example, the TEM and CFM are detailed as follows.

Transformer encoder module. The TEM employs the classic encoder structure in Transformer [33] for preliminary encoding of features. We omit a detailed description of its internal components, and describe its processing with the following formula:

$$\{{\widehat{C}}_i,{\widehat{F}}_i\}={\mathcal{F}}_{TEM}\left(\{{\tilde{C}}_{i-1},{\tilde{F}}_{i-1}\}\right)$$

(13)

where $\{{\widehat{C}}_i,{\widehat{F}}_i\}\in {\mathbb{R}}^{l\times d_e}$ represents the output feature matrices of the TEM, ${\mathcal{F}}_{TEM}(·)$ is a function that denotes the functionality of the TEM module.

Cross-attention fusion module. The CFM takes $\{{\widehat{C}}_i,{\widehat{F}}_i\}$ as inputs and utilizes a cross-attention mechanism for interaction between features. During this process, one of the two features acts as the primary feature, while another serves as an auxiliary feature to assist in encoding the primary feature. Given that the CFMs of both branches are mirror images of each other, we specifically describe the structure of the CFM that employs fine-grained features as the primary feature, as shown in the bottom row of Figure 3.

Firstly, through multi-head linear transformations, a value matrix $V_F^j$ and a key matrix $K_F^j$ are obtained from the feature matrix ${\widehat{F}}_i$, whereas a query matrix $Q_C^j$ is obtained from the feature matrix ${\widehat{C}}_i$, where $V_F^j$, $K_F^j$, and $Q_C^j\in {\mathbb{R}}^{l\times (d_e/h)}$; j denotes the j-th head; and h is the number of heads (all processes in this subsection occur at the i-th layer; to simplify, we have removed the subscript i from certain matrices, such as $V_F^j$ and $K_F^j$). The formulas are as follows:

$$V_F^j={\widehat{F}}_i{W}_V^j{K}_F^j={\widehat{F}}_i{W}_K^j{Q}_C^j={\widehat{C}}_i{W}_C^j$$

(14)

where $W_V^j$, $W_K^j$, and $W_C^j\in {\mathbb{R}}^{d_e\times (d_e/h)}$ are the multi-head linear weight matrices.

Then, we calculate the attention matrix ${\mathcal{A}}_F^j$ between $K_F^j$ and $Q_C^j$, which is formulated as follows:

$${\mathcal{A}}_F^j=\mathrm{softmax}({\displaystyle \frac{{\mathbf{Q}}_{\mathbf{C}}^{\mathbf{j}}{{\mathbf{K}}_{\mathbf{F}}^{\mathbf{j}}}^T}{\sqrt{d_e/h}}})$$

(15)

where ${\mathcal{A}}_F^j$ represents the correlation between the two branch features in the j-th head.

Subsequently, we multiply the value matrix with the attention matrix, then merge the multiple heads and perform a linear transformation, which is formulated as follows:

$$\begin{array}{c}{\mathcal{Z}}_F^j={\mathcal{A}}_F^j\times V_F^j\\ {\mathcal{Z}}_F=({\mathcal{Z}}_F^1\left|\right|{\mathcal{Z}}_F^2\left|\right|\cdots \left|\right|{\mathcal{Z}}_F^h)W_o\end{array}$$

(16)

where || represents the concatenation function, and $W_o\in {\mathbb{R}}^{d_e\times d_e}$ is the linear weight matrix.

Finally, following the standard Transformer encoder model [33], we employ a feed-forward network (FFN) and two residual connections with layer normalization to obtain the final output feature matrix. Furthermore, we have introduced simple learnable scaling coefficients to residual connections, which have been proven to enhance performance to some extent [34,35]. The process is formulated as follows:

$$\begin{array}{c}{\widehat{\mathcal{Z}}}_F=LN(\alpha ·{\widehat{F}}_i+\beta ·{\mathcal{Z}}_F)\\ {\tilde{F}}_i=LN(\gamma ·{\widehat{\mathcal{Z}}}_F+\delta ·FFN\left({\widehat{\mathcal{Z}}}_F\right))\end{array}$$

(17)

where $LN(·)$ denotes layer normalization, and $FFN(·)$ refers to two fully connected layers. $\alpha$, $\beta$, $\gamma$, and $\delta$ are the learnable scaling coefficients.

4.4.3. Fusion Section

The fusion section takes in the coarse-grained and fine-grained feature matrices, ${\tilde{C}}_n$ and ${\tilde{F}}_n$, output by the BFIM (n denotes the number of the BFIM layers, thus ${\tilde{C}}_n$ and ${\tilde{F}}_n$ represent the outputs of the BFIM), and fuses them into the final representation.

Firstly, we perform average pooling on the coarse-grained and fine-grained feature matrices ${\tilde{C}}_n$ and ${\tilde{F}}_n$ to integrate the features of each point on the trajectory, producing the coarse-grained and fine-grained feature vectors ${\upsilon }_C$ and ${\upsilon }_F$, respectively.

Then, we design four schemes to combine these two feature vectors. (a) $FFN\left({\upsilon }_C\right|\left|{\upsilon }_F\right)$; (b) ${\upsilon }_C\left|\right|{\upsilon }_F$; (c) ${\upsilon }_C$; (d) ${\upsilon }_F$. Through experimentation, we select the best-performing scheme (a), thus the formula is as follows:

$$r=FFN\left(AvgPool\left({\tilde{C}}_n\right)\right|\left|AvgPool\left({\tilde{F}}_n\right)\right)$$

(18)

where $AvgPool(·)$ denotes the average pooling function, and r is the output of the section, which also serves as the feature vector that represents the spatio-temporal trajectory T encoded by the STT-CFE.

4.5. STT-CL Contrastive Learning Procedure

STT-CL’s training follows the standard BYOL contrastive learning framework [30], as illustrated on the right of Figure 2, employing two networks: the online network and the target network. The online network, parameterized by $\theta$, comprises an encoder ${\mathcal{E}}_{\theta }$, a projector ${\mathcal{P}}_{\theta }$, and a predictor ${\mathcal{G}}_{\theta }$. The target network mimics the architecture of the online network, but uses a distinct set of weights $\phi$, which are updated as an exponential moving average of the online network parameters $\theta$. More precisely, given a target decay rate $\tau \in [0,1]$, after each training step we perform the following update:

$$\phi \leftarrow \tau \phi +(1-\tau )\theta$$

(19)

During training, STT-CL creates two augmented trajectories $T_1^{\prime }$ and $T_2^{\prime }$. Then, the online network processes $T_1^{\prime }$ to produce a representation $r_1$ and a projection $h_1$. Similarly, the target network processes $T_2^{\prime }$ to generate $r_2$ and a target projection $h_2^{\prime }$. A prediction $z_1$ of $h_1$ is made, and both $z_1$ and $sg\left(h_2^{\prime }\right)$ are normalized, where $sg(\cdot )$ means stop-gradient. The networks are trained by minimizing the mean squared error between the normalized predictions $z_1$ and the target projections $sg\left(h_2^{\prime }\right)$. The loss is formulated as follows:

$$los{s}_{\theta ,\phi }=2-2·{\displaystyle \frac{\langle z_1,sg\left(h_2^{\prime }\right)\rangle }{\parallel z_1{\parallel }_2·{\parallel sg\left(h_2^{\prime }\right)\parallel }_2}}$$

(20)

where the angle brackets $<\cdot ,\cdot >$ denote the inner product, and ${\parallel \cdot \parallel }_2$ means L2 normalization.

5. Experiments

5.1. Experimental Settings

We conducted experiments on two large-scale real-world datasets.

• Porto comprises 1.7 million GPS trajectory data from taxi fleets in Porto, Portugal, offering rich insights into urban mobility and traffic patterns.
• BJ was collected in Beijing cabs in November 2015 [27,36]. It is made up of one million road network trajectories with timestamps and road network data. We utilize these to perform sampling, resulting in the GPS trajectories.

Following previous research [14,29], we filter the trajectories within the urban area, having between 20 and 200 trajectory points. The preprocessed trajectory statistics are illustrated in

Table 1. Statistics of preprocessed datasets.

Dataset	#Trajectories	#Mean Points	#Mean Length (km)
Porto 1	1,215,421	65	7.12
BJ 2	846,922	80	5.26

¹ https://www.kaggle.com/c/pkdd-15-predict-taxi-service-trajectory-i (accessed on 15 March 2025); ² https://github.com/aptx1231/START (accessed on 15 March 2025).

. In addition, each dataset is randomly partitioned into training, validation, and testing sets in a 7:1:2 ratio.

Baselines. We compare our method, STT-CL, with three heuristic similarity measures, DTW [10], EDwP [37] (an improved version of EDR [11]), and Fréchet [13], as well as with two self-supervised learning-based methods: t2vec [14] and TrajCL [29]. To ensure a fair comparison, we incorporate the time dimension as the third input dimension and also integrate the time dimension into the grid embeddings for both t2vec and TrajCL.

Implementation details. Following previous studies, the spatial division distance of the spatio-temporal grid is fixed to 100 m, and the duration of the time divisions is fixed to one hour, in order to capture the cyclical patterns of urban traffic throughout one day. For comparison, STT-CL utilizes the same trajectory augmentation techniques as TrajCL: point masking, and trajectory truncation. For both TrajCL and STT-CL, the number of multi-heads, encoder layers, and the contrastive temperature are 8, 2, and 0.05, respectively. For all learning-based methods, we set the dimensions of the similarity representation r at 256, and employ the Euclidean distance for similarity representation distance computation. For training, we employ Adam as the optimizer, with the initial learning rate, batch size, and maximum epochs set at 0.001, 256, and 20, respectively.

Our method is implemented using Python 3.9 and PyTorch 12.2.2. All experiments are carried out on a platform equipped with a 64-core Intel Xeon Platinum 8358P CPU and an NVIDIA GeForce RTX 3090 GPU.

Metrics. Following previous studies [14,15,29], we evaluate the methods in terms of two aspects, i.e., self-similarity and cross-similarity.

Self-similarity. We randomly select some trajectories from the test set to form the query set Q, where each trajectory T is a series of points, denoted as $T=<p_1,p_2,p_3,\cdots >$. We construct two subtrajectories, $T_a$ and $T_b$, from each trajectory based on the parity of their point indices, with $T_a$ containing all odd-indexed points, $T_a=<p_1,p_3,\cdots ,p_{2i+1},\cdots >$, and $T_b$ containing all even-indexed points, $T_b=<p_2,p_4,\cdots ,p_{2i},\cdots >$. These subtrajectories are assigned to sets $Q_1$ and $Q_2$, respectively. Additionally, we select some other trajectories from the test set to form the database D with $Q_2$, which is used for searching.

Following this methodology, we calculate two key metrics for self-similarity, mean rank ($MR$) and precision (P), formulated as follows:

$$\begin{array}{c}MR={\displaystyle \frac{1}{\left|Q_1\right|}}{\displaystyle \sum _{T_i\in Q_1}}{r}_i\\ P={\displaystyle \frac{1}{\left|Q_1\right|}}{\displaystyle \sum _{T_i\in Q_1}}{p}_i\end{array}$$

(21)

where $r_i$ denotes the rank of the most similar trajectory to $T_i$ in the search database D. $p_i$ equals 1 if the most similar trajectory to $T_i$ in $Q_1$ ranks first in D; otherwise, $p_i$ equals 0. A lower $MR$ or larger P indicates a better self-similarity performance, as similar trajectories are ranked higher.

Cross-similarity. We utilize the cross-distance deviation ($CDD$) metric to assess the robustness of the similarity measure in maintaining the similarity between two distinct trajectories, irrespective of the data augmentation strategies employed. The $CDD$ is computed as follows:

$$CDD={\displaystyle \frac{|d(T_a^{\prime },T_b^{\prime })-d(T_a,T_b)|}{d(T_a,T_b)}}$$

(22)

where $T_a$ and $T_b$ are two distinct trajectories, $d(\cdot ,\cdot )$ denotes the similarity distance between two trajectories, $T_a^{\prime }$ is a variant of $T_a$ obtained by trajectory augmentation, and $T_b^{\prime }$ is obtained in a similar manner. A lower value of $CDD$ indicates that the measured similarity is closer to the actual similarity, demonstrating a more robust similarity measure.

5.2. Experimental Comparison

We compare STT-CL with baselines in two aspects: effectiveness and robustness.

5.2.1. Effectiveness

Firstly, we explore the general effectiveness of the models, shown in

Table 2. MR and precision performance across different database sizes (20 k to 100 k).

		MR					Precision
Dataset	Method	20 k	40 k	60 k	80 k	100 k	20 k	40 k	60 k	80 k	100 k
Porto	DTW	18.14	26.178	36.14	51.487	60.571	0.531	0.512	0.491	0.475	0.456
	EDwP	13.75	15.148	18.154	21.147	25.442	0.54	0.521	0.506	0.498	0.478
	Fr’echet	10.41	11.154	15.145	17.245	19.754	0.597	0.578	0.561	0.545	0.52
	t2vec	1.408	1.892	2.347	2.777	3.215	0.839	0.769	0.729	0.696	0.67
	TrajCL	1.008	1.019	1.029	1.044	1.061	0.995	0.993	0.99	0.985	0.979
	STT-CL	1.008	1.016	1.022	1.032	1.036	0.995	0.993	0.992	0.988	0.983
	p-value	0.312	0.0387	0.0128	0.0116	0.0013	0.512	0.465	0.231	0.0735	0.0438
BJ	DTW	5.15	7.872	11.157	16.787	22.145	0.791	0.771	0.762	0.748	0.732
	EDwP	3.54	5.45	8.461	13.457	16.45	0.841	0.83	0.814	0.795	0.781
	Fr’echet	2.541	4.145	6.45	9.571	12.154	0.868	0.851	0.838	0.815	0.801
	t2vec	1.104	1.149	1.179	1.228	1.27	0.923	0.897	0.884	0.864	0.849
	TrajCL	1.003	1.003	1.004	1.007	1.009	0.997	0.997	0.996	0.994	0.994
	STT-CL	1.002	1.003	1.003	1.005	1.007	0.998	0.997	0.997	0.995	0.994
	p-value	0.583	0.653	0.477	0.407	0.393	0.654	0.781	0.541	0.47	0.487

. Keeping the size of the query set $Q_1$ fixed at 1000 trajectories (|$Q_1$| = 1 k), we compare the performance of the self-similarity metric across various sizes of search database D, where $\left|D\right|$ ranges from 20 k to 100 k. Furthermore, to assess the statistical significance of the performance differences between STT-CL and TrajCL, we conduct a significance analysis using t-tests. Specifically, we calculate the p-values to evaluate the significance of the observed performance differences across the various metrics.

Heuristic methods exhibit superior performance in the spatio-temporal trajectory similarity computation task over the general spatial trajectory similarity computation task due to the increased emphasis on temporal dimension similarity, among which the Fréchet distance method exhibits the most outstanding performance. However, compared to all learning-based methods, the effectiveness of heuristic approaches remains inferior. STT-CL and TrajCL, two contrastive learning techniques, exhibit greater effectiveness than t2vec. However, according to the significance analysis, when the size of the search database is relatively small, there is no significant performance difference between the two models, especially in terms of precision.

The comparison between the two datasets clearly shows that the Porto dataset exhibits a lower trajectory similarity compared to the BJ dataset, which better facilitates model performance assessment and makes it a more appropriate choice for an experimental dataset.

5.2.2. Robustness

Furthermore, we evaluate the robustness of the models by comparing self-similarity and cross-similarity metrics in the context of low-quality trajectories, as shown in

Table 3. MR and precision performance across different down-sampling rates (0.1 to 0.5) in self-similarity evaluation.

		MR					Precision
Dataset	Method	0.1	0.2	0.3	0.4	0.5	0.1	0.2	0.3	0.4	0.5
Porto	DTW	72.148	110.12	150.215	200.406	270.587	0.412	0.354	0.287	0.254	0.212
	EDwP	32.145	42.254	61.12	70.875	91.276	0.321	0.451	0.432	0.394	0.351
	Fréchet	28.124	51.242	75.45	125.548	179.412	0.387	0.341	0.31	0.281	0.264
	t2vec	8.763	26.954	42.572	79.063	300.898	0.623	0.549	0.466	0.395	0.295
	TrajCL	1.089	1.318	2.248	8.89	27.642	0.949	0.812	0.756	0.597	0.481
	STT-CL	1.063	1.166	1.777	2.19	5.109	0.953	0.908	0.841	0.759	0.63
	p-value	0.0008	<0.0001	<0.0001	<0.0001	<0.0001	0.0016	<0.0001	<0.0001	<0.0001	<0.0001
BJ	DTW	30.154	36.45	44.18	88.15	150.487	0.712	0.641	0.612	0.512	0.419
	EDwP	18.45	21.109	22.62	24.375	30.26	0.725	0.701	0.687	0.658	0.635
	Fréchet	15.154	18.1	26.48	49.548	75.412	0.756	0.675	0.598	0.512	0.425
	t2vec	1.336	1.462	1.786	2.368	4.119	0.832	0.803	0.741	0.678	0.563
	TrajCL	1.021	1.04	1.098	1.298	1.87	0.985	0.97	0.925	0.865	0.712
	STT-CL	1.008	1.022	1.059	1.117	1.338	0.993	0.987	0.958	0.933	0.871
	p-value	0.0208	0.0093	0.0003	<0.0001	<0.0001	0.0411	0.0103	0.0012	<0.0001	<0.0001

and

Table 4. CDD performance across different down-sampling rates (0.1 to 0.5) in cross-similarity evaluation.

Dataset	Method	0.1	0.2	0.3	0.4	0.5
Porto	DTW	0.0312	0.0359	0.0398	0.0435	0.047
	EDwP	0.0075	0.0198	0.0301	0.0358	0.0401
	Fréchet	0.0085	0.0221	0.033	0.0402	0.0485
	t2vec	0.0217	0.0266	0.0312	0.0355	0.0445
	TrajCL	0.0085	0.0132	0.0199	0.0251	0.0298
	STT-CL	0.012	0.0159	0.0197	0.0231	0.0287
	p-value	0.0062	0.0212	0.6328	0.0231	0.0412
BJ	DTW	0.0236	0.0288	0.0356	0.0448	0.0497
	EDwP	0.0032	0.0121	0.0188	0.0268	0.0351
	Fréchet	0.0048	0.0098	0.0189	0.0284	0.0374
	t2vec	0.0201	0.0216	0.0237	0.0258	0.0287
	TrajCL	0.0076	0.0089	0.0169	0.0215	0.0253
	STT-CL	0.0098	0.0121	0.0146	0.0173	0.0212
	p-value	0.0673	0.0056	0.0181	<0.0001	<0.0001

. We fix the sizes of query set $Q_1$ and search database D at 1 k and 100 k, respectively, applying an equal down-sampling rate to both $Q_1$ and D for down-sampling, and perform the calculation of metrics under these conditions, where the down-sampling rate is varied from 0.1 to 0.5 (the higher the down-sampling rate, the lower the trajectory quality). Similarly, we also conduct a significance analysis to compare STT-CL and TrajCL.

Contrary to a previous study [15], we do not assess performance on a distorted trajectory dataset, as it has been shown that trajectory distortion has negligible effects on the computation of trajectory similarity [29].

Self-similarity. Among all heuristic methods, EDwP demonstrated the best performance on low-quality trajectory data, while the Fréchet method showed a rapid decline in performance as the trajectory degradation increased (with higher down-sampling rates).

STT-CL exhibits the lowest MR and highest precision metrics among all methods, regardless of down-sampling rates. This underscores the optimal robustness of STT-CL in environments with low-quality trajectories. Furthermore, it is observed that TrajCL experiences a significant disparity in self-similarity metrics compared to STT-CL, especially when the trajectory quality is exceedingly low (with a down-sampling rate exceeding 0.3). This discrepancy is attributed to the inferior performance of the grid embedding method and the TrajCL backbone encoder, a finding corroborated by the subsequent ablation study.

Cross-similarity. Due to computational differences, at a down-sampling rate of 0.1, certain heuristic methods (EDwP and Fréchet) exhibit a lower CDD than learning-based methods. However, as the down-sampling rate increases, the similarity distance between trajectories considerably expands, resulting in a decrease in the cross-similarity performance of heuristic methods compared to learning-based ones.

Comparing STT-CL with TrajCL, it is observed that when the down-sampling rate is below 0.2, TrajCL exhibits a lower CDD, reflecting superior cross-similarity performance. In contrast, when the down-sampling rate exceeds 0.2, the CDD for TrajCL exceeds that of STT-CL. This clearly indicates that a decline in trajectory quality severely and broadly affects TrajCL’s performance, thereby further confirming STT-CL’s robust performance in the context of low-quality trajectories.

5.2.3. Efficiency

The efficiency of trajectory similarity computation is equally crucial, especially for real-world applications where large-scale datasets are involved. In this section, we compare the training and testing efficiency of different models on the Porto dataset, as shown in Figure 4.

Training time. To evaluate the training efficiency of different models on datasets of varying sizes, we conducted experiments using training sets of 100 k, 200 k, and 400 k trajectories. For each training set size, we recorded the one-epoch training times of different models and compared their performance in terms of training efficiency on large-scale datasets. In the experiments, contrastive learning-based methods, STT-CL and TrajCL, were nearly five times faster than t2vec in terms of training time. However, STT-CL took slightly longer to train than TrajCL. Considering that STT-CL involves an additional feature fusion step, we performed further tests by removing the fusion part in STT-CFE and measuring the training time, as shown in Figure 4. It can be seen that the fusion step in STT-CL accounts for 4% of the total time, and the remaining part still takes slightly longer than TrajCL.

Testing time. To evaluate the testing efficiency of different models, we conducted experiments on the Porto dataset using a fixed query set $Q_1$ of size 1 k and search database D of size 100 k. We measured the time taken by each model to compute the trajectory similarities between the query and the search dataset. The results showed that t2vec performed better on the CPU, exhibiting faster testing times compared to STT-CL and TrajCL. However, on the GPU, t2vec exhibited slower testing times. This is due to the recursive matrix computations involved in t2vec, which are less optimized for parallel computation on GPU. The testing time for STT-CL and TrajCL did not show significant differences on either CPU or GPU. Despite the overall increased computational cost of the STT-CL model, this difference during testing is not noticeable when handling smaller query sets and datasets.

5.3. Ablation Study

We analyze the impact of the model components by comparing self-similarity metrics (MR and precision) at different down-sampling rates. We present the results solely for the Porto dataset, and the BJ dataset demonstrates a similar trend.

The impact of grid embedding. We assessed our two proposed optimized grid embedding techniques against the method utilized in TrajCL, as depicted in Figure 5. ‘node2vec’ and ‘node2vec+’ in the figure, respectively, denote the original and optimized versions of the node2vec methodology, while ’word2vec+’ signifies the refined FastText approach (used in the comparative experiments).

The results reveal that the robustness of the node2vec method substantially increases following optimization. Additionally, the ‘node2vec+’ approach exhibits superior performance to the ‘word2vec+’ method when the down-sampling rate is below 0.2; however, its effectiveness diminishes at higher down-sampling rates. This phenomenon is attributed to high-quality trajectories more accurately representing trajectory similarities through spatial–temporal proximity relations, whereas low-quality trajectories more effectively convey similarity through spatial semantic relationships embedded in historical trajectories.

The impact of the encoder. We conduct a comparison between our proposed STT-CFE model and the encoder implemented in Transformer and TrajCL, as depicted in Figure 6. Within these experiments, the input to the Transformer’s encoder comprises concatenated coarse-grained and fine-grained matrices, while TrajCL’s encoder, DualSTB, is capable of directly integrating coarse-grained and fine-grained matrices as its inputs.

The result indicates that STT-CFE performs well at all evaluated down-sampling rates. Furthermore, we observed a notable decline in DualSTB’s robustness when faced with low-quality trajectories (specifically, when the down-sampling rate exceeds 0.3), which aligns with the significant performance degradation previously noted in TrajCL experiments.

The impact of feature combination. In Section 4.4.3, we introduced four schemes for feature combination, and we conducted experimental comparisons among these schemes, as shown in Figure 7.

The result indicates that scheme (a) overall exhibits the best performance in the MR experiments. However, scheme (c) outperforms scheme (a) in terms of precision metrics when the down-sampling rate exceeds 0.3, but it shows poorer MR metrics. This is due to strategy (c)’s exclusive reliance on the coarse-grained branch, which leads to difficulty in distinguishing between trajectories with similar structures.

Parameter Study

In this section, we focus on studying the effect of various parameters on the performance of the model, particularly how they influence the handling of low-quality trajectories, i.e., when the down-sampling rate is greater than or equal to 0.3. In the subsequent parameter experiment figures, the symbol ${\rho }_{\mathrm{d}}$ represents the down-sampling rate.

The impact of the number of encoder layers. We explore the impact of the number of encoder layers on model performance by varying the number of encoder layers from one to five, as shown in Figure 8. The experimental results show that the overall performance improves as the number of encoder layers increases. However, when the number of layers reaches three, the performance improvement becomes marginal, indicating that additional layers do not contribute significantly beyond this point. Given that increasing the number of layers also leads to a substantial increase in computational overhead, we conclude that using two encoder layers strikes a balance between performance enhancement and computational efficiency.

The impact of the number of embedding dimensions. We explore the impact of the number of embedding dimensions by varying it from 64 to 1024, as shown in Figure 9. The experimental results show that overall performance increases with the number of embedding dimensions up to a certain point, but then starts to decline. This trend can be attributed to overfitting when the number of embedding dimensions becomes too large. Notably, the overfitting phenomenon becomes more pronounced as the quality of the trajectories decreases. However, it is important to highlight that the precision metric is less sensitive to overfitting compared to the mean rank. Thus, we default the number of embedding dimensions to 256.

6. Conclusions

This study presents STT-CL, an innovative contrastive learning framework for spatio-temporal trajectory similarity computation that systematically captures latent spatio-temporal dependencies. Our primary theoretical contribution lies in the proposed Spatio-Temporal Trajectory Cross-Fusion Encoder (STT-CFE), which establishes a hierarchical feature integration paradigm that adeptly integrates coarse-grained and fine-grained features. The encoder demonstrates exceptional robustness in processing low-quality trajectories with irregular sampling rates and missing data points.

Through rigorous empirical validation on large-scale urban mobility datasets, STT-CL achieves consistent performance gains of 12.7–18.4% over state-of-the-art baselines across a range of critical metrics. These results underline the necessity of joint spatio-temporal embedding spaces for trajectory representation learning and highlight the robustness of contrastive learning in addressing the challenges of trajectory similarity evaluation.

The framework advances ITS by enabling more accurate trajectory analysis for congestion prediction, route optimization, and mobility pattern discovery. Future extensions may explore (a) integration with graph neural networks for network-constrained movement modeling, and (b) domain adaptation techniques for cross-city deployment.