A ResNet1D-AttLSTM-Based Approach for Ship Trajectory Classification

Abstract

To improve the feature extraction method for ship trajectories and enhance trajectory classification performance, this paper proposes a ship trajectory classification model that combines a one-dimensional residual network (ResNet1D) and an attention-based Long short-term memory network (AttLSTM). The model aims to address the limitations of traditional methods in extracting feature patterns jointly represented by non-adjacent local regions in ship trajectories, optimized through the introduction of a self-attention mechanism. Specifically, the model first utilizes the ResNet1D module to progressively extract implicit motion pattern features from local to global levels, while the AttLSTM module captures temporal sequence features of ship trajectories. Finally, the fusion of these two types of features generates a more comprehensive and rich spatiotemporal motion feature representation, enabling accurate classification of five types of ship trajectories, including towing vessels, fishing vessels, sailing vessels, passenger ships, and tankers. Experimental results show that this model excels on extensive real-world trajectory datasets, achieving a classification accuracy of 89.7%, significantly outperforming models relying solely on single feature sets or lacking integrated attention mechanisms. This not only validates the model’s superior performance in ship trajectory classification tasks but also demonstrates its potential and effectiveness for practical applications.

1. Introduction

The analysis and mining of ship trajectory data hold significant application value in various fields, such as maritime traffic safety [1], traffic management and planning [2,3], and marine environmental protection [4]. This has spurred extensive research on ship trajectories, including trajectory prediction [5,6,7,8], anomaly detection [9,10,11], channel planning [12,13,14], behavior pattern recognition [15,16,17,18,19], and traffic flow analysis [20]. Trajectory category information plays a crucial supporting role in anomaly behavior detection and ship navigation supervision. However, the actual collected ship trajectory data may suffer from quality issues such as missing category information and labeling errors, which hinder the accuracy and reliability of subsequent tasks like navigation supervision and anomaly behavior detection. Therefore, research on ship trajectory classification methods is of great theoretical and practical significance.

Current ship trajectory classification algorithms mainly include traditional machine learning-based classification algorithms and neural network-based classification algorithms. The former includes algorithms based on logistic regression [21], conditional random fields [22], decision trees [23], random forests [24,25], K-nearest neighbors (KNNs) [26], support vector machines [27], etc. Although these algorithms have achieved some success, their reliance on expert-defined features makes the feature representation susceptible to subjective influences. Additionally, differences in navigation rules and environments across different sea areas necessitate frequent adjustments to feature combinations and parameter settings, limiting their practical application effectiveness. In contrast, neural network-based methods automatically learn deep-level features through nonlinear feature transformations, avoiding the limitations of manual feature engineering, and exhibit better generalization in practical applications due to their end-to-end learning capabilities. Currently, neural network-based ship trajectory classification algorithms mainly include convolutional neural networks (CNNs) and recurrent neural networks (RNNs).

CNNs and their variants, leveraging their translation invariance and convolutional kernel weight-sharing properties, can achieve feature extraction from the local to the global with a relatively small number of parameters, forming high-level abstract feature representations. This characteristic has facilitated their application in the field of trajectory classification. Kontopoulos et al. [28] transforms the ship trajectory classification problem into an image recognition task by visualizing four types of ship trajectory motion patterns and introducing pre-trained CNN models such as the Visual Geometry Group Network (VGG) [29] for classification. Yang et al. [30] generated trajectory images containing navigation pattern information based on the motion and shape characteristics of ship trajectories and constructed a CNN to achieve trajectory classification. Guo et al. [31] converted ship trajectory data into images and built a deep convolutional neural network classification model based on ResNet50.

RNNs and their variants, as neural network models specifically designed for processing sequential data, can effectively capture the temporal dependencies of sequential data, making them widely used in ship trajectory data analysis. Jiang et al. [32] proposed a partitioned gated recurrent unit (pGRU) architecture, enhancing the model’s expressive power in low-dimensional and heterogeneous feature spaces through partitioned activation learning in the feature space. De Freitas et al. [33] innovatively combined time series models with computer vision models, using bidirectional long short-term memory networks (Bi-LSTM) to extract temporal features from AIS data streams.

To further enhance the completeness and richness of ship trajectory feature representations, researchers have begun exploring hybrid architectures combining CNNs and RNNs. Zhang et al. [34] proposed a CNN-LSTM progressive trajectory classification model. By segmenting trajectories into sub-segments, the model uses CNNs to extract local motion pattern features within each sub-segment, which are then input into an LSTM for classification. However, this progressive method relies on the granularity of local motion patterns in sub-segments for temporal feature extraction, potentially leading to information loss. Cui et al. [35] proposed a 1DCNN-LSTM hybrid classification model, achieving classification by fusing the results of the two networks at the classifier level, but this fusion may limit the model’s comprehensive understanding of the original trajectory data.

Despite significant progress in using AIS data for ship classification, existing research still faces the following limitations: (1) Image-based methods may lead to information loss during data conversion, and their applicability is limited in small dataset scenarios due to the difficulty in visualizing certain types of features; (2) RNNs and their variants are constrained by sequential processing mechanisms and long-range dependency issues, as well as the sequential traversal characteristics of convolution operations, making it difficult for current methods to effectively extract joint motion patterns in non-adjacent regions; (3) when using convolutional networks to process trajectory sequences (rather than trajectory images), existing methods do not consider using residual blocks to expand network depth to enhance model scalability. As the number of network layers and input trajectory lengths increase, these methods may face challenges in addressing gradient vanishing or explosion issues.

To address these issues, this study proposes the following innovative solutions:

• Non-adjacent co-feature extraction based on self-attention: To overcome the limitations in extracting features from non-adjacent regions, this study leverages the self-attention mechanism [36], which can directly attend to any position in the sequence and dynamically focus on the most useful information for the current task, to construct the AttLSTM module. By innovatively integrating the self-attention mechanism with the LSTM architecture, the model can more effectively extract feature patterns that require joint representation across multiple regions, even if these patterns are discontinuously distributed within a region.
• Depth-scalable architecture with residual learning: To enhance model scalability in sequence tasks while minimizing gradient-related concerns, this study proposes the Resnet1D module. This module combines one-dimensional convolution with skip connections, constructing a multi-scale feature pyramid to ensure stable gradient propagation while expanding model depth.

Based on these innovations, this paper constructs the ResNet1D-AttLSTM hybrid classification model for ship trajectories, achieving multi-level, multi-dimensional feature extraction and fusion: the model performs multi-granularity spatial feature mining through the ResNet1D module, captures temporal dynamic evolution patterns using AttLSTM, and finally generates high-integrity spatiotemporal joint feature representations through a designed projection fusion strategy for ship trajectory classification.

2. Methods

The ship trajectory classification method proposed in this paper primarily comprises two parts: data preprocessing and the construction of a trajectory classification model. During the data preprocessing phase, we focus on denoising techniques and methods for constructing trajectory sequences from the dataset of trajectory points. For the construction of the trajectory classification model, we designed a hybrid classification model that integrates ResNet1D and AttLSTM.

2.1. Data Preprocessing

Data quality plays a crucial role in classification algorithms based on neural network models, and the process of collecting ship trajectory data can introduce noisy data. Therefore, it is necessary to perform data preprocessing. Taking the AIS dataset as an example, the data preprocessing workflow is illustrated in Figure 1.

Noise removal is necessary because AIS data can contain false or erroneous information due to intentional tampering by third parties, operational errors, or system malfunctions during its generation. Missing value data, outlier data, and duplicate data are common types of noise found in AIS datasets, with specifics as follows:

• Missing value data refers to records where critical attributes such as longitude, latitude, speed over ground, course over ground, and time are absent.
• Outlier data includes records where the values for important attributes like longitude, latitude, speed over ground, course over ground, and time fall outside reasonable ranges.
• Duplicate data consists of identical records that appear multiple times within the dataset.

For these three types of noisy data, we adopt a deletion approach for handling them. Field selection aims to reduce the dimensionality of the dataset to lower computational complexity. In the AIS dataset, this paper selects seven key fields: maritime mobile service identity (MMSI), vesseltype, time, course over ground (COG), speed over ground (SOG), latitude and longitude. Other fields are removed. These selected fields effectively reflect the dynamic behavior and location information of vessels while minimizing redundant data. Additionally, category filtering refers to the process of removing data from all categories except those relevant to the study. Specifically, this involves retaining records from five specific types of vessels—towing vessels, fishing vessels, sailing vessels, passenger ships, and tankers—based on their distinct characteristics and the availability of sufficient data, while excluding data from other categories in the AIS dataset. This step is necessary because the original AIS dataset contains numerous ship categories, which could introduce unnecessary complexity and dilute the focus of the analysis.

In the AIS dataset, certain types of vessels are overrepresented, resulting in a significantly larger volume of trajectory point data for these categories, while other types have relatively fewer data points. To address this imbalance and facilitate subsequent preprocessing steps, after completing the noise removal process, we performed random undersampling on the majority classes. This involved randomly removing a portion of the trajectory data for the overrepresented vessel types to achieve a more balanced distribution across all categories.

As trajectory classification algorithms process objects composed of a series of ordered trajectory points forming trajectory segments, and the AIS dataset is a collection of numerous independent trajectory points, it is necessary to organize these isolated points into trajectory segments according to certain principles. In other words, we need to extract ship trajectory sequences. The method used for extracting ship trajectory sequences directly impacts the design of the classification algorithm; different extraction methods can generate trajectory sequences with varying important feature patterns, thus requiring the design of corresponding classification algorithms and the establishment of appropriate model hyperparameters.

For instance, the significant features of trajectories differ across various time scales. If we define long-term trajectories as navigation records over three months and short-term trajectories as those within one hour, then, in long-term trajectories, characteristics such as anchoring habits, route selection, and destination preferences are more discriminative for ship types. In contrast, these features hold less importance in short-term trajectories. This paper focuses on the research of classification algorithms for short-term trajectories, and the method for extracting trajectory sequences is as follows:

• Fixed time window-based segmentation: For the navigation records of each ship in the AIS dataset, an initial trajectory segmentation is performed using a sliding window approach. Specifically, a fixed time window of 60 min is employed to traverse the entire navigation record in chronological order. Each window’s trajectory points are aggregated into an independent trajectory sequence.
• Removal of anchoring points: A speed threshold, $V_T$, is set; if the speed of a trajectory point is less than $V_T$, it is considered an anchoring point and removed from the trajectory sequence. Anchoring points are removed because they contain static data that contribute little to the analysis of vessel navigation behavior and may even introduce noise.
• Outlier removal: An heuristic outlier detection method [34] is employed. Using the current trajectory point as the center and $V_{max}\times {∆}_t$ as the radius (where $V_{max}$ is the upper limit of the reasonable speed range and ${∆}_t$ is the time interval between the current and next trajectory points), a circular region is defined. If the next trajectory point falls outside this circular region, it is identified as an outlier. Outliers are typically caused by sensor malfunctions, signal interference, or other external factors leading to data anomalies, which can interfere with the analysis of true vessel navigation behavior.
• Trajectory segmentation: A time interval threshold, $T_{seg}$, is set. In the trajectory sequence, the time interval between each trajectory point and the previous one is calculated. If the time interval exceeds $T_{seg}$, it is marked as a segmentation point, dividing the trajectory sequence into multiple subsequences. The primary purpose of trajectory segmentation is to ensure that the trajectory points within each segment are more closely related in space and time, avoiding data dispersion caused by long time intervals. This helps the model learn more accurate behavioral patterns.
• Sequence length filtering: A trajectory point count threshold, $P_{num}$, is established. The number of trajectory points in each sequence is calculated, and sequences with fewer points than $P_{num}$ are discarded. Removing overly short sequences reduces the impact of noise and allows the model to focus on high-quality data.

After extracting the trajectory sequences, the dataset may still suffer from class imbalance. To address this issue, we performed undersampling on the majority classes in the trajectory sequence dataset by randomly removing a portion of the trajectory sequences from these classes to achieve a more balanced distribution across all categories.

Furthermore, because certain features within the trajectory data have different scales and units, to prevent the model from becoming overly sensitive to some features—which could lead to a decrease in robustness—we applied min–max normalization. This method standardizes all features to a uniform range, ensuring that no single feature disproportionately influences the model due to its scale.

2.2. Construction of the ResNet1D-AttLSTM Model

As shown in Figure 2, the ResNet1D-AttLSTM ship trajectory classification model primarily comprises a feature extraction module based on ResNet1D and AttLSTM, as well as a classification module based on a multilayer perceptron (MLP).

After completing the data preprocessing, the model first organizes the ship trajectory sequences into a five-channel format based on five features of each trajectory point (longitude, latitude, SOG, COG, and time) and inputs them into the ResNet1D module. Through convolutional operations and multiple residual block processes, this module extracts high-level motion features from the sequence. Simultaneously, the ship trajectory sequences are also fed into the AttLSTM module to capture the temporal variation characteristics of the trajectory sequences.

Finally, the two types of features extracted from the ResNet1D and AttLSTM modules are concatenated and fused. These combined features are then passed through a multilayer perceptron to output the predicted results for trajectory type classification.

2.2.1. ResNet1D Module

ResNet1D is a network model whose design is based upon residual network architecture [37], utilizing exclusively one-dimensional convolutional layers. It is specifically tailored for handling one-dimensional sequence data such as time series and audio signals. ResNet1D inherits the residual blocks and skip connections from ResNet, which facilitate the learning of identity mappings, thereby alleviating the problems of vanishing and exploding gradients that are common in deep networks. Additionally, ResNet1D is constructed in a modular fashion, allowing for the easy expansion of network depth by stacking multiple residual blocks to meet the requirements of various tasks.

As illustrated in Figure 2, within the ResNet1D module, the trajectory sequences are organized into a five-channel representation based on five features of each trajectory point (longitude, latitude, SOG, COG, and time), which serves as the input. This module initially passes the trajectory sequences through a one-dimensional convolutional layer, followed by a batch normalization layer and a ReLU activation function to extract low-level features from the trajectory sequences. The convolutional layer is configured with $k$ convolutional kernels, each of size $c_{in}\times h$ (where $c_{in}$ is the number of input channels and $h$ is the width of the convolution kernel).

Subsequently, the data flows through an intermediate layer composed of $n$ residual blocks. To enhance the model’s generalization capability and address the issue of variable feature dimensions caused by trajectories of non-uniform length, a global average pooling layer is applied. This results in a high-level feature representation of ship trajectory sequences with fixed dimensions. The architecture of the residual block is illustrated in Figure 3.

Each residual block consists of two one-dimensional convolutional layers with the same number of output channels, followed by a batch normalization layer and a ReLU activation function after each convolutional layer. The input data bypasses these two convolution operations through a skip connection, which adds the input directly to the output before the final ReLU activation.

In the first convolutional layer, $c$ convolution kernels for which $W$ = {$w_1,w_2$, …, $w_c$} are set, with each kernel size being $k\times h$. In the second convolutional layer, $c$ convolution kernels for which $U$ = {$u_1,u_2$, …, $u_c$} are set, with each kernel size being $c\times h$. Zero-padding and a stride of 1 are used to maintain the feature dimensions after the convolution operations.

Assuming the sequence length is $len$, the one-dimensional convolution operation is performed along the sequence direction using convolution kernels $W$ and $U$ on the input $X_i=\left\{x_{1,i:i+h-1}, x_{2,i:i+h-1} ,\cdots , x_{k,i:i+h-1}\right\}\left(0\le i\le len\right)$. The result of this operation is then added to $X_i$, and the sum passes through the activation function to produce new features. The new features, $Y_i$, generated by each residual block can be represented by Equation (1):

$$\left\{\begin{array}{l}{f}_1=ReLU\left(BN\left({\sum }_{m=1}^c {\sum }_{n=0}^{h-1} w_{m,n}\cdot x_{m,i+n}+b_1\right)\right)\\ f_2=ReLU\left(BN\left({\sum }_{m=1}^c {\sum }_{n=0}^{h-1} u_{m,n}\cdot f_{1,m,i+n}+b_2\right)\right)\\ Y_i=ReLU\left(f_2+X_i\right)\end{array}\right.$$

(1)

In the equation, $BN$ denotes the batch normalization operation, $m$ represents the current channel index, and $n$ represents the position index within the convolution kernel width $h$. $b_1$ and $b_2$ denote the biases, while $f_1$ and $f_2$ represent the output features after the first and second convolution-BN-ReLU operations, respectively. Thus, the new features obtained by the residual block are given by $Y_i=\{y_{1,i}, y_{2,i},\cdots , y_{c,i}\} \left(0\le i\le len\right)$.

2.2.2. AttLSTM Module

LSTM networks alleviate the vanishing gradient problem in traditional RNNs to a certain extent by introducing gating mechanisms, thereby improving the ability to model long-term dependencies. However, when processing sequential features, LSTMs adopt a sequential approach, capturing information only from the beginning of the sequence to the current time step, while underutilizing information beyond the current position. Moreover, LSTMs have limitations in extracting feature patterns jointly expressed by multiple non-adjacent regions. Specifically, LSTMs struggle to effectively capture complex patterns that are discontinuously distributed in the sequence. Although theoretically capable of capturing such patterns at the final step of processing, their modeling capability may degrade due to the loss of early information.

To address these issues, this study constructs an AttLSTM module by integrating a multi-head self-attention mechanism into the final layer of the LSTM. The self-attention mechanism directly calculates the correlations between each position in the trajectory sequence and all other positions, enabling the effective capture of global feature patterns that are discontinuously distributed while simultaneously focusing on the joint behavior of multiple regions. The application of the multi-head mechanism further enhances the model’s understanding of the entire sequence, thereby improving its ability to model complex patterns.

As shown in Figure 4, the AttLSTM module consists of an LSTM layer and an attention layer. The input to this module is the preprocessed ship trajectory sequences. Due to the variable lengths of these input sequences, we statistically determine the maximum length $L_{max}$ from all trajectory sequences in the dataset to standardize the input length for the LSTM layer. For trajectory sequences shorter than $L_{max}$, zero-padding is applied to extend them to $L_{max}$.

First, the trajectory points in the sequence are fed into the LSTM layer in chronological order to initially capture the temporal variation characteristics of the trajectory sequences. Then, a multi-head self-attention mechanism is applied to further extract and emphasize information from key time points within the sequence. This enhances the model’s focus on important temporal features.

In the LSTM layer, the number of network layers is set to $N$. Each LSTM unit within a layer contains three gates (input gate $i_t^{\left(l\right)}$, forget gate $f_t^{\left(l\right)}$, and output gate $o_t^{\left(l\right)}$) where $l$ denotes the current layer index. Each LSTM unit performs the following process for time step $t$: given the input $x_t^{\left(l\right)}$, the previous hidden state $h_{t-1}^{\left(l\right)}$, and the previous cell state $c_{t-1}^{\left(l\right)}$, it calculates the current hidden state $h_t^{\left(l\right)}$ and the current cell state $c_t^{\left(l\right)}$. The update process is described by Equations (2)–(8), as follows:

$$f_t^{\left(l\right)}=\sigma \left({\mathit{W}}_{\mathit{f}}^{\left(\mathit{l}\right)}[h_{t-1}^{\left(l\right)},x_t^{\left(l\right)}]+b_f^{\left(l\right)}\right)$$

(2)

$$i_t^{\left(l\right)}=\sigma \left({\mathit{W}}_{\mathit{i}}^{\left(\mathit{l}\right)}[h_{t-1}^{\left(l\right)},x_t^{\left(l\right)}]+b_i^{\left(l\right)}\right)$$

(3)

$$j_t^{\left(l\right)}=tan h\left({\mathit{W}}_{\mathit{j}}^{\left(\mathit{l}\right)}[h_{t-1}^{\left(l\right)},x_t^{\left(l\right)}]+b_j^{\left(l\right)}\right)$$

(4)

$$c_t^{\left(l\right)}=f_t^{\left(l\right)}\ast c_{t-1}^{\left(l\right)}+i_t^{\left(l\right)}\ast j_t^{\left(l\right)}$$

(5)

$$o_t^{\left(l\right)}=\sigma \left({\mathit{W}}_{\mathit{o}}^{\left(\mathit{l}\right)}[h_{t-1}^{\left(l\right)},x_t^{\left(l\right)}]+b_o^{\left(l\right)}\right)$$

(6)

$$h_t^{\left(l\right)}=o_t^{\left(l\right)}\ast tan h\left(c_t^{\left(l\right)}\right)$$

(7)

$$x_t^{(l+1)} :=h_t^{\left(l\right)}$$

(8)

In the equations:

• $\ast$ denotes element-wise multiplication (Hadamard product).
• $:=$ denotes assignment.
• $\mathit{W}$ and $b$ represent the weight matrices and bias parameters of the gate controllers, respectively.
• $\sigma$ and $\mathrm{t}\mathrm{a}\mathrm{n} h$ denote the Sigmoid activation function and the hyperbolic tangent activation function, respectively.
• $j_t$ represents the new information to be added to the cell state.

The update process of the LSTM unit is illustrated in Figure 5. Finally, the output of the LSTM layer is $H=\{h_1^{\left(N\right)},h_2^{\left(N\right)},\cdots ,h_{L_{max}}^{\left(N\right)}\}$, which serves as the input to the attention layer.

In the attention layer, $i$ attention heads are set up. As the LSTM layer is capable of extracting positional information of trajectory points within the sequence, no positional encoding is added to the input. The computation process for multi-head attention is as follows:

For each attention head $i$, the input $H$ undergoes three linear transformations to obtain the query matrix $Q_i$, key matrix $K_i$, and value matrix $V_i$, as shown in Equation (9):

$$Q_i=H{W}_i^Q,K_i=H{W}_i^K,V_i=H{W}_i^V$$

(9)

where $W_i^Q$, $W_i^K$, and $W_i^V$ are the linear transformation matrices.

Next, the output for each attention head based on scaled dot-product attention is computed according to Equation (10):

$${head}_i=softmax\left({\displaystyle \frac{Q_i{K}_i^T}{\sqrt{d_k}}}\right)V_i$$

(10)

where $d_k$ is the dimensionality of the key vectors.

Finally, the outputs from all attention heads are concatenated and passed through a linear transformation with weight matrix $W^O$ to produce the output of the attention layer, as given by Equation (11):

$$O=\mathit{Concat}\left({head}_1,\dots ,{head}_h\right)W^O=\{o_1,o_2,\cdots ,o_{L_{max}}\}$$

(11)

2.2.3. Trajectory Classification Based on Multilayer Perceptron

First, to effectively integrate the features extracted by the ResNet1D module and the AttLSTM module, we applied global average pooling (GAP) to the feature maps output by the ResNet1D module. By calculating the average value of each channel across the time dimension, we obtained a fixed-length one-dimensional vector. For the output feature $O$ of the AttLSTM module, we selected the state at the last time step as its one-dimensional representation. These two processing methods not only reduce the number of parameters but also retain the main information of the features, thereby helping to prevent overfitting.

Next, we concatenated the two aforementioned one-dimensional feature vectors to form a comprehensive feature vector. This vector was then fed into a multi-layer perceptron (MLP) for classification tasks. The configuration of the MLP in this study is as follows:

• Number of layers: 2 hidden layers.
• Number of neurons per layer:
  • The first hidden layer has twice the number of neurons as the dimensionality of the comprehensive feature vector.
  • The second hidden layer has half the number of neurons as the first hidden layer.
• Activation Function: ReLU activation function is used for all hidden layers.

Finally, the MLP outputs a one-dimensional vector of length $s$, where $s$ equals the number of ship types. For each value $z_i$ ($1$ ≤ $i$ ≤ $s$) in the output vector, we apply the softmax function for probability normalization to obtain the probability distribution across categories, as shown in Equation (12):

$$P_i={\displaystyle \frac{e^{z_i}}{{\sum }_{k=1}^s e^{z_k}}}$$

(12)

where $P_i$ represents the probability that the ship trajectory is predicted to be of the i-th type and satisfies ${\sum }_{\mathrm{i}=1}^s{P}_i$ = 1. The category with the highest probability value is chosen as the predicted class for the corresponding ship trajectory.

3. Experiment

3.1. Data Analysis and Preprocessing

The dataset used in this study is sourced from publicly available automatic identification system (AIS) ship trajectory data collected by the United States Coast Guard, USA. The data is accessible at https://marinecadastre.gov/ais/ (accessed on 3 April 2024). For this experiment, we selected 86,431,580 AIS records from 1 June to 10 June 2022, as our research subjects. Due to the large volume of data, the storage and preprocessing processes were implemented within a MySQL database.

During the denoising process based on our data preprocessing methods, we set the reasonable speed range to between 0 and 40 knots ($V_{max}=40$), allowed for all possible headings, and considered global latitude and longitude ranges. According to these filtering criteria, a total of 565,710 trajectory points with missing values, outliers, or duplicates were identified and removed. After field selection and category filtering, the data distribution across different vessel categories was summarized (see

Table 1. Overview of data volume statistics for various types of ships.

Type of Ship	Fishing	Towing	Sailing	Passenger	Tanker
Number of track points	4,423,130	28,025,380	3,609,600	5,796,500	2,518,370
Number of ships	10,460	33,880	13,150	9960	5020

). The results indicate that tugboats accounted for more than thirty thousand records, whereas cruise ships numbered only 5020.

To address the issue of imbalanced trajectory data, we randomly downsampled each vessel category to 5000 instances to improve the balance during model training.

During the extraction of trajectory sequences, the speed threshold for anchoring points $V_T$ was set to 0.3 knots, the time interval threshold for trajectory segmentation $T_{seg}$ was set to 10 min, and the trajectory sequence length threshold $P_{num}$ was set to 15. Based on these parameters, a preliminary extraction yielded 551,324 trajectory sequences.

Subsequently, we performed undersampling on the majority classes (fishing, sailing, passenger, and tanker) based on the distribution of trajectory sequences across categories (see Figure 6). A portion of the trajectory sequences from the majority classes was randomly deleted to ensure that each vessel category had an equal number of sequences. Ultimately, the dataset was processed to contain 247,750 trajectory sequences, with each vessel category comprising 49,550 sequences.

Statistically, the maximum length of the trajectory sequences $L_{max}$ was found to be 60. Finally, the trajectory sequence dataset underwent min–max normalization, and was split into training and testing sets in an 8:2 ratio.

3.2. Experimental Setup

3.2.1. Experimental Environment

The hardware and software environment used in this study is detailed in

Table 2. Experimental environment.

Hardware/Software Environment	Detailed Information
Central processing unit (CPU)	Intel(R) Core(TM) i9-13900HX, 2.20 GHz
Graphics processor unit (GPU)	GeForce RTX 4060
Computer memory	32 GB, DDR5
Computer system	Windows 11, 64-bit
Development framework	PyTorch 2.0.1+cu118
Development language	Python 3.11.5

.

3.2.2. Model Implementation and Training

The ResNet1D-AttLSTM model was implemented using Python based on the PyTorch. During the training process, we utilized the Adam optimizer as the optimization algorithm, with an initial learning rate set to 0.0001 and a batch size of 256. The loss function employed was cross-entropy. To effectively prevent overfitting, we implemented the early stopping criterion during training.

In terms of hyperparameter settings, the following applies:

• For the ResNet1D module, the convolutional layers were configured with 32 convolutional kernels of size 3;
• Within the residual blocks, the convolutional layers were configured with 64 convolutional kernels of the same size;
• In the AttLSTM module, the dimension of the memory cells was set to 128.

3.3. Model Evaluation and Analysis

3.3.1. Evaluation Metrics

To analyze the classification performance of the model, this study employs four key metrics: accuracy, precision, recall, and F1-score. The specific calculation methods for these metrics are provided in Equations (13)–(16).

$$\mathrm{A}\mathrm{c}\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{a}\mathrm{c}\mathrm{y}={\displaystyle \frac{N_{\mathrm{C}\mathrm{o}\mathrm{r}\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{t}}}{N}}$$

(13)

$$\mathrm{P}\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{i}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n}={\displaystyle \frac{N_{\mathrm{T}\mathrm{P}}}{N_{\mathrm{T}\mathrm{P}}+N_{\mathrm{F}\mathrm{P}}}}$$

(14)

$$\mathrm{R}\mathrm{e}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{l}={\displaystyle \frac{N_{\mathrm{T}\mathrm{P}}}{N_{\mathrm{T}\mathrm{P}}+N_{\mathrm{F}\mathrm{N}}}}$$

(15)

$$F_1={\displaystyle \frac{2\times \mathrm{P}\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{i}\mathrm{s}\mathrm{i}\mathrm{o}\mathrm{n}\times \mathrm{R}\mathrm{e}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{l}}{\mathrm{Precision}+\mathrm{Recall}}}$$

(16)

where the following applies:

• $N_{\mathrm{C}\mathrm{o}\mathrm{r}\mathrm{r}\mathrm{e}\mathrm{c}\mathrm{t}}$: The number of correctly classified ship trajectory sequences.
• $N$: The total number of ship trajectory sequences.
• $N_{\mathrm{T}\mathrm{P}}$: The number of true positives, i.e., the number of ship trajectory sequences correctly classified as belonging to a particular class.
• $N_{\mathrm{F}\mathrm{N}}$: The number of false negatives, i.e., the number of ship trajectory sequences that belong to a particular class but were incorrectly classified as belonging to another class.
• $N_{\mathrm{F}\mathrm{P}}$: The number of false positives, i.e., the number of ship trajectory sequences that do not belong to a particular class but were incorrectly classified as belonging to that class.

These metrics provide a comprehensive evaluation of the model’s performance by considering both the correctness of classifications and the balance between precision and recall.

3.3.2. Hyperparameter Tuning of ResNet1D-AttLSTM

To evaluate the performance of the ResNet1D-AttLSTM model under different hyperparameter settings, we employed four-fold cross-validation and calculated the average classification accuracy across four independent validation sets. As shown in

Table 3. Classification performance of the ResNet1D-AttLSTM model under different settings.

	Scheme 1	Scheme 2	Scheme 3	Scheme 4	Scheme 5	Scheme 6	Scheme 7
Number of residual blocks	1	—	1	1	2	2	3
Number of LSTM layers	—	2	2	2	2	2	2
Memory cell dimension	—	128	128	128	128	128	128
Number of attention heads	—	—	—	4	4	8	12
Attention layer embedding dimension	—	—	—	128	128	256	256
Accuracy (%)	79	81.1	84.3	87.4	87.9	90.1	88.5

, the model achieved the highest classification accuracy under Scheme 5. This scheme includes two residual blocks, two LSTM layers (each with a memory cell dimension of 128), eight attention heads (with an embedding dimension of 256), and a dropout rate of 0.3 in the feature fusion layer.

As indicated in Table 3, Scheme 1 and Scheme 2 achieved accuracies of 79% and 81.1%, respectively, suggesting that relying solely on either ResNet1D or LSTM for ship trajectory classification has limited performance. Scheme 3, which integrates features extracted by ResNet1D with the temporal information captured by LSTM, achieved an accuracy of 84.3%, higher than Schemes 1 (79%) and 2 (81.1%). This indicates that combining spatial and temporal features significantly improves model performance. Scheme 4 further improved the accuracy to 87.4%, demonstrating that introducing the attention mechanism allows the model to more effectively capture key information, thereby enhancing classification performance.

However, Scheme 7 showed a slight decrease in accuracy to 88.5% compared with Scheme 6. This phenomenon could be ascribed to the heightened model complexity induced by an overabundance of attention heads and residual blocks, potentially resulting in overfitting.

3.3.3. Classification Performance on Different Ship Types

Next, this study conducted a detailed statistical analysis of the classification results for each type of ship trajectory in the test set. The detailed classification results, confusion matrix, and metrics such as precision, recall, and F1-score are presented in

Table 4. Classification performance of the ResNet1D-AttLSTM model on different ship types.

Actual Class	Predicted Class
	Towing	Fishing	Sailing	Passenger	Tanker	Precision(%)	Recall(%)	F1(%)
Towing	45,849	1144	888	741	928	90.8	92.5	91.6
Fishing	1075	44,863	2060	635	917	86.3	90.5	88.4
Sailing	1632	3737	42,304	840	1037	89.2	85.4	87.3
Passenger	1091	1390	1492	43,007	2570	93.0	86.8	89.8
Tanker	845	837	690	1008	46,170	89.4	93.2	91.3

.

From Table 4, several observations can be made:

• F1-score analysis:
  • The model demonstrates good recognition ability across all categories of ship trajectories, with F1 scores exceeding 87% for each category. The highest F1 score is achieved for towing vessels at 91.6%, while the lowest is for sailing vessels at 87.3%.
  • The superior classification performance for towing vessels may be attributed to their distinctive movement patterns: relatively fixed navigation paths, low and stable speeds, and regular turning behaviors.
  • The lower F1 score for sailing vessels could be due to their variable heading and speed characteristics, as well as their broad and unfixed activity areas.
• Precision analysis:
  • The model achieves the lowest precision for fishing vessels at 86.3% and the highest for passenger ships at 93%. This indicates that many non-fishing vessel trajectories were misclassified as fishing vessels, whereas most predicted passenger ship trajectories were correctly identified.
  • Further analysis of the confusion matrix reveals that the low precision for fishing vessels primarily stems from confusion between sailing and fishing vessel trajectories. Under specific sailing conditions, these two types of vessels exhibit similar trajectory features. For example, when wind conditions allow small fishing boats and sailboats to have comparable speed and heading changes, or when they operate in similar waters, it becomes challenging for the model to distinguish between them. This confusion also contributes to the lower recall rate for sailing vessels.
• Recall analysis:
  • The recall for passenger ship trajectories is relatively low at 86.8%, while it is highest for oil tankers at 93.2%. This suggests that some passenger ship trajectories were misclassified as other types, whereas most actual oil tanker trajectories were correctly identified.
  • The analysis shows that many passenger ship trajectories were misidentified as oil tankers. Oil tankers typically have more fixed routes and higher data quality, which helps the model better distinguish them from other types of ships.

Overall, the classification performance is best for towing vessel and oil tanker trajectories, while fishing and sailing vessel trajectories exhibit relatively poorer classification results. To improve the model’s ability to distinguish between the trajectories of fishing and sailing vessels, we plan to add more training data for these two types in future work in order to assist the model to better differentiate them. Additionally, we intend to introduce more discriminative, manually defined features, such as operational type and weather conditions, as contextual information, and optimize the model by refining its architecture and loss function to enhance overall performance.

3.3.4. Comparative Analysis

To further evaluate the performance of the ResNet1D-AttLSTM model, this study conducted comparative experiments, comparing it with trajectory classification models based on FishNet [31], pGRU [32], and CNN-LSTM [34] network architectures. The selection of these models was based on their methodological relevance to our work, as they employ deep learning architectures for ship trajectory classification, to process trajectory data as a sequence task without converting it to an image, and to address similar maritime application scenarios. Among these, FishNet employs a one-dimensional convolutional neural network architecture, while pGRU represents an advanced recurrent neural network variant that achieves efficient modeling of low-dimensional heterogeneous data by partitioning each input feature within the activation function and assigning independent parameters to each partition. The comparative experiments used accuracy as the evaluation metric, and the results are presented in

Table 5. Comparison of classification accuracy among different models.

Model	Accuracy (%)
ResNet1D-AttLSTM	89.7
FishNet [31]	81.4
pGRU [32]	82.2
CNN-LSTM [34]	84.1

and Figure 7.

According to the data in Table 5 and Figure 7, the ResNet1D-AttLSTM model outperforms all other models in the trajectory classification task, achieving an accuracy of 89.7%, which is significantly higher than the others. This model integrates a one-dimensional residual network with an attention-based long short-term memory network, enabling it to effectively capture long-term dependencies in ship trajectory sequences and learn key features through the self-attention mechanism. In contrast, the accuracies of FishNet and pGRU are 81.4% and 82.2%, respectively, while that of CNN-LSTM is 84.1%. These results indicate that the ResNet1D-AttLSTM model exhibits superior accuracy and robustness when handling complex trajectory data.

4. Conclusions and Future Work

This paper presents an innovative ship trajectory classification model. The proposed model combines the advantages of ResNet1D and LSTM for local multi-level feature detection and learning long-term dependencies, respectively. It also employs self-attention mechanisms to enhance the understanding of critical information, thereby generating high-integrity spatiotemporal motion feature representations of ship trajectories, effectively improving the performance of ship trajectory classification. Experimental results show that the proposed ResNet1D-AttLSTM model outperforms other models that rely on single feature sets or lack an integrated attention mechanism in terms of accuracy. On a real AIS trajectory dataset, the overall classification accuracy of this model reached 89.7%, with particularly notable performance in the identification of towing vessel and tanker trajectories. However, there is room for improvement in the classification of fishing boat and sailing yacht trajectories.

Future research directions include the following:

• Expanding the training dataset: Increase the diversity and volume of training data, especially for less represented vessel types like fishing and sailing boats, to improve classification accuracy and robustness.
• Integrating contextual features: Incorporate additional discriminative features such as operational type and weather conditions into the model to better capture the context of vessel movements, thereby improving classification performance.
• Refining data preprocessing techniques: Optimize preprocessing methods, considering the periodic nature of certain navigational data (e.g., longitude and COG), to ensure that these steps more accurately reflect actual navigation scenarios.
• Optimizing model architecture: Explore various optimization strategies for the ResNet1D-AttLSTM architecture, including the testing of different activation functions or the introduction of partitioned activation mechanisms, to potentially achieve even better model performance.
• Enhancing classification system diversity: Expand the scope of the classification system to include a wider range of vessel types, making it adaptable to diverse maritime environments and specific application scenarios.
• Generalizing to other domains: Investigate the applicability of the developed methods to other domains, such as urban traffic management, to validate the generalizability and adaptability of the proposed techniques.