Intelligent Tracking Method for Aerial Maneuvering Target Based on Unscented Kalman Filter

Abstract

This paper constructs a nonlinear iterative filtering framework based on a neural network prediction model. It uses recurrent neural networks (RNNs) to achieve accurate regression of complex maneuvering target dynamic models and integrates them into the nonlinear iterative filtering system via Unscented Transformation (UT). In constructing the neural network prediction model, the Temporal Convolutional Network (TCN) modules that capture long-term dependencies and the Long Short-Term Memory (LSTM) modules that selectively forget non-essential information were utilized to achieve accurate regression of the maneuvering models. When embedding the neural network prediction model, this paper proposes a method for extracting Sigma points using the UT transformation by ‘unfolding’ multi-sequence vectors and explores design techniques for the time sliding window length of recurrent neural networks. Ultimately, an intelligent tracking algorithm based on unscented filtering, called TCN-LSTM-UKF, was developed, effectively addressing the difficulties of constructing models and transition delays under high-maneuvering conditions and significantly improving the tracking performance of highly maneuvering targets.

1. Introduction

Target tracking is the process of estimating a continuous and accurate target trajectory by processing discrete, noise-contaminated sensor measurements. The basic idea is to design a motion model for the target based on prior knowledge and iteratively optimize this model according to the spatio-temporal variation patterns of the measurements, with the model output serving as the target state estimation. After decades of development, target tracking has been widely applied in radar target detection, precision weapon guidance, aerospace measurement and control, UAV navigation, and autonomous driving, significantly advancing the related fields. It is noteworthy that in many practical scenarios, the target’s motion pattern is not constant and may experience state transitions such as acceleration, deceleration, or turning. These uncertain maneuvering behaviors cause a mismatch between the tracking model and the actual target motion characteristics, resulting in a significant reduction in tracking accuracy or even tracking divergence. Thus, accurately tracking maneuvering targets, especially those with strong maneuvers, has long been a challenging problem in radar data processing.

The commonly used maneuvering target tracking methods mainly fall into two categories: one is model-based state prediction methods, and the other is neural network-based state prediction methods. Model-based methods are centered around the Kalman Filter [1,2], and their tracking effectiveness depends on the accuracy of the target motion model, initially including the Extended Kalman Filter (EKF), Unscented Kalman Filter (UKF), and others. Common motion models [3,4] mainly include the Constant Velocity (CV) model, Constant Acceleration (CA) model, Coordinated Turn (CT) model, and adaptive tracking models such as the Singer model [5] and the current statistical model [6]. These methods, using only a single model, can adjust model parameters according to measurement changes, but still struggle to cover a variety of complex target maneuvers. To address this, scholars have subsequently proposed multi-model approaches and later the Interacting Multiple Model (IMM) [7] algorithm, which work with various models in synchronization and perform a weighted summation of their respective state estimates to achieve a superior state estimation. Compared to traditional single-model-based filtering methods, they significantly improve the tracking performance of maneuvering targets. However, due to the latency in the calculation and update of weights, at the moment when the target maneuvers, the probabilities of the models are not accurate, leading to lagged tracking results and reduced tracking precision.

In recent years, with the rapid development and widespread application of deep learning, scholars have proposed neural network-based methods for maneuvering target tracking. In the earlier methods, scholars used online learning [8,9] to predict the innovations, Kalman gain, and other parameters, thereby adaptively adjusting the motion models to obtain better state estimates. However, online learning cannot use models and algorithms with high computational complexity, and the limited time available for data preprocessing leads to poor preprocessing effects. Therefore, this method has gradually been replaced by deep neural network algorithms trained and learned on offline data. Recurrent Neural Networks, the earliest models used for time-series processing, have been widely applied in many fields such as weather forecasting, stock market predictions, autonomous driving, and natural language processing. Correspondingly, as trajectory data are a type of time series, the strategy of integrating deep learning methods with traditional processing techniques has become a prominent trend. However, for a single radar, the amount of trajectory measurements is often too small to build a complete offline database [10,11]. To address this, this paper uses a Digital Combat Simulator (DCS) to generate a large amount of simulated flight data, which after preprocessing, are converted into trajectory data in Cartesian coordinates suitable for network input. Compared with current databases built on simulation data, this offline simulated trajectory database is closer to real conditions. The resulting models will have stronger generalization capabilities and tracking performance.

In maneuvering target tracking methods, state prediction is crucial. There are currently many neural network models designed for state prediction, such as trajectory prediction algorithms based on BP neural networks [12], algorithms based on Bi-LSTM [13], state estimation algorithms based on NARX (nonlinear autoregressive with an exogenous input) [14], Transformer-based networks TBN [15], and the joint direct tracking and classification algorithm DeppDTC based on CNN-Transformer [16]. These algorithms primarily focus on whether the network can retain long-term memory of feature information based on attention mechanisms, while neglecting performance analysis of the convolutional neural network (CNN) used for feature extraction. Therefore, this paper proposes a new state prediction model combining a Temporal Convolutional Network and LSTM. The TCN optimizes the CNN layers by replacing standard convolutions with dilated convolutions and causal convolutions. By using LSTM, long-term dependencies in the measurements can be captured with fewer layers, enhancing state prediction accuracy and efficiency.

Without measurement-based correction, relying solely on predictions inevitably introduces cumulative errors. Prediction systems based on neural networks face difficulties incorporating measurements due to the unclear specific form of the nonlinear state transition matrix. To address this issue, some scholars have proposed feasible methods, such as using neural networks to estimate model parameters, including state transition matrices [17,18], transition probability matrices (TPMs) in IMM [19], polynomial coefficients [20], turning rate [21,22], and model probabilities in IMM [23], and then using traditional methods for filtering after obtaining specific models. Additionally, incorporating measurement influences during neural network training is another method [24]. Although this approach presents significant challenges to the neural network’s feature learning capabilities, it avoids the complexity of adding measurement feedback modules later, such as in the TrMTT algorithm [25]. Other studies have designed new recursive algorithms on existing models, such as NTTrRT [26]. These methods abandon trajectory-to-trajectory prediction, improving prediction accuracy but failing to address the statistical quantity problem of target states under nonlinear prediction systems, introducing unnecessary errors. Therefore, this paper proposes a fusion algorithm, TCN-LSTM-UKF (TLU), based on neural network prediction and the Unscented Kalman Filter, capable of calculating state statistics at each time step without explicitly defining the state transition matrix, thus incorporating measurement influences into the system. Firstly, we analyzed the propagation characteristics of Sigma points in nonlinear systems and discovered that the state changes in a single Sigma point across different time steps exhibit temporal correlation. Therefore, we proposed a method of extracting Sigma points using the UT transformation by ‘unfolding’ multi-sequence vectors, employing the TCN-LSTM network for time-series prediction of each point. The predicted state vectors and covariance matrices are computed by calculating the weighted sum of the Sigma points at the current moment, and then, the measurements are introduced following the basic principles of Kalman Filters to correct the state vectors and covariance matrices. Additionally, we explored design techniques for the time sliding window length of recurrent neural networks. Through this approach, the proposed algorithm effectively handles the state prediction issues of nonlinear systems and introduces measurement feedback in a reasonable and effective manner to help correct errors in the predictions.

This paper is organized as follows: Section 2 introduces the basic principles of TCNs and LSTM. Section 3 proposes the intelligent algorithm for maneuvering target tracking, TCN-LSTM-UKF. Section 4 presents the results of a simulation analysis and real data processing, and Section 5 summarizes the work of this paper.

2. Basic Concepts of TCN and LSTM

2.1. Temporal Convolutional Network Based on Causal and Dilated Convolutions

TCN uses one-dimensional convolution (1D convolution) to process sequence data, divided into three parts: causal convolution, dilated convolution, and residual connection [27].

TCN employs causal convolution [28], where the output at time $t$ is only convolved with elements at time t and earlier in the previous layer. Figure 1 illustrates causal convolution, used to assume all data must have a one-to-one causal relationship in time order. Given an input sequence time signal, $X=\left(x_0,x_1,x_2,x_3,x_4\right)$, where $x_t\in {ℝ}^n$, $n$ is the variable dimension, and $x_t$ does not have a strict causal relationship in time order. Although $x_0$ and $x_4$ may have a direct logical connection, causal convolution ensures that the relationship between $x_0$ and $x_4$ is influenced by $x_1$, $x_2$, and $x_3$.

In convolutional neural networks, dilated convolution and receptive field are two important concepts. The size of the receptive field determines the range of preceding and succeeding information the network can capture; the larger the receptive field, the more information the network can capture.

Traditional convolution processes involve performing one convolution and then pooling, reducing the sequence size and increasing the receptive field. However, the main problem is that some sequence information is lost during pooling. Dilated convolution [29] has the advantage of not requiring pooling, gradually increasing the receptive field through a series of dilated convolutions, allowing each convolution output to contain rich long-term tracking information. The standard convolution is given as

$$y\left(t\right)={\displaystyle {\sum }_{\mathrm{i}=0}^{\mathrm{k}-1}w\left(i\right)}\bullet x\left(t+i\right)$$

(1)

where $w$ is the convolution kernel of size $k$, $x$ is the input sequence, and $y\left(t\right)$ represents the output at time step $t$. In dilated convolution, gaps are introduced between the convolution kernels, and the output of dilated convolution with a dilation rate $d$ is

$$y\left(t\right)={\displaystyle {\sum }_{\mathrm{i}=0}^{\mathrm{k}-1}w\left(i\right)}\bullet x\left(t+d\bullet i\right)$$

(2)

Compared to increasing the number of convolution layers and convolution kernel sizes, dilated convolution can capture long-term dependencies more efficiently.

In Temporal Convolutional Networks, residual connections (ResNet) are also an important structural feature [30]. Figure 2 illustrates the working principle of residual connections, where ResNet directly adds the input information across layers to the output, allowing effective training even for very deep networks.

2.2. Long Short-Term Memory Neural Network

LSTM [31,32] is a special type of recurrent neural network, with the core being three main gate control systems: forget gate, input gate, and output gate, as well as a cell state that maintains network states. As shown in Figure 3, these components work together to determine how information is retained, forgotten, and transmitted.

2.3. Unscented Transformation and Unscented Kalman Filter

The Unscented Kalman Filter [33,34] is an advanced filtering technique based on the Unscented Transformation, suitable for state estimation problems in highly nonlinear systems. It approximates the statistical characteristics of nonlinear transformations, such as mean and covariance, through carefully selected weighted sample points.

Assuming the state vector $X$ has a dimension n, a mean $\overline{X}$, and a covariance matrix $P$, the Sigma points include the mean itself and 2n points symmetrically distributed around the mean, totaling 2n + 1 points.

The first point is the mean itself:

$$X_0=\overline{X}$$

(3)

The remaining 2n points are obtained by shifting the square root of the mean and covariance matrix, symmetrically distributed in both positive and negative directions along each dimension:

$$X_i=\overline{X}+\sqrt{n+\lambda }{S}_i,i=1,\dots ,n$$

(4)

$$X_{i+n}=\overline{X}-\sqrt{n+\lambda }{S}_i,i=1,\dots ,n$$

(5)

where $S$ is the square root of the covariance matrix $P$ obtained through Cholesky decomposition, $\lambda ={\alpha }^2\left(n+\kappa \right)-n$ is a scaling parameter, $\alpha$ controls the distance between points and the mean (typically less than 1), and $\kappa$ is a tuning parameter.

The weights of each Sigma point are calculated as follows:

$${\omega }_0^m={\displaystyle \frac{\lambda }{n+\lambda }}$$

(6)

$${\omega }_0^c={\displaystyle \frac{\lambda }{n+\lambda }}+\left(1-{\alpha }^2+\beta \right)$$

(7)

$${\omega }_i^m={\omega }_i^c={\displaystyle \frac{1}{2\left(n+\lambda \right)}},i=1,2,\dots ,2n$$

(8)

where ${\omega }_i^m$ represents the mean weight of the $i$-th Sigma point, and ${\omega }_i^c$ represents the covariance weight of the $i$-th Sigma point. $\beta$ is used to incorporate prior knowledge about the distribution, typically set to two in a Gaussian distribution.

In addition to the selection of the Sigma points, the Unscented Kalman Filter process requires each Sigma point to be propagated through the nonlinear function $g$, resulting in

$$Y_i=g\left(X_i\right),i=0,\dots ,2n$$

(9)

Finally, the estimated mean and covariance matrix are obtained as follows:

$$\overline{Y}={\displaystyle \sum _{i=0}^{2n}{\omega }_i}{Y}_i$$

(10)

$$P_Y={\displaystyle \sum _{i=0}^{2n}{\omega }_i}\left(Y_i-\overline{Y}\right){\left(Y_i-\overline{Y}\right)}^{\prime }$$

(11)

3. The Proposed TCN-LSTM-UKF Algorithm

3.1. Neural Network Model Based on the Serial Structure of TCN-LSTM

Temporal Convolutional Networks (TCNs) offer a distinct advantage over traditional CNN in handling time-series data, especially for tasks like maneuvering target tracking. Typically, before using recurrent neural networks for maneuvering target trajectory prediction, CNN layers are used to extract motion features. However, traditional CNN layers are primarily designed for image processing, where the receptive field of each layer is limited by the size and number of convolution kernels. Although increasing the number of layers can indirectly expand the receptive field, this method significantly raises computational complexity, memory consumption, and training time. More importantly, CNNs struggle to capture long-term dependencies, which are critical in trajectory prediction tasks. This limitation also introduces the risk of “future information leakage,” where CNNs unintentionally use future data in predictions, thus compromising temporal continuity and reliability. In contrast, TCNs are specifically designed to address these issues by capturing long-distance temporal dependencies even in shallow networks, improving computational efficiency. TCNs use dilated convolutions, which expand the receptive field without increasing the computational burden, allowing the model to access information from a broader temporal range. Moreover, TCNs employ causal convolutions, where each output at a given time step depends only on the current and previous inputs, preserving temporal order and ensuring predictions are based solely on known historical data. This causality-preserving property avoids the problem of future information leakage. Additionally, TCNs demonstrate significant stability and efficiency advantages over CNNs. In deep neural networks, handling long sequences often leads to vanishing or exploding gradients. While CNNs can partially mitigate this problem by stacking multiple convolutional layers, they do not fully resolve it. TCNs, however, use residual connections and normalization layers to maintain stable gradient flow in deep networks, significantly reducing the risk of vanishing or exploding gradients. TCN’s architecture also enhances parallel computation capabilities, as dilated convolutions can cover multiple time steps simultaneously, greatly improving computational efficiency for long sequences and better utilizing modern hardware’s parallel computing power. Furthermore, TCNs, with their relatively simple convolution operations and fewer parameters, provide better generalization and stability when processing large and complex time-series datasets, with a lower risk of overfitting compared to CNNs. In summary, TCN offers a more efficient, powerful, and adaptable architecture than CNN, especially suited for various time-series data analysis tasks requiring the capture of complex temporal dynamics. Therefore, to enable the network to better learn the maneuvering characteristics of target motion, we replace the CNN-LSTM neural network architecture with the TCN layer.

TCN and LSTM are both excellent techniques for processing time-series data, each with its unique advantages. When using LSTM alone, handling long time series can become challenging due to issues such as gradient explosion or gradient vanishing, which affects the accuracy of the model’s predictions. By introducing TCN, which has a larger receptive field, the network can better capture long-term dependencies in the sequence. Additionally, TCN’s convolution-based parallel processing structure improves the computational efficiency compared to the sequential processing structure of using LSTM alone. More importantly, TCN can effectively filter noise during the feature extraction phase, providing cleaner and more meaningful features for LSTM to process subsequently, thereby enhancing the overall robustness and noise resistance of the model. Therefore, this paper proposes a serial network structure based on TCN and LSTM, where TCN serves as the feature extractor followed by LSTM layers for sequence modeling. This effectively integrates the strengths of both, improving the overall prediction accuracy of the model and can be effectively applied in the single-step prediction phase of maneuvering target tracking tasks.

In summary, TCN-LSTM can handle the diversification and complexity in maneuvering target tracking tasks, performing excellently in large-scale, high-dimensional, and rapidly changing tracking scenarios. This method helps improve tracking algorithm performance, enhancing reliability and efficiency in practical applications. Figure 4 shows the specific network framework, consisting of two TCN layers and one LSTM layer, with preprocessed Cartesian coordinate system historical trajectory data as input. The structure is b × n × c, where b represents batch size (i.e., the number of samples processed simultaneously in one forward and backward pass), n represents sequence length (in maneuvering target tracking tasks, it represents the number of trajectory time steps in a window), and c represents the number of features (in this paper, it is consistent with the target state dimension, with the target state vector containing nine dimensions of x, y, and z positions, velocities, and accelerations). The TCN part accepts nine-dimensional inputs and consists of two layers, with output channels of 64 and 128, respectively. The kernel size is nine, and dilated convolutions are used with dilation rates of one and two to expand the receptive field, allowing the model to effectively capture long-term dependencies. To maintain the time dimension, the padding is set to 8 and 16 in the first and second layers, respectively. Each convolutional layer is followed by a Relu activation function, and a 0.2 Dropout is applied to prevent overfitting. In addition, residual connections are used for each convolutional output, and if the input and output channels are different, a 1 × 1 convolution is used to adjust the input size. Next is the LSTM part, which processes the 128-dimensional feature output by the TCN. The LSTM network contains nine layers in total, with 256 hidden units per layer, and a unidirectional structure is adopted. Therefore, it extracts features from the forward sequence. The output dimension of the LSTM is 256, which is then mapped to a nine-dimensional output through a fully connected layer to generate the final prediction results. A 0.2 Dropout is also applied between each LSTM layer.

3.2. Intelligent Tracking Algorithm Based on Unscented Filters

Existing data-based tracking methods rarely combine Kalman Filters to add a measurement feedback mechanism. Using neural network predictions alone cannot dynamically adjust and correct prediction errors. First, the predictions of neural networks have some error at each time step, and when these predictions are used for subsequent predictions, these errors gradually accumulate, leading to a decline in prediction accuracy. Additionally, the internal working mechanisms of neural networks are complex and lack interpretability, making it difficult to understand the model’s decision-making process and the reliability of the results in practical applications. In contrast, Kalman Filtering methods have clear mathematical models, making the results easier to verify. Therefore, this paper proposes a TCN-LSTM-UKF intelligent tracking algorithm based on unscented filtering. This algorithm integrates modern neural networks and traditional Kalman Filters, leveraging the powerful predictive capabilities of neural networks and the real-time correction capabilities of Kalman Filters. This significantly improves the tracking accuracy and robustness of the system when dealing with highly maneuvering targets.

To optimize filter performance and improve the system model, this paper studies the time dependency of Sigma points. In the Unscented Kalman Filter, although Sigma points at each time step are regenerated according to the current state estimate and covariance matrix, their generation depends on the prediction and state update from the previous time step. In this sense, there is an indirect temporal dependency between Sigma points at different times, as each set of Sigma points is adjusted based on information from the previous time step. By tracking the changes in each Sigma point over time, we can observe how they evolve with the system. In this context, the changes in Sigma points can be viewed as a time series reflecting the dynamic behavior of the system. Therefore, the proposed TCN-LSTM network model can be trained to understand the temporal patterns of Sigma point changes and predict future states. At this point, each Sigma point’s time series can be considered a feature sequence, and the neural network needs to capture the patterns in these sequences for prediction.

The generation and propagation rules of Sigma points are illustrated in Figure 5. In UKF, the generation of Sigma points is designed to approximate the Gaussian distribution with a small number of discrete points and to capture the state distribution in a nonlinear system. Specifically, 2n + 1 Sigma points are generated from the initial state mean and covariance matrix, where n is the dimension of the state vector. By calculating the Cholesky decomposition of the covariance matrix, we obtain vectors to offset the state mean, generating symmetric Sigma points on both sides. These Sigma points represent possible values of the state distribution and are centered around the state mean, distributed within the range defined by the covariance, effectively capturing the changes in the state. When the Sigma points pass through a nonlinear system (in this paper, a pre-trained neural network prediction model), each point undergoes an independent nonlinear transformation. This means that the nonlinear system makes different predictions for each Sigma point, producing corresponding outputs. These predicted results typically no longer maintain a linear relationship, as the complexity of the nonlinear system leads to a nonlinear mapping between input and output. However, despite this nonlinear transformation, the Sigma points still retain the statistical properties of the original state distribution. After passing through the nonlinear system, the predicted results of the new Sigma points are used to re-estimate the state mean and covariance of the system. By taking a weighted average of these predicted results, a new state mean can be calculated, and the state covariance can also be re-estimated. This process allows UKF to better capture changes and uncertainties in the state when dealing with nonlinear systems, ensuring an accurate description of the state distribution. In summary, the generation and propagation of Sigma points through a nonlinear system ensure that, even in the presence of complex nonlinear mappings, the algorithm can effectively reflect changes in the state and obtain more accurate estimates of the mean and covariance through weighted summation. This makes UKF more stable and accurate when handling nonlinear systems compared to other filtering methods.

Based on the time dependency of Sigma points, this paper proposes an intelligent tracking algorithm, TLU, for maneuvering targets based on the unscented filter, as shown in Figure 6.

Initially, appropriate data preprocessing is conducted, converting raw radar measurements recorded as range–azimuth–elevation into Cartesian coordinates, and preliminary tracking is performed using the IMM algorithm. Data from the initial n time steps are selected as the initial window, and the Sigma point set of the target state vector at each time step in the initial window is calculated, resulting in a three-dimensional tensor of shape s × n × c, where s represents the number of selected Sigma points, and c represents the dimension of the target state vector. According to the general practice of the Unscented Transformation, we have the following:

$$s=2c+1$$

(12)

As shown in Figure 7, in TLU, since the network-based one-step prediction requires all information of the target state for the previous n time sampling points, each set of Sigma points constructed should reflect the propagation characteristics over this period and the motion characteristics of the target. Therefore, we first flatten the state vectors of the n sampling points and then construct the Sigma point set based on this one-dimensional vector. The number of points obtained with this new construction method is as follows:

$$s=2\times n\times c+1$$

(13)

Among them, it is necessary to construct a covariance matrix corresponding to the n × c-dimensional state vector for Cholesky decomposition. The covariance matrices for n time steps, each of shape c × c, are combined along the diagonal to form a new covariance matrix of shape (n × c) × (n × c), as follows:

$$P_{Sigma}=\left[\begin{array}{ccccc}{P}_1& 0& 0& 0& 0\\ 0& P_2& 0& 0& 0\\ 0& 0& \ddots & 0& 0\\ 0& 0& 0& P_{n-1}& 0\\ 0& 0& 0& 0& p_n\end{array}\right]$$

(14)

Before inputting the s Sigma point sequences into the TCN-LSTM network for prediction, a normalization module [35] needs to be added to ensure faster and more efficient convergence of the algorithm. After normalization, the model treats all features with consistent importance, avoiding poor training results due to the large variation range of position features. In the proposed algorithm, the min–max normalization method is used:

$$x_{norm}={\displaystyle \frac{x-\min \left(x\right)}{\max \left(x\right)-\min \left(x\right)}}$$

(15)

After processing the data through the TCN-LSTM module, the future state predictions of the s Sigma points are obtained. Since the subsequent process is based on the recursive model of the UKF, only one time step prediction result is output at this point. The UKF uses this prediction result and new measurement data to update the state estimate, optimizing potential prediction errors.

The TLU algorithm combines dynamic model selection (IMM), deep learning (TCN-LSTM), and advanced filtering technology (UKF) with a data-driven core. Compared to traditional model-based tracking algorithms, it offers higher prediction accuracy and performs excellently in handling high-maneuvering target tracking problems in complex environments. More importantly, regarding the issue of unknown model parameters in nonlinear systems when using neural networks for prediction, the TLU algorithm does not require determining the specific form of the state transition matrix. It can calculate the mean and covariance matrix by performing a weighted sum of the Sigma point set predicted at the current time step, without the need to design new measurement feedback systems. This avoids errors introduced by linearization, and this problem is addressed and solved by the proposed method for the first time compared to existing tracking algorithms.

4. Experimental Analysis

4.1. Analysis of Experimental Data Based on DCS

4.1.1. DCS Database

As a data-driven algorithm, TLU requires a large amount of data in high-dimensional space to capture complex dynamics, and it places high demands on data quality and the sufficiency of the training process. Due to the current limited amount of measured data, it is insufficient to build a comprehensive dataset. However, it is necessary to ensure that the trajectory data used meets practical needs, including various environmental changes and maneuvering characteristics. Therefore, this experiment abandons the use of simulated trajectory data and instead chooses DCS simulated flight data. DCS is a highly realistic flight simulation software that provides extremely accurate flight system simulations, an advanced physics engine, and highly realistic terrain environments. It also integrates various civilian and military aircraft. By collecting a large amount of trajectory data from this simulation, a vast offline database can be constructed. The raw data from DCS are video stream data, as shown in Figure 8, and the specific trajectory data are exported through the simulation software Tacview 1.9.4.

The radar scan cycle is 0.2 s. Based on existing parameters, the data are converted to Cartesian coordinates, resulting in nine-dimensional trajectory data in the Cartesian system.

First, the coordinates in the ECEF system are obtained from the original latitude and longitude data. Additionally, the geographic coordinates of the local sensor need to be provided to convert the ECEF coordinates to Cartesian coordinates. $L{s}_{radar}$ is set to 45.083 radians, $R{s}_{radar}$ to 38.987 radians, and $H{s}_{radar}$ to 6562 m. Based on Equations (15)–(18), the ECEF coordinates of the local sensor are calculated: $X_s=\left[x_s,y_s,z_s\right]$, and the rotation matrix $R$ is constructed:

$$R=\left[\begin{array}{ccc}-\sin \left(R{s}_{radar}\right)& -\sin \left(L{s}_{radar}\right)\bullet \cos \left(R{s}_{radar}\right)& \cos \left(L{s}_{radar}\right)\bullet \cos \left(R{s}_{radar}\right)\\ \cos \left(R{s}_{radar}\right)& -\sin \left(L{s}_{radar}\right)\bullet \sin \left(R{s}_{radar}\right)& \cos \left(L{s}_{radar}\right)\bullet \sin \left(R{s}_{radar}\right)\\ 0& \cos \left(L{s}_{radar}\right)& \sin \left(L{s}_{radar}\right)\end{array}\right]$$

(16)

The $ECEF$ coordinates of the target are $X_t=\left[ECE{F}_x,ECE{F}_y,ECE{F}_z\right]$, and the Cartesian coordinates are obtained by the following:

$$x_{real}=inv\left(R\right)\bullet \left(X_t-X_s\right)$$

(17)

After obtaining the position values, the velocity and acceleration need to be calculated. The velocity is a three-dimensional vector calculated based on ground speed, heading angle, and vertical speed. Ground speed and heading angle $\theta$ determine the horizontal velocity components, while vertical speed directly provides the vertical component. The acceleration is calculated using the lateral acceleration, longitudinal acceleration, and the pitch angle.

The simulated flight data are sufficient to construct a large offline database, which can be used as the training and validation dataset for the subsequent TCN-LSTM network.

4.1.2. Parameter Settings in DCS Data Analysis

The dataset used in the experiment was generated from an offline database, with specific parameters listed in

Table 1. Simulation experiment parameter settings.

Parameter Name	Value
Number of trajectories	65,519
Proportion of the training set	60%
Proportion of the validation set	40%
Learning rate	0.000001
Weight decay	0.00001
Batch size	64
Training set accuracy	92.92%
Validation set accuracy	87.21%

. The model training process is shown in Figure 9. In this model, we adopted the Adam optimizer, which can dynamically adjust the learning rate of each parameter to accelerate the convergence of complex neural networks. The initial learning rate was set to 1 × 10⁻⁶, which, although relatively low, enables stable updates for the model weights, avoiding oscillations caused by excessively large gradients. Weight decay was set to 1 × 10⁻⁵, helping to control overfitting, especially when dealing with high-dimensional and complex data, by limiting the growth of weights and thus enhancing the model’s generalization ability. As for the learning rate decay strategy, although we did not employ a dynamic learning rate adjustment method, the initial learning rate is already small enough to ensure that the model can still converge smoothly in the later stages of training. Regarding batch size, we chose 64 as the training batch size. This batch size strikes a balance between computational resources and model performance, fully utilizing the parallel computing power of GPUs while maintaining stability during the training process. In conclusion, the choice of optimizer, weight decay, and appropriate batch size settings all contribute to improving the model’s training stability and predictive performance.

Furthermore, the size of the sliding window in the neural network significantly impacts model performance. A window that is too large may introduce irrelevant information, leading to overfitting, while a window that is too small may not capture sufficient information. To select an appropriate window size, the experiment used the Pearson Correlation Coefficient [36] to calculate the correlation of the target state vector at different time intervals. The Pearson Correlation Coefficient is a statistical measure of the strength of a linear relationship between two sets of data. The formula is as follows:

$$r={\displaystyle \frac{{\displaystyle \sum \left(x_k-{\overline{x}}_k\right)\left(x_{k+t}-{\overline{x}}_{k+t}\right)}}{\sqrt{{\displaystyle \sum {\left(x_k-{\overline{x}}_k\right)}^2{\displaystyle \sum {\left(x_{k+t}-{\overline{x}}_{k+t}\right)}^2}}}}}$$

(18)

where $x_k$ and $x_{k+t}$ are two sets of state vectors at intervals of t sampling periods, and ${\overline{x}}_t$ and ${\overline{x}}_{t+k}$ are their means. The range of r is −1 to 1, where 1 indicates a perfect positive correlation, −1 indicates a perfect negative correlation, and 0 indicates no linear correlation. As shown in Figure 10, when $t$ = 50, the Pearson Correlation reached 0.999945, and as t continued to decrease, the correlation improvement slowed significantly. Therefore, the experiment selected a sliding window size of 50.

4.1.3. System Initialization

Due to noise potentially masking the true signal in the data, directly using noisy measurements as input to the neural network may result in the network learning inaccurate features, reducing system accuracy. The TLU algorithm uses an IMM module for initialization. The IMM model set includes the CV model, CA model, Singer model, and three CT models with different turning rates, totaling six models. The results of the first 50 sampling points filtered by the IMM are selected as the initial state of the TLU system and the initial input for the TCN-LSTM model.

4.1.4. Positive Definiteness of the Covariance Matrix

In the TLU algorithm, performing a Cholesky decomposition on the covariance matrix P at each time step is a crucial step. The formula is as follows:

$$P=L{L}^T$$

(19)

where $L$ is a lower triangular matrix used to generate Sigma points that approximate the probability distribution in state estimation. However, due to the inappropriate setting of process noise and model errors, the covariance matrix may become non-positive definite, meaning it is symmetric but not all of its eigenvalues are positive. This can cause the Cholesky decomposition to fail, preventing subsequent recursive operations. In the experiment, a regularization method [37] was chosen; a very small positive value (0.0001) is added to the diagonal elements of the covariance matrix when it is not positive definite, making it positive definite. Experimental results show that this method is effective and does not introduce errors.

4.1.5. Comparative Experiment and Result Analysis

The test set used in this experiment is a simulated trajectory newly generated from the offline database, consisting of 586 sampling points, with a radar scan cycle of 0.2 s. Figure 11 shows the trajectory of the selected test set, comparing the true trajectory, the result tracked by the TLU algorithm, and the result tracked by the traditional algorithm IMM-a. IMM-a includes three models: CV, CA, and CT. As shown in the figure, the tracking accuracy of the TLU algorithm is superior to that of the traditional Interactive Multiple Model (IMM) algorithm. Whether in the smooth sections with small maneuvers or the sharp turning sections with large maneuvers, the TLU algorithm consistently tracks the target stably and provides better tracking performance.

To ensure the rigor of the experiment, this paper selects five existing maneuvering target tracking algorithms for comparative analysis on the TLU algorithm. Random radar measurement errors were generated for the simulated trajectory to conduct 50 Monte Carlo experiments, and the position and velocity RMSE in three directions were obtained, as shown in Figure 12. Among them, the radar measurement noise is Gaussian noise with a mean of 0. The standard deviation for range measurements is 5–10 m, and the standard deviation for azimuth and elevation angles are $0.05\pi /180$ degrees to $0.1\pi /180$ degrees. Additionally, IMM-a is the IMM algorithm that includes CV, CA, and CT models. IMM-b extends the model set of IMM-a by adding the Singer model and CT models with different turning rates. TBN is a prediction tracking algorithm based on Transformer, CNN-LSTM is a tracking model that uses CNN for feature extraction and LSTM for information memory and filtering, and LTR is an algorithm where LSTM predicts the probabilities of each model in IMM to assist IMM in target tracking.

Overall, as shown in Figure 12, TBN and CNN-LSTM are limited to using historical data to predict the target state and lack current system observations for result correction. Although they perform excellently at certain time points, their overall error is larger compared to other algorithms, and their system stability is poor. LTR, while enhancing system stability by incorporating traditional filtering algorithms into its predictions, excessively relies on feature-rich training datasets. For real-world data, the specific motion model of the target is unknown and cannot be used to construct the dataset. Simulated trajectories also fail to provide data diversity, resulting in insufficient model generalization capability for LTR. Consequently, LTR does not offer significant advantages over traditional Kalman Filter methods in tracking performance, as it does not predict the target’s state vector.

From Figure 12a,b, it can be seen that TLU’s tracking accuracy in the x-axis and y-axis positions is significantly better than TBN and CNN-LSTM and comparable to IMM and LTR. According to Figure 12c,f, TLU completely outperforms the other five algorithms in terms of the z-axis position and velocity tracking accuracy, demonstrating TLU’s strong capability in capturing target vertical maneuvers. According to Figure 12d,e, TLU’s tracking accuracy in x-axis and y-axis velocities is comparable to that of TBN and superior to that of the other four algorithms. In summary, the TLU algorithm shows certain improvements in position and velocity tracking accuracy compared to the other five algorithms and can maintain stable error during significant maneuvers, with less impact from time lag. The more pronounced motion characteristics of the target in the z-axis, i.e., larger altitude changes, and relatively stable noise in the z-axis direction enable TLU to better capture z-axis maneuver features, resulting in better tracking performance than in the x- and y-axes. In addition, for the performance evaluation of an algorithm, computational speed is an important metric alongside error analysis, as it impacts whether the algorithm can be applied in real-world environments. On an NVIDIA 3060 Ti, the processing times for different algorithms with an input sequence length of 50 and a batch size of 64 are shown in

Table 2. The processing times for different algorithms.

Algorithm	Time Consumed per Try [ms]
TLU	23
TBN	30
CNN-LSTM	35
IMM-a	21
IMM-b	25
LTR	27

. In practical applications, there is often a need to balance between computational speed and tracking accuracy. Lightweight algorithms like IMM have an advantage in speed but may not provide sufficient accuracy when dealing with complex maneuvering targets. On the other hand, deep learning models can capture more complex dynamics but come with higher computational costs. Due to the parallel computing structure of TCN, our proposed TLU algorithm achieves a notable improvement in computational speed while maintaining tracking accuracy, making it significantly faster than other neural network-based models and comparable to lightweight traditional Kalman Filter algorithms.

In scenarios with varying SNR, the probability of target detection can differ significantly. When the SNR is low, the target might not be detected at certain times, resulting in measurement loss. We assumed that one measurement point is lost for every five points and conducted new simulations to test the robustness of the algorithm. The results are shown in Figure 13, where TLU-a represents the tracking results without any missing points, and TLU-b represents the tracking results with missing points.

4.2. Results and Analysis of Radar Data Processing

The experiment verified that the proposed TLU algorithm performs significantly well on simulated trajectories. However, to verify the algorithm’s data transferability and consider the diversity of real-world environments, this paper also applies the TLU algorithm to radar measurements for performance analysis. The experiment used ten measured trajectories, and one of these trajectories was selected as the test set. This trajectory consists of 290 time steps, with a radar scan cycle of approximately 0.2–0.3 s. Among them, the radar measurement noise is Gaussian noise with a mean of 0. The standard deviation for range measurements is 30 m, and the standard deviation for azimuth and elevation angles are $0.2\pi /180$ degrees. This trajectory has a large turning maneuver, making it suitable for testing the algorithm’s tracking performance on highly maneuvering targets.

Considering that using only the nine trajectories outside the test set as training data is insufficient for the network to learn enough target motion features, we segmented these nine trajectories, totaling 6864 sampling points, into sliding windows of 50 time steps each. This resulted in 6423 trajectories of size 50 × 9. Additionally, a large amount of DCS simulated trajectory data was added for data augmentation, resulting in a total of 71,942 training trajectories. We used 60% of these data as the training set and 40% as the validation set. The training parameters were set to 1000 epochs, a learning rate of 0.001, a weight decay of 0.00001, and a batch size of 64. The accuracy of the trained model on the training set was 90.42%, and on the validation set, it was 88.43%. Figure 14 shows the tracking trajectories of TLU and IMM-a on the test set of measured data. IMM-a is the IMM algorithm that includes CV, CA, and CT models. It is evident that the TLU tracking trajectory matches better with the true trajectory compared to IMM-a.

To ensure the rigor of the experiment, we collected statistics on more metrics and conducted performance comparisons. Figure 15 shows the three-dimensional position and velocity tracking errors of TLU and the other six algorithms on the test trajectory. Since it is not feasible to conduct multiple Monte Carlo experiments with different radar measurement errors on the measured data, we used the absolute value of the difference between the algorithm’s tracking results and the true values as the tracking error. The test results show that TLU outperforms the other six algorithms in all six metrics, especially in tracking accuracy for velocity values.

Considering that the position tracking accuracy of TLU is lower than its velocity tracking accuracy, we chose to improve the algorithm’s position tracking accuracy by using a dual-channel tracking method with combined model predictions instead of directly using TCN-LSTM’s position prediction results. In this experiment, position prediction based on the CV model was selected, calculated as follows:

$$X_{\mathrm{pre}}^{\mathrm{k}}=X_{TLU}^{\mathrm{k}-1}+V_{\mathrm{pre}}^{\mathrm{k}}\bullet T$$

(20)

where $X_{\mathrm{pre}}^{\mathrm{k}}$ is the position prediction at time k based on the CV model, $X_{TLU}^{\mathrm{k}-1}$ is the position tracking result of TLU at time k − 1, $V_{\mathrm{pre}}^{\mathrm{k}}$ is the velocity prediction at time k based on TCN-LSTM, and $T$ is the radar scan period. The dual-channel prediction method effectively combines the advantages of both model-based and data-based approaches, retaining the high-accuracy velocity prediction from the data and achieving higher-accuracy position prediction based on the velocity prediction and model calculation, thereby improving the tracking performance of TLU.

Figure 16 compares the position tracking results before and after improvement, with TLU-a and TLU-b representing the tracking results before and after improvement, respectively. As shown in Figure 16c, the improved TLU significantly enhances the position accuracy on the z-axis. Figure 16a,b also show that the improved TLU achieves higher position tracking accuracy on the x-axis and y-axis at certain times compared to before improvement. In summary, TLU demonstrates excellent tracking performance on measured data, with significant improvements in position and velocity tracking accuracy compared to IMM-a.

5. Conclusions

This paper proposes an intelligent tracking algorithm for maneuvering targets based on Long Short-Term Memory neural networks and the Unscented Kalman Filter. First, we introduce a TCN-LSTM neural network model, which achieves higher prediction accuracy and shorter response time compared to existing models. Secondly, unlike existing methods that add a measurement feedback module, we propose a new strategy based on Unscented Transformation. By tracking the temporal correlation of the decomposed Sigma points of the target state vector, each Sigma point’s time series, formed by system propagation, is input into the neural network for feature analysis, and the corresponding prediction points are obtained. Finally, various statistics are calculated through weighted fusion. This algorithm solves the problem of the inability to determine the specific form of the state transition matrix in nonlinear systems when using neural networks for prediction, successfully incorporating measurement influences into the system to correct prediction errors. The simulation and experiment results show that the proposed method significantly improves the tracking accuracy of maneuvering targets.