Incremental SAR Automatic Target Recognition with Divergence-Constrained Class-Specific Dictionary Learning

Abstract

Synthetic aperture radar (SAR) automatic target recognition (ATR) plays a pivotal role in SAR image interpretation. While existing approaches predominantly rely on batch learning paradigms, their practical deployment is constrained by the sequential arrival of training data and high retraining costs. To overcome this challenge, this paper introduces a divergence-constrained incremental dictionary learning framework that enables progressive model updates without full data reprocessing. Specifically, firstly, this method learns class-specific dictionaries for each target category via sub-dictionary learning, where the learning process for a specific class does not involve data from other classes. Secondly, the intra-class divergence constraint is incorporated during sub-dictionary learning to address the challenges of significant intra-class variations and minor inter-class differences in SAR targets. Thirdly, the sparse representation coefficients of the target to be classified are solved across all sub-dictionaries, followed by the computation of corresponding reconstruction errors and intra-class divergence metrics to achieve classification. Finally, when the targets of new categories are obtained, the corresponding class-specific dictionaries are calculated and added to the learned dictionary set. In this way, the incremental update of the SAR ATR system is completed. Experimental results on the MSTAR dataset indicate that our method attains >96.62% accuracy across various incremental scenarios. Compared with other state-of-the-art methods, it demonstrates better recognition performance and robustness.

1. Introduction

Synthetic aperture radar (SAR) has the advantage of all-day, all-weather, high-resolution and large-scale observation. These characteristics have made SAR become an important means of battlefield surveillance and reconnaissance [1,2,3,4]. In various military applications, SAR automatic target recognition (ATR) has attracted more and more attention from scholars. With the development of machine learning, various SAR ATR methods have been proposed, including traditional methods [5,6] and deep-learning-based methods [7,8]. There methods generally use a batch training strategy to learn all training data. After obtaining the feature extractors and classifiers, the performances of these methods are verified on the test data. Experimental results show that they have high recognition accuracy; for example, the accuracy on MSTAR dataset can easily exceed 99% [9,10].

Nevertheless, the aforementioned methods suffer from substantial limitations. Specifically, the batch learning strategy is only applicable to situations where the training dataset remains constant. In real-world battlefield settings, acquiring all training data simultaneously is often unfeasible. Upon the acquisition of new training data, it becomes necessary to merge the existing and new training samples and then retrain the SAR ATR model using the combined dataset. This process demands a significant amount of time and computational resources, imposing a heavy burden on the update of the SAR ATR system. Consequently, substituting the batch learning strategy with incremental learning is imperative for the swift updating of the SAR ATR system.

Incremental learning, also referred to as continuous or lifelong learning, was initially introduced by Coppock et al. in 1962 [11]. It enables a system to continuously assimilate new knowledge from incoming data while retaining the majority of previously acquired knowledge. The significance of incremental learning is manifested in two key aspects [12,13,14]:

(1) In real-world applications, data is typically acquired incrementally; thus, upon encountering novel data, a pre-trained system must undergo adjustments to incorporate the knowledge embedded within the new data.

(2) Modifying an existing trained system generally incurs lower time and computational costs compared to retraining the system from scratch. Evidently, incremental learning represents a progressive process of accumulation and updating, closely resembling the human learning paradigm.

Evidently, incremental learning constitutes a process of progressive accumulation and iterative refinement, closely mirroring the cognitive learning mechanism inherent in human beings.

As shown in Figure 1, incremental learning can update the SAR ATR system at a very low cost. As far as we know, many scholars have carried out works on incremental SAR ATR. For instance, Dang et al. introduced the class boundary selection-based incremental learning (CBesIL). This method preserves prior recognition capabilities by selectively safeguarding class boundary exemplars as new classes are incrementally added [15]. Subsequently, Dang et al. enhanced the incremental nonnegative matrix factorization (INMF) by incorporating sparse constraints, resulting in a modified version denoted as $L_P-INMF$. Compared to the original INMF, $L_P-INMF$, an improved variant, exhibits superior recognition performance [16]. Tang et al. developed the high plastic error correction incremental learning (HPecIL), leveraging models trained on previous tasks to rectify cumulative errors and mitigate model degradation [17]. Meanwhile, Liu et al. proposed a class-incremental synthetic aperture radar (SAR) automatic target recognition (ATR) method. Grounded in a continuous teacher–student learning framework, this deep learning approach effectively alleviates catastrophic forgetting [18] in neural networks [19]. Guo et al. presented POSELM, an optimized version of the extreme learning machine (ELM). Specifically, POSELM applies the Particle Swarm Optimization algorithm to refine initial weights, thereby enhancing recognition accuracy [20]. Finally, Tao et al. devised a multiscale incremental dictionary learning method, building upon and improving the LC-KSVD algorithm [21]. Based on self-sustainment guidance representation, Pan et al. proposed an incremental SAR ATR method. This method made use of a dynamic query navigation module and a structural extension module to ensure the model’s learning ability for new and old class targets [22]. Zhang et al. proposed a multi-stage regularization-based SAR ATR method, called SCF-CIL. SCF-CIL applied an overfitting training strategy and a multi-stage regularization method to ensure the model’s incremental learning capability [23]. Cao et al. proposed the $L_{2,1}$-constrained deep incremental NMF ($L_{2,1}$-DINMF) method for SAR ATR. By introducing the $L_{2,1}$-constraint into deep nonnegative matrix factorization (DNMF) and defining incremental update rules, this method significantly improves the incremental recognition performance [24]. Gao et al. implemented incremental SAR ATR using strong separability features (SSF-IL). The SSF-IL employs intra-class and inter-class scatter to design the feature separability loss. Additionally, a classifier bias correction method based on boundary features is devised to achieve target classification [25]. Yu et al. proposed multilevel adaptive knowledge distillation network (MLAKDN) to realize incremental SAR ATR. MLAKDN proposes an adaptive weighted distillation strategy, a feature distillation method, a model rebalancing technique, and a weighted incremental classification loss to guarantee the model’s incremental recognition ability [26].

Furthermore, because of the complexity and challenge of the incremental SAR ATR problem, scholars only discuss incremental learning in specific settings. For example, the newly added data in References [15,16,17,18,19,20,22,23,24,25,26] belong to new classes, while Reference [21] deals with the new data of existing categories. In this paper, the projects we study are the same as those in References [15,16,17,18,19,20,22,23,24,25,26], and they belong to class incremental learning.

The above methods have good performance, but there is still room for improvement. In recent years, sparse representation has been widely used in SAR ATR, and it performed well [27,28,29]. The sparse representation classifier directly takes the training samples of various classes as the atoms to form a dictionary. Then, the test samples are classified according to their sparse representation under the dictionary. This approach is naturally suitable for class incremental learning. In more detail, when the samples of new classes are obtained, they can be directly used to expand the dictionary to accomplish class incremental learning. SAR target images have the characteristics of large intra-class distances and small inter-class differences. The dictionary constructed directly with training samples has difficulty adapting to this situation, and it performs poorly in SAR ATR. Therefore, we can improve this situation with a class-specific dictionary [30]. In addition, in the process of dictionary learning, regularization terms can be added to improve the recognition performance.

Motivated by the aforementioned concepts, this paper employs class-specific dictionaries to realize incremental learning for SAR ATR. Initially, the objective function of dictionary learning is regularized by the intra-class divergence [31], aiming to acquire a more discriminative dictionary. Subsequently, an enhanced dictionary learning approach is utilized to derive the class-specific dictionary for each target class. Next, the sparse representations of test samples under all class-specific dictionaries are computed. Based on these class-specific dictionaries, two metrics, namely reconstruction error and intra-class divergence, are calculated. Ultimately, these metrics are jointly considered for target recognition. Once the data of a new class is obtained, it suffices to learn its corresponding class-specific dictionary independently. Experiments conducted on the MSTAR dataset have verified the efficacy of the proposed method.

To summarize, the main contributions of this paper are as follows:

(1) A novel incremental SAR ATR method utilizing class-specific dictionaries is developed. This approach enables incremental learning without the necessity of retaining historical data, optimizing storage and computational resources.

(2) Intra-class divergence is integrated into the dictionary learning framework as a constraint, significantly enhancing the discriminative power of class-specific dictionaries. This innovation improves the ability to distinguish between different target classes.

(3) Comparative analysis demonstrates that the proposed method outperforms existing incremental learning techniques in SAR ATR tasks, demonstrating superior recognition accuracy and robustness.

The following sections of this paper are systematically arranged. Section II reviews the related studies, including incremental learning and sparse representation classifiers. In Section III, the detailed implementation of our proposed incremental SAR ATR method using class-specific dictionaries is elaborated. Section IV conducts multiple experiments on the MSTAR dataset, presenting and analyzing the corresponding experimental results. Finally, Section V summarizes the research conclusions and prospects for future work.

2. Related Works

This research primarily concerns incremental learning and sparse representation classifiers. This section elucidates the fundamental strategies of incremental learning and the operational principles of sparse representation classifiers, laying the groundwork for the subsequent discussions.

2.1. Incremental Learning

Incremental learning is used to solve the problem of the high computational cost of model updates, and it is not only for deep learning methods but also for traditional methods. In detail, incremental learning requires that the model can continuously learn the new knowledge and update itself with a small computation cost while retaining the previously learned information [32,33]. According to different tasks, incremental learning can be divided into task incremental learning, domain incremental learning, and class incremental learning [34]. Here, we only discuss class incremental learning, which continuously learns knowledge from new class targets [35,36].

In recent years, the implementation methods of incremental learning can be roughly divided into three categories: model-structure-based methods, replay-based methods, and regularization-based methods. Model structure-based methods continuously modify the model structures during incremental learning, which adds new structures for incremental tasks. RKR [37], SVDD [38], one-class-SVM [39] and ICAC [40] all belong to this kind of method. Replay-based methods (such as iCaRL [41], EVM [42] and CBesIL [15]) restore representative exemplars of old class targets. During incremental learning, these exemplars are mixed with new class targets to retrain the model. These kinds of methods have better performance than other incremental learning methods, but they face the problem of how to select high-quality key examples. Regularization-based methods make use of knowledge distillation as the regularization term to constrain the model. This kind of method requires storing the weight of the old model to obtain the source of knowledge distillation. In addition, regularization-based methods are often used in combination with replay-based methods.

In fact, replay-based methods are most used in incremental learning, while our proposed method belongs to the category of model-structure-based methods. In the following, we refer to class incremental learning as incremental learning for convenience.

2.2. Sparse Representation Classifier

Sparse representation has been widely used in the field of signal processing. The purpose of sparse representation is to find the sparsest representation of test samples using a linear combination of these training samples [43].

Consider a training sample set $Y=[Y_1,Y_2,\dots ,Y_K]\in R^{m\times n}$ with $K$ classes. Here, $m$ represents the length of the sample, while $n$ denotes the number of samples. $Y_i=[y_i^1, y_i^2, \dots , y_i^{n_i}]\in R^{m\times n_i}$ represents the training samples of class $i$, and $y_i^j$ is the $j- \mathrm{th}$ of $Y_i$. $y$ is a column vector representing the test sample. The sparse representation problem can be denoted by the following equation:

$$\widehat{\alpha }=\underset{\alpha }{\arg \min }{‖y-Y\alpha ‖}_2^2 s.t. {‖\alpha ‖}_0\le T$$

(1)

where $\alpha$ is the sparse representation coefficient vector; $T$ is the sparse threshold; ${‖ \cdot ‖}_0$ means $L_0$ norm; and ${‖\alpha ‖}_0$ reflects the number of non-zero elements in $\alpha$. The optimization of the $L_0$ norm is an NP-hard problem in Equation (1); therefore, in practical applications, we usually use the $L_1$ norm instead of the $L_0$ norm. In this case, Equation (1) can be expressed as

$$\widehat{\alpha }=\underset{\alpha }{\arg \min }\left\{{‖y-Y\alpha ‖}_2^2 + \gamma \cdot {‖\alpha ‖}_1\right\}$$

(2)

where the parameter $\gamma$ is a factor used to balance reconstruction error and sparsity.

As for the sparse representation classifier, it makes use of the reconstruction errors of various classes to predict the class of the test sample $y$. The detailed process is presented in Equation (3).

$$identity(y)=\underset{i}{\arg \min }\left\{erro{r}_i\right\} =\underset{i}{\arg \min }\left\{{‖y-Y_i{\widehat{\alpha }}_i‖}_2\right\}, i=1,2,\dots ,K$$

(3)

where ${\widehat{\alpha }}_i$ is the sparse coefficient vector corresponding to the $i-th$ class. Additionally, $identity(y)$ denotes the predicted class of the test sample $y$, and $erro{r}_i={‖y-Y_i{\widehat{\alpha }}_i‖}_2$ represents the reconstruction error if the test sample $y$ corresponds to $Y_i$. Finally, the test sample $y$ is divided into the class with the minimum reconstruction error.

3. Methods

In this section, we introduce our proposed incremental SAR target recognition method based on a class-specific dictionary. The schematic diagram of our method is shown in Figure 2. First, for each class of targets, we learn the dictionaries individually using the improved dictionary learning method. These dictionaries are also called class-specific dictionaries. Then, these dictionaries are collected into a dictionary set $D$($D=\{D_1,D_2,\dots ,D_C\}$), where $D_i$ represents the sub-dictionary corresponding to the $i-th$ class, and $C$ denotes the number of classes. Finally, the target is classified by comprehensive utilization of the sparse representation coefficient and reconstruction error. When encountering the targets from the new category, the class-specific dictionary $D_{new}$ is learned in the same way. At the same time, the dictionary set $D$ is updated with $D=\{D, D_{new}\}$. The following parts introduces the class-specific dictionary learning, target recognition strategy, and incremental learning.

3.1. Class-Specific Dictionary Learning

In this paper, the sub-dictionary of each class target will be built by the dictionary learning method, and these dictionaries can also be called class-specific dictionaries.

For the targets of class $i$, its training set is $Y_i=\{y_i^1,y_i^2,\dots ,y_i^{N-1},y_i^N\}$, where $y_i^j$ represents the $j-th$ sample in $Y_i$ and $N$ denotes the number of samples. The process of dictionary learning can be represented by Equation (4).

$$\underset{D_i,X_i}{\min }\left\{{‖Y_i-D_i{X}_i‖}_2+\lambda {‖X_i‖}_1\right\}$$

(4)

In Equation (4), $X_i=\{x_i^1,x_i^2,\dots ,x_i^N\}$ represents the sparse coefficient matrix of $Y_i$ under dictionary $D_i$($D_i=\{d_i^1,d_i^2,\dots ,d_i^{n_i}\}$), and $n_i$ indicates the number of atoms in dictionary $D_i$. $\lambda$ is the weight factor. The dictionary learning process is completed by alternately updating $D_i$ and $X_i$.

The conventional dictionary learning methods only focus on the reconstruction performance and rarely consider the discriminative properties of sparse coefficients, which is not conducive to the classification task. To address this problem, here, we draw on the idea of FDDL and add constraints during dictionary learning. There are two ways to enhance the classification ability of dictionaries: (1) increasing inter-class differences, (2) reducing intra-class differences. We adopt the class-specific dictionary learning strategy and do not introduce information of other classes, so we can only reduce intra-class differences in this paper. In this case, the objective function of class-specific dictionary learning can be expressed as Equation (5).

$$\underset{D_i,X_i}{\min } \left\{ {‖Y_i-D_i{X}_i‖}_F^2+{\lambda }_1\cdot {‖X_i‖}_1+{\lambda }_2\cdot f\left(X_i\right) \right\} s.t. {‖d_i^k‖}_2=1$$

(5)

Here, $f(X_i)$ represents the intra-class difference, and ${\lambda }_1$ and ${\lambda }_2$ are weight factors to balance sparsity and intra-class divergence. For class-specific dictionary, intra-class differences can be reduced by minimizing the intra-class divergence of the sparse coefficient matrix $X_i$. This process can be expressed as

$$\underset{X_i}{\min }f\left(X_i\right)= \underset{X_i}{\min }\left\{{\displaystyle {\sum }_{j=1}^N\left(x_i^j-m_i\right){\left(x_i^j-m_i\right)}^T}\right\}, x_i^j\in X_i$$

(6)

In Equation (6), $m_i$ is the mean vector of $X_i$, and $m_i={\displaystyle {\sum }_{j=1}^N{x}_i^j/N}$. We build the matrix $M_i$ with the same size as $X_i$, and make its column vectors all be $m_i$. Therefore, $f\left(X_i\right)={‖X_i-M_i‖}_F^2$, and Equation (5) can be rewritten as

$$\underset{D_i,X_i}{\min } \left\{ {‖Y_i-D_i{X}_i‖}_F^2+{\lambda }_1\cdot {‖X_i‖}_1+{\lambda }_2\cdot {‖X_i-M_i‖}_F^2\right\} s.t. {‖d_i^k‖}_2=1$$

(7)

Equation (7) needs to optimize $D_i$ and $X_i$. We adopt the alternating optimization strategy; that is, fixed $D_i$ optimizes $X_i$, and then fixed $X_i$ optimizes $D_i$.

First, fix $D_i$ to optimize $X_i$. When dictionary $D_i$ is fixed, the objective function is equivalent to

$$\underset{X_i}{\min }f\left(X_i\right)= \underset{X_i}{\min }\left\{{\displaystyle {\sum }_{j=1}^N\left(x_i^j-m_i\right){\left(x_i^j-m_i\right)}^T}\right\}, x_i^j\in X_i$$

(8)

Equation (8) can be solved according to the projection iteration method to obtain the sparse representation coefficient matrix $X_i$.

Second, fix $X_i$ and optimize $D_i$. It is known that ${\lambda }_1\cdot {‖X_i‖}_1+{\lambda }_2\cdot f\left(X_i\right)$ is a constant when $X_i$ is fixed, so Equation (7) can be simplified as

$$\underset{D_i}{\min } \left\{{‖Y_i-D_i{X}_i‖}_F^2\right\} s.t. {‖d_i^k‖}_2=1$$

(9)

In this case, the objective function is the same as that in conventional dictionary learning, and dictionary $D_i$ can be updated according to Algorithm 1.

Algorithm 1: Fix $X_i$ and optimize $D_i$

Input: $D_i=\{d_i^1,d_i^2,\dots ,d_i^{n_i}\}$//Initialized class-specific dictionary

Input: $Y_i=\{y_i^1,y_i^2,\dots ,y_i^{N-1},y_i^N\}$//Training data of $i-th$ class

Input: $X_i=\{x_i^1,x_i^2,\dots ,x_i^N\}$//Sparse coefficient matrix

1:  For $k=1,2,3,\dots ,n_i$ do

2:     It’s known that $D_i{X}_i=d_i^k{x}_i^k+{\displaystyle {\sum }_{j\ne k}{d}_i^k{x}_i^k}$ ($j=1,2,\dots ,n_i$). Let $E_i^k{=\mathrm{Y}}_i-{\displaystyle {\sum }_{j\ne k}{d}_i^j{x}_i^j}$, then Equation (9) can be represented as $\underset{d_i^k}{\min }\left\{{‖E_i^k-d_i^k{x}_i^k‖}_F^2\right\} s.t. {‖d_i^k‖}_2=1$.

3:     Solve $d_i^k$ by least square method.

4:     Normalize $d_i^k$, and $d_i^k=d_i^k/‖d_i^k‖$.

5:  end for

Output: $D_i=\{d_i^1,d_i^2,\dots ,d_i^{n_i}\}$//The updated class-specific dictionary

SAR target recognition includes two steps: feature extraction and classification. Incremental SAR ATR methods require incremental feature extraction, and it is a subject worthy of study. In this paper, we directly convert SAR images into vectors and then construct the training set and test set. The method does not have the process of feature extraction.

3.2. Target Classification Scheme

As shown in Figure 2, after obtaining the class-specific dictionaries of various classes, we collect them to build a dictionary set for classification. The reconstruction error and discriminant information of the coefficient (also referred to as the intra-class difference in this paper) are used during class-specific dictionary learning, and these two items are also used comprehensively for classification during testing. Specifically, it is used to solve the sparse representation coefficient of the sample $y$ under dictionary $D_i$, and the solution method can refer to Equation (10).

$$\widehat{x}=\arg \underset{x}{\min }\left\{{‖y-D_{i}x‖}_2+\gamma \cdot {\displaystyle \frac{{‖x-m_i‖}_2^2}{{‖x‖}_2}}\right\}$$

(10)

In Equation (10), $m_i$ is the mean vector of sparse representation coefficients obtained by training samples of the $i-th$ class during training. $\gamma$ is the weight factor. In general, the least square method is usually used to solve $\widehat{x}$, which could significantly reduce the computation complexity.

On the basis of $D_i$, $m_i$ and $\widehat{x}$, we calculate the measure $e_i$ for classification. As shown in Equation (11), it includes two parts: the reconstruction error term (${‖y-D_i\widehat{x}‖}_2$) and the coefficient discriminant term (${‖\widehat{x}-m_i‖}_2/{‖\widehat{x}‖}_2$). $\gamma$ is the weight factor to balance them, which is the same as that in Equation (10).

$$e_i={‖y-D_i\widehat{x}‖}_2^2+\gamma \cdot {\displaystyle \frac{{‖\widehat{x}-m_i‖}_2^2}{{‖\widehat{x}‖}_2}}$$

(11)

Finally, the measures of test sample $y$ under various class-specific dictionaries are calculated. Then, as shown in Equation (12), the test sample $y$ belongs to the category with minimum $e_i$.

$$identity\left(y\right)=\arg \underset{i=1,2,\dots k}{\min }\left\{e_i\right\}$$

(12)

3.3. Incremental Dictionary Learning

After obtaining the samples of new classes, we take Equation (2) as the objective function to learn the class-specific dictionary of these samples, and it is represented as $D_{New}$. Then, the dictionary set $D$ is updated with $D_{New}$, and it is $D=\{D_1,D_2,\dots ,D_N,D_{New}\}$. On the basis of the updated dictionary set $D$, the sparse representation coefficients of these test samples are solved.

We comprehensively consider the reconstruction error term and the coefficient discriminant term to classify the targets.

In this paper, the learning process of a class-specific dictionary does not need to consider the information from other classes, so it is more suitable for the class incremental learning scenario in this paper.

4. Experiments and Results

In this section, we conducted several experiments on MSTAR dataset to evaluate the effect of our method. First, some implementation details are introduced, including the datasets and evaluation metrics. Second, the experimental scenario settings and incremental recognition performance under different scenarios are presented. At the same time, we compare our method with several state-of-the-art methods in this part. Finally, we discuss the influence of parameters on experimental results.

4.1. Inplementations

4.1.1. Dataset

We conduct experiments on the MSTAR (The Moving and Stationary Target Acquisition and Recognition) dataset [44]. The MSTAR dataset was established by the Air Force Research Laboratory (AFRL) and Defense Advanced Research Project Agency (DARPA), and it was widely used in the research of SAR target recognition. This dataset contains SAR images under Standard Operation Condition (SOC) [45] and Extended Operation Condition (EOC) [46], and these images are imaged in the X-band and with HH polarization. In addition, the range and azimuth resolution of them are both 0.3 m. Here, we utilized the images under SOC to conduct experiments. The SAR images of these targets are shown in Figure 3, and they include 10 classes of military vehicles, including BMP2, BTR70, T72, BTR60, 2S1, BRDM2, D7, T62, ZIL131, and ZSU234. The azimuth angles of these images range from 0 to 360 degrees. In our experiments, images with depression angles of 15 and 17 are used to establish the training set and testing set. The configuration of ten classes of targets is presented in

Table 1. Configuration of ten-class targets under SOC.

Target	Training		Test
	Num	Angle	Num	Angle
BMP2	233	17	195	15
BTR70	233	17	196	15
T72	233	17	196	15
BTR60	256	17	195	15
2S1	299	17	274	15
BRDM2	298	17	274	15
D7	299	17	274	15
T62	299	17	273	15
ZIL131	299	17	274	15
ZSU234	299	17	274	15

.

In our experiments, all images are resized to 64*64 by center cropping. After that, these images are reshaped into vectors to construct a training set and test set.

4.1.2. Evaluation Protocol

The performance of our method is evaluated by recognition accuracy. Six state-of-the-art methods, including Replay [47], iCaRL [41], Wa [48], Podnet [49], ICAC [40], and CBesIL [15], were used to carry out comparative experiments. In our experiments, the backbones of iCaRL, Replay, Wa, ICAC and Podnet are all Resnet18. A brief description of these methods is as follows.

• Replay: Replay retains a small amount of old category data as an instance set. Then, the instance set is used for training in the process of updating new data to review old knowledge.
• iCaRL: iCaRL builds and manages an exemplar set, which is a representative sample set of old data. After the representation learning of these data, iCaRL classifies the sample with the nearest-mean-of-exemplars rule.
• Wa: Wa is an improvement of iCaRL. On the basis of iCaRL, Wa normalized the classifier amplitude. This operation could eliminate the deviation in the model updating process.
• Podnet: Inspired by the representation learning, Podnet improves the distillation loss with pooled outputs distillation (POD). In addition, it represents every class with several proxy vectors, so it has better performance in incremental learning.
• ICAC: ICAC adaptively adds new anchored class centers for new classes, and the features of new class will be clustered around the corresponding center. For old classes, ICA retains key samples for each class. In addition, ICAC proposes an SL (Separable Learning) strategy to address the class imbalance between new and old classes.
• CBesIL: To reduce data storage pressure, CBesIL proposes a class boundary selection method to build the exemplar set. When performing incremental learning, CBesIL employs a boundary-based reconstruction method to rebuild the key data to avoid catastrophic forgetting.

As presented in

Table 2. Three different incremental learning scenarios for MSTAR dataset.

Scenario	BMP2	BTR70	T72	BTR60	2S1	BRDM2	D7	T62	ZIL131	ZSU234
A	Task_1				Task_2	Task_3	Task_4	Task_5	Task_6	Task_7
B	Task_1				Task_2		Task_3		Task_4
C	Task_1				Task_2			Task_3

, we set up three different scenarios for the MSTAR dataset to carry out incremental learning experiments, and they are Scenario_A, Scenario_B and Scenario_C. The initial classes of three scenarios are all 4. However, the incremental classes (step sizes) of them are 1, 2 and 3, respectively. The settings of three scenarios are consistent with that in Reference [40].

4.2. Incremental Recognition Performance

The proposed method is compared with the above-mentioned state-of-the-art methods on the MSTAR dataset. In addition, the recognition accuracy of Joint Training is taken as the baseline. Among these methods, CBesIL belongs to the traditional method, while the other methods are based on deep learning. As for the setting of hyper-parameters, the exemplar size in Replay, iCaRL, and Podnet are all set to 30, which is consistent with the setting of Reference [40]. The number of atoms in the class-specific dictionary is set to 40, while the weight factors are set to 0.1 and 0.01, respectively.

It should be noted that Joint Training takes Resnet18 as the backbone to extract targets’ features; then, it makes use of a softmax classifier to recognize these targets. Furthermore, Joint Training adopts a batch training strategy. This means that Joint Training makes use of all training data to update the SAR ATR system when encountering data of new classes. In theory, the recognition accuracy of Joint Training should be significantly better than these incremental learning methods.

We conducted experiments on the three above-mentioned scenarios. The overall recognition accuracies of these methods are presented in

Table 3. The overall recognition accuracy of several methods under three scenarios.

Method	Scenario_A							Scenario_B				Scenario_C
	Task_1	Task_2	Task_3	Task_4	Task_5	Task_6	Task_7	Task_1	Task_2	Task_3	Task_4	Task_1	Task_2	Task_3
Replay	0.9770	0.9527	0.9414	0.9370	0.9345	0.9358	0.9592	0.9770	0.9534	0.9212	0.9456	0.9770	0.9713	0.9612
iCaRL	0.9834	0.9612	0.9414	0.9514	0.9457	0.9619	0.9604	0.9834	0.9692	0.9435	0.9534	0.9834	0.9769	0.9715
Wa	0.9834	0.9669	0.9496	0.9383	0.9414	0.9507	0.9559	0.9834	0.9624	0.9505	0.9464	0.9834	0.9688	0.9666
Podnet	0.9859	0.9754	0.9564	0.9545	0.9558	0.9521	0.9633	0.9859	0.9609	0.9547	0.9386	0.9859	0.9657	0.9604
ICAC	0.9949	0.9804	0.9676	0.9565	0.9483	0.9342	0.9176	0.9949	0.9735	0.963	0.9477	0.9949	0.9713	0.9564
CBesIL	0.9806	0.828	0.7744	0.7633	0.7511	0.7313	0.7215	0.9806	0.8113	0.7639	0.7021	0.9806	0.7749	0.7175
Our Method	0.9987	0.9896	0.9662	0.9707	0.9680	0.9707	0.9736	0.9987	0.9662	0.9680	0.9736	0.9987	0.9707	0.9736
Joint Training	0.9962	0.9962	0.9917	0.9925	0.9968	0.9963	0.9951	0.9962	0.9917	0.9968	0.9951	0.9962	0.9925	0.9951

. Furthermore, we have visualized these accuracies in Figure 4 for a more intuitive comparison. The codes of ICAC and CBesIL have not been published, so we directly cited the experimental results of Reference [40]. The other data in Table 3 were obtained from our own experiments.

It is obvious that Joint Training has the best recognition ability in the three scenarios, and its accuracies are more than 0.9917. Joint Training performs almost as well as expected, so we regard its accuracies as the benchmark. In general, with the gradual increase in classes, the recognition accuracies of these incremental learning methods basically present a downward trend. Taking Scenario_A as an example, we analyze the performance of these incremental learning methods. First, the final accuracies (accuracies of Task_7) of several incremental learning methods are 0.9592, 0.9604, 0.9559, 0.9633, 0.9176, 0.7215, and 0.9736. Compared with other incremental learning methods, the accuracies of our method are 0.0144, 0.0132, 0.0177, 0.0560 and 0.2521 higher. Second, the average accuracies of seven tasks in Replay, iCaRL, Wa, Podnet, ICAC and CBesIL are 0.9482, 0.9579, 0.9552, 0.9633, 0.9571, 0.7929. At the same time, the average accuracy of our method is 0.9767. It is obvious that our method achieves a higher average accuracy than other methods. Third, our method performs better than other incremental learning methods from Task_1 to Task_7 in Scenario_A, and it has the higher recognition accuracies in seven tasks.

As for Scenario_B, first, the average recognition accuracies of four tasks in Replay, iCaRL, Wa, Podnet, ICAC, CBesIL, and our method are 0.9493, 0.9624, 0.9607, 0.9600, 0.9698, 0.8145 and 0.9766, respectively. Our method performs better on average accuracy. Second, our method has higher recognition accuracy on three tasks (Task_1, Task_3 and Task_4), and it only performs slightly worse than iCaRL on Task_3. Furthermore, after analyzing the results of Scenario_C, we can draw similar conclusions as in Scenario_B. In summary, our method has better performance on incremental SAR target recognition.

It should be noted that, for each method, the recognition accuracies of Task_1 in Scenario_A, Scenario_B and Scenario_C are identical. For example, the accuracies of iCaRL’s Task_1 are 0.9834 in the three scenarios. This is because their training data are exactly the same. Furthermore, in our method, Task_3 of Scenario_A and Task_2 of Scenario_B have the same accuracy (they are both 0.9662). Similar situations include Task_4 of Scenario_A and Task_2 of Scenario_C (0.9565), Task_5 of Scenario_A, Task_3 of Scenario_B (0.9680), etc. This is because our method trains these dictionaries separately for each class of targets. The recognition accuracy is only related to the total number of classes, and it has nothing to do with the step size during incremental learning.

Different from the overall accuracy in Table 3, we analyzed the recognition accuracy of various class targets in Task_7 (Scenario_A). The recognition results are presented in

Table 4. The recognition accuracy of several methods in Task_7.

Method	BMP2	BTR70	T72	BTR60	2S1	BRDM2	D7	T62	ZIL131	ZSU234	Overall
Joint Training	0.9897	1.0000	1.0000	1.0000	0.9818	0.9891	1.0000	0.9963	0.9964	1.0000	0.9951
Replay	0.8821	0.9694	0.9592	0.9436	0.9891	0.8650	0.9891	0.9817	0.9891	1.0000	0.9592
iCaRL	0.9282	0.9694	0.9796	0.8462	0.9635	0.9124	0.9781	0.9963	0.9964	1.0000	0.9604
Wa	0.9641	0.9694	0.9643	0.9026	0.9343	0.8942	0.9380	0.9853	1.0000	1.0000	0.9559
Podnet	0.9744	0.9694	0.9898	0.9538	0.9489	0.9088	0.9270	0.9707	1.0000	1.0000	0.9633
Our Method	1.0000	1.0000	1.0000	0.9949	0.9635	0.8759	0.9927	0.9524	0.9891	0.9964	0.9736

. Six methods, including Joint Training, Replay, iCaRL, Wa, Podnet and our method, are compared in Table 4. Obviously, as a benchmark, Joint Training has the best performance on each task. Then, our method performs better on five classes of targets (BMP2, BTR70, T72, BTR60 and D7) compared with Replay, iCaRL, Wa and Podnet. Furthermore, we find that several incremental learning methods achieve significantly lower accuracy on BRDM2 than other classes. For example, the accuracies of Replay, iCaRL, Wa and our method on BRDM2 are 0.0942, 0.0480, 0.0617 and 0.0977 lower than their respective overall accuracies.

Furthermore, we compare the time consumed by several methods, including Replay, iCaRL, Wa, Podnet, and our method. The time taken by them to complete the seven tasks in Scenario_A is presented in

Table 5. Time consumption of several methods in Scenario_A.

Method	Replay	iCaRL	Wa	Podnet	Our Method
Time (s)	310	485	524	929	457

. Among them, Replay requires the least time, and it is 310 s. Following the Replay method, our method consumes 457 s. The time consumed by iCaRL, Wa and Podnet is 28 s, 67 s and 472 s more than our method, respectively. On the whole, there is little difference in the time consumed by iCaRL, Wa and our method. Our method has some advantages in the time of model training. These methods are deployed on the computer with Intel Core i7-8700K CPU, NVIDIA GTX 1080Ti GPU and 16 GB memory.

4.3. Parametric Analysis

Here, we analyze the effect of four parameters on the experimental results. They are the iterations, the number of atoms, and the weight factors ${\lambda }_1$ and ${\lambda }_2$. The evaluation is mainly carried out from the perspective of recognition accuracy.

4.3.1. The Effect of Iterations

Taking BMP2 as an example, we conduct a qualitative analysis of the loss during dictionary learning. At this time, the number of dictionary atoms is 40, and the factors ${\lambda }_1$ and ${\lambda }_2$ are set to 0.1 and 0.01, respectively. As shown in Figure 5, when $iteration>30$, the value of loss almost does not change. Specifically, when $iteration=30$ and $iteration=60$, the loss values are 66.07 and 65.79, respectively. The difference between the two loss values is only 0.28, which is very subtle. We think the model converged when $iteration=30$. In addition, the change trend of the loss curve in other class-specific dictionaries is basically consistent with that in Figure 5.

Quantitatively, we train these class-specific dictionaries when the iterations are 5, 10, 15, 30, 45 and 60, respectively. Then, the recognition accuracy under different iterations is measured. Taking Scenario_A as an example, the accuracy is shown in Figure 6. It is obvious that the change in accuracy is more obvious when the iterations are 5 and 10. However, when the iterations are 15, 30, 45 and 60, the accuracy fluctuates only slightly. This phenomenon indirectly indicates that the model converged when $iteration>30$. Therefore, we take $iteration=45$ in our experiments.

4.3.2. The Effect of Atom Number

A class-specific dictionary is composed of multiple atoms. In theory, a large number of atoms will make the dictionary have a better representation ability, but it would significantly increase the computational complexity. Here, we set the number of atoms to be 30, 40, 50, 60, 70 and 80, and train these class-specific dictionaries, respectively. On the basis of these dictionaries, the recognition accuracy under Scenario_A is calculated, which is shown in Figure 7. In addition, in this experiment, the iteration is 45, and the weight factors ${\lambda }_1$ and ${\lambda }_2$ are set to 0.1 and 0.01, respectively.

It can be found that, when the number of atoms is 40, 55, 70, and 85, the recognition accuracies of several models in seven tasks are basically the same. This leads to two conclusions. First, when the number of atoms is 40, it can meet the requirements of the experiments. Second, our proposed method is robust, and it is insensitive to the number of atoms. Based on the above analysis, we set the number of atoms to 40 in the several experiments above.

4.3.3. The Effect of Weight Factors ${\lambda }_1$ and ${\lambda }_2$

The weight factors ${\lambda }_1$ and ${\lambda }_2$ are used to control the weight of sparsity and intra-class divergence, respectively. As presented in

Table 6. Combination of ${\lambda }_1$. and ${\lambda }_2$ in four different cases.

Case	Case_A	Case_B	Case_C	Case_D
${\lambda }_1$	0.1	0.1	0.1	0.1
${\lambda }_2$	0	0.1	0.02	0.01
${\lambda }_1/{\lambda }_2$	-	1	5	10

, we set four different cases to analyze the effect of weight factors ${\lambda }_1$ and ${\lambda }_2$. On this basis, we conducted several experiments in Scenario_A, and the recognition accuracy of several cases in Scenario_A is shown in Figure 8.

In addition, it should be noted that, in this experiment, we set $iteration=45$, and the number of atoms in the class-specific dictionary is set to 40.

On the whole, the recognition accuracy of each task in Case_D is the highest, and the result in Case_A is second only to that in Case_D. The results in Case_B and Case_C are worse. It can be found that, in Case_B and Case_C, intra-class divergence takes a larger proportion in the objective function, while sparsity takes a larger proportion in Case_A and Case_D. Based on the above phenomenon, we think that sparsity has a greater impact on the recognition accuracy than intra-class divergence. In addition, in the objective function, the intra-class divergence with a small proportion can improve the recognition accuracy, while the intra-class divergence with a large proportion will have a negative impact on the experimental results.

5. Conclusions

In order to realize the rapid and low-cost update of the SAR ATR system, this paper proposes an incremental SAR ATR method based on a class-specific dictionary. To this end, we make use of intra-class divergence to constrain the process of dictionary learning. Then, the class-specific dictionary of each class target is learned separately. These class-specific dictionaries are organized into a dictionary set for classification. During testing, the sparse representation coefficients of these samples under all dictionaries are calculated. On the basis of the coefficients, two indicators of reconstruction error and intra-class divergence are calculated, and finally, the targets are classified. When encountering new class data, it is enough to learn the corresponding class-specific dictionary, and then it is used to update the dictionary set. Experimental results on the MSTAR dataset have demonstrated the effectiveness of our method. In summary, the learning process of class-specific dictionaries does not require the participation of other class samples, so it is very suitable for class incremental learning.

For future research, our method will be enhanced in two key aspects.

(1) Incremental feature extraction [50,51]: the current approach of directly learning dictionaries from vectorized SAR images without feature extraction incurs high computational costs. We will explore incremental feature extraction techniques to mitigate this issue. Additionally, ensuring feature extraction captures target-specific features rather than SAR image background information is also a key focus for future work.

(2) Open-world recognition [52,53]: Class incremental learning leverages novel class targets to rapidly update SAR ATR systems, while open set recognition [54,55] facilitates the quick discovery of unknown class targets. These two approaches are inseparable in their applications, and their combined use has been termed open world recognition by scholars [52,53]. In future work, we will investigate SAR target recognition under open world scenarios to enable the SAR systems to adapt efficiently to dynamic environments.