Hyperspectral detection method and device based on low-rank sparse joint constraint autoencoder

Abstract

The application discloses a hyperspectral detection method and device based on a low-rank sparse joint constraint self-encoder and belongs to the technical field of remote sensing image processing. The method inputs a random noise image into a full convolution self-encoder to obtain a reconstructed background image; a joint optimization model is constructed based on a low-rank constraint and a sparse constraint, a background matrix, a target matrix, self-encoder network parameters and a Lagrange multiplier are iteratively updated through an alternating direction multiplier method; and a target detection result is generated according to the reconstruction error of the final reconstructed background image and an original hyperspectral image. The application effectively strips the sparse target component while accurately reconstructing the low-rank background by jointly constraining the low-rank nature of the background and the sparsity of the target, significantly reduces the false alarm rate and improves the detection precision of small targets in the hyperspectral image.

Description

Technical Field

[0001] This invention belongs to the field of remote sensing image processing technology, specifically relating to a hyperspectral detection method and apparatus based on a low-rank sparse joint constraint autoencoder. Background Technology

[0002] Hyperspectral image target detection technology utilizes imaging spectrometers to acquire unified spectral data across dozens to hundreds of consecutive narrow bands from the visible to the infrared spectrum. This allows for the capture of subtle spectral feature differences in ground objects, enabling the location or extraction of targets of interest within the image. Based on whether the target's spectral information is known, hyperspectral target detection is categorized into supervised and unsupervised methods. Unsupervised methods are suitable for situations where target spectral information is difficult to obtain and represent the most common research direction in practical applications.

[0003] The core idea of ​​unsupervised hyperspectral target detection methods is to construct a background model and identify pixels that cannot be effectively reconstructed by the background model or have extremely low probability as targets. Autoencoders, as a deep learning network architecture, have powerful feature extraction and generation capabilities and are widely used in hyperspectral target detection. Since the types of ground features constituting the background are limited, the space formed by the spectral vectors of background pixels has low rank. By imposing low-rank prior constraints on the autoencoder, it can be guided to generate the background, and pixels that cannot be effectively reconstructed are identified as targets.

[0004] In existing technologies, the hyperspectral target detection method based on a low-rank constrained autoencoder proposed by S. Wang et al. (Deep Low-Rank Prior for Hyperspectral Anomaly Detection, IEEE Transactions on Geoscience and Remote Sensing, vol.60, pp.1-17) optimizes the accuracy of background modeling by utilizing the low-rank characteristics of the background. However, this method only considers the low-rank prior of the background and fails to fully explore and utilize the sparsity prior of the target pixels. In hyperspectral scenes, targets typically have significant characteristics of extremely small spatial proportions and discrete distribution. If the low-rank nature of the background and the sparsity of the target can be constrained together in the model, the leakage of target information can be minimized while accurately reconstructing the background.

[0005] In summary, existing low-rank constraint-based autoencoder methods suffer from insufficient background reconstruction purity and easy leakage of target signals due to neglecting the prior sparsity of target pixels when constructing the background model. Therefore, there is an urgent need for a hyperspectral detection method that can effectively remove sparse target components while accurately reconstructing the low-rank background, in order to significantly reduce the false alarm rate and improve the detection accuracy of small targets in hyperspectral images. Summary of the Invention

[0006] To address the aforementioned technical problems, this invention provides a hyperspectral detection method and apparatus based on a low-rank sparse joint constraint autoencoder. The method introduces low-rank constraints and sparse constraints into the autoencoder and iteratively optimizes it using the alternating direction multiplier method, thereby accurately reconstructing the low-rank background while explicitly stripping the sparse target components.

[0007] To achieve the above objectives, the technical solution adopted by the present invention is as follows:

[0008] A hyperspectral detection method based on a low-rank sparse joint-constrained autoencoder, the method comprising:

[0009] Step 1: Obtain the original hyperspectral image and input the random noise image into a fully convolutional autoencoder to reconstruct the background image;

[0010] Step 2: Construct a joint optimization model with low-rank constraints and sparse constraints. The low-rank constraints are used to constrain the nuclear norm of the reconstructed background image, and the sparse constraints are used to constrain the column sparsity of the target matrix.

[0011] Step 3: Transform the joint optimization model into an augmented Lagrange function, and use the alternating direction multiplier method to iteratively update the reconstructed background image, the network parameters of the fully convolutional autoencoder, the target matrix, and the Lagrange multipliers. When updating the network parameters of the fully convolutional autoencoder, the loss function used includes regularization terms corresponding to the low-rank constraint and the sparse constraint. When updating the reconstructed background image, it depends on the current network parameters of the fully convolutional autoencoder. When updating the target matrix, it depends on the updated reconstructed background image.

[0012] Step 4: After the iteration is completed, the trained fully convolutional autoencoder is used to generate the final reconstructed background image, and the target detection result is generated based on the final reconstructed background image and the original hyperspectral image.

[0013] Furthermore, in step 1: the fully convolutional autoencoder includes an encoder and a decoder. The encoder includes five downsampling operations, each downsampling operation using a convolutional layer with a stride of 2 to progressively reduce the feature map resolution. The decoder includes five upsampling operations, each upsampling operation using nearest neighbor interpolation to double the feature map size. The feature map output from the first convolutional layer in the encoder and the feature map output from each downsampling stage both have 128 channels and are concatenated with the feature map from the corresponding upsampling stage in the decoder via skip connections. The last layer of the decoder uses a convolutional layer with a 1×1 kernel to restore the number of feature map channels to the number of bands in the original hyperspectral image and outputs a reconstructed background image through a Sigmoid activation function.

[0014] Furthermore, in step 2: during the process of constructing the joint optimization model of low-rank constraints and sparse constraints, the low-rank constraints are achieved by minimizing the kernel norm of the reconstructed background image, where the kernel norm is the sum of the singular values ​​of the reconstructed background image matrix; the sparse constraints are achieved by minimizing the sum of the L2 norms of each column of the target matrix, where each column corresponds to the spectral vector of a pixel, and the sum of the L2 norms is used to force as many whole columns as possible in the target matrix to be zero.

[0015] Furthermore, in step 3: when iteratively updating the reconstructed background image using the alternating direction multiplier method, a singular value threshold function is used to perform singular value shrinkage processing on the matrix of the reconstructed background image. The singular value threshold function sets the singular values ​​in the matrix of the reconstructed background image that are less than the singular value threshold to zero, and subtracts the singular value threshold from the singular values ​​that are greater than the singular value threshold. The singular value threshold is equal to 1 divided by the penalty factor.

[0016] Furthermore, in step 3: when iteratively updating the network parameters of the fully convolutional autoencoder using the alternating direction multiplier method, an adaptive weight map is introduced into the loss function. The adaptive weight map is calculated based on the residual image between the original hyperspectral image and the current reconstructed background image. The weight value of each pixel position in the adaptive weight map is negatively correlated with the reconstruction error of the corresponding pixel. Pixels with larger reconstruction errors are assigned smaller weights, and all weight values ​​are normalized to the range of zero to one.

[0017] Furthermore, in step 3: when iteratively updating the target matrix using the alternating direction multiplier method, a soft threshold function is used to set the columns in the matrix whose vector L2 norm is less than the soft threshold to zero, and the columns that are greater than or equal to the soft threshold are scaled. The scaled column vector is equal to the original column vector minus the soft threshold multiplied by the unit direction vector of the column vector; the soft threshold is equal to 1 divided by the penalty factor.

[0018] Furthermore, in step 4: the target detection result is obtained by calculating the L2 norm reconstruction error of the spectral vector of each pixel in the final reconstructed background image and the original hyperspectral image. The larger the reconstruction error, the higher the probability that the pixel is identified as the target. The reconstruction errors of each pixel are arranged according to the spatial arrangement of the original image to form a two-dimensional detection result map, and the elements in the two-dimensional detection result map are normalized. The normalized value represents the probability that each pixel is the target.

[0019] On the other hand, the present invention provides a hyperspectral detection device based on a low-rank sparse joint constraint autoencoder, comprising:

[0020] The image acquisition and mapping module is used to acquire the original hyperspectral image and input the random noise image into the fully convolutional autoencoder to map it into the reconstructed background image;

[0021] The model building module is used to build a joint optimization model with low-rank constraints and sparse constraints. The low-rank constraints are used to constrain the kernel norm of the reconstructed background image, and the sparse constraints are used to constrain the column sparsity of the target matrix.

[0022] The iterative update module is used to transform the joint optimization model into an augmented Lagrangian function, and to iteratively update the reconstructed background image, the network parameters of the fully convolutional autoencoder, the target matrix, and the Lagrangian multipliers sequentially using the alternating direction multiplier method. Specifically, when updating the network parameters of the fully convolutional autoencoder, the augmented Lagrangian function containing low-rank and sparse regularization terms is used as the network's loss function, and parameter optimization is performed through gradient backpropagation. The update of the reconstructed background image depends on the current network parameters of the fully convolutional autoencoder, and the update of the target matrix depends on the updated reconstructed background image.

[0023] The result generation module is used to generate a final reconstructed background image using the trained fully convolutional autoencoder after the iteration, and to generate a target detection result based on the final reconstructed background image and the original hyperspectral image.

[0024] Thirdly, the present invention provides an electronic device, comprising: one or more processors; and a memory for storing one or more programs; wherein, when the one or more programs are executed by the one or more processors, the one or more processors implement the aforementioned hyperspectral detection method based on a low-rank sparse joint constraint autoencoder.

[0025] Fourthly, the present invention provides a computer-readable storage medium having executable instructions stored thereon, which, when executed by a processor, enable the processor to implement the aforementioned hyperspectral detection method based on a low-rank sparse joint constraint autoencoder.

[0026] The beneficial effects of this invention are as follows:

[0027] First, this invention constructs a joint low-rank and sparse modeling framework that simultaneously captures the global correlation of background pixels and the isolation characteristics of target pixels. Existing single low-rank constraint methods are prone to causing overly smooth backgrounds and leakage of target signals. This invention, through a joint modeling mechanism, captures the global spectral correlation of the background while explicitly utilizing sparse constraints to capture the spatial isolation of target pixels. This forces the network to effectively separate the target signal from the background stream, preventing it from contaminating the low-rank background components, and significantly improving the detection accuracy and robustness of weak targets.

[0028] Second, by analyzing each training iteration as an alternating direction multiplier step, this invention derives a physically interpretable loss function containing explicit low-rank regularization and sparse regularization terms, establishing a fundamental link between deep learning and model-based optimization. Compared to existing black-box autoencoder methods, this invention enhances the interpretability of the model, giving the network training process a clear physical meaning.

[0029] Third, addressing the shortcomings of existing single low-rank methods that easily erroneously reconstruct small targets as background, this invention employs a complementary strategy of low-rank and sparseness. This strategy can effectively remove sparse target components while accurately reconstructing the low-rank background, significantly reducing the false alarm rate and improving the detection accuracy of small targets in hyperspectral images. It can be widely applied in fields such as military reconnaissance, environmental monitoring, and agricultural analysis. Attached Figure Description

[0030] Figure 1 This is a flowchart of the hyperspectral detection method based on a low-rank sparse joint constraint autoencoder according to the present invention.

[0031] Figure 2 This is a diagram of the fully convolutional autoencoder architecture with skip connections of the present invention;

[0032] Figure 3 This is a detailed architecture diagram of the modules included in the self-encoder of the present invention;

[0033] Figure 4 This is a schematic diagram of the datasets used in an embodiment of the present invention. I-III correspond to the HYDICE, Hyperion, and Pavia datasets, respectively.

[0034] Figure 5 This is a comparison diagram of the implementation effects of the present invention and existing technical methods. Detailed Implementation

[0035] The present invention will be further described below with reference to the accompanying drawings and embodiments.

[0036] like Figure 1 As shown, this invention provides a hyperspectral detection method based on a low-rank sparse joint constraint autoencoder. By designing an autoencoder architecture with low-rank and sparse joint constraints, it can effectively remove sparse target components while accurately reconstructing the low-rank background, thereby significantly reducing the false alarm rate and improving the detection accuracy of small targets in hyperspectral images. Specifically, the method includes:

[0037] Step 1: Obtain the original hyperspectral image and input the random noise image into a fully convolutional autoencoder to reconstruct the background image;

[0038] Step 2: Construct a joint optimization model with low-rank constraints and sparse constraints. The low-rank constraints are used to constrain the nuclear norm of the reconstructed background image, and the sparse constraints are used to constrain the column sparsity of the target matrix.

[0039] Step 3: Transform the joint optimization model into an augmented Lagrange function, and use the alternating direction multiplier method to iteratively update the reconstructed background image, the network parameters of the fully convolutional autoencoder, the target matrix, and the Lagrange multipliers. The loss function used to update the network parameters of the fully convolutional autoencoder includes regularization terms corresponding to the low-rank constraint and the sparse constraint. Updating the reconstructed background image depends on the current network parameters of the fully convolutional autoencoder, and updating the target matrix depends on the updated reconstructed background image.

[0040] Step 4: After the iteration is completed, the trained fully convolutional autoencoder is used to generate the final reconstructed background image, and the target detection result is generated based on the final reconstructed background image and the original hyperspectral image.

[0041] Furthermore, in step 1:

[0042] like Figure 2 As shown, the autoencoder used is a fully convolutional autoencoder. "Fully convolutional" means that the network only involves convolutional layers, excluding batch normalization layers, activation functions, and upsampling functions. The network architecture consists of an encoder and a decoder. The encoder contains 5 downsampling operations, and the decoder contains 5 upsampling operations. To simplify the diagram, repeated modules are represented by block #i, i=1,2,3,4,5,6, where Conv2d(mn,k×k,stride p), p=1,2 represents a convolutional layer with m input channels, n output channels, k×k kernel size, and p stride; BatchNorm2d represents a batch normalization layer; LeakyReLU and Sigmoid are activation functions; and Up2× represents upsampling by a factor of 2 (nearest neighbor interpolation).

[0043] like Figure 3 As shown, a detailed structural diagram of each block is presented:

[0044] (1) Encoder: The encoder consists of 15 convolutional layers and adopts a layered design of "feature extraction-downsampling-feature fusion". The feature processing capability is enhanced by modular repetition structure. Specifically, the network uses block #1 (1×1 convolution, stride 1) and block #2 (3×3 convolution, stride 2 + 3×3 convolution, stride 1) as the basic units, and then repeats the combination of "block #4 (1×1 convolution, stride 1) + block #3 (3×3 convolution, stride 2 + 3×3 convolution, stride 1)" 4 times. This repetition structure design achieves cross-channel feature fusion through the 1×1 convolution of block #4, and gradually reduces the feature map resolution through the stride 2 convolution of block #3 (becoming 1 / 16 of the original size after 4 downsampling), extracting multi-scale background features layer by layer (shallow blocks retain details, and deep blocks capture global background patterns). At the same time, multiple downsampling further weakens small target features because the proportion of target pixels in the feature map continues to decrease. Furthermore, the 128-dimensional feature maps generated by block #1 and block #4 in each repeating unit are concatenated with the feature maps of the corresponding layers in the decoder via skip connections, ensuring that spatial details (such as edges and textures) from different levels can be fused during decoding. Except for block #2, which reduces the input from the original number of bands B to 128 dimensions, the remaining convolutional layers maintain 128-dimensional outputs to avoid loss of spectral information and ensure the integrity of spectral features during encoding.

[0045] (2) Decoder: The decoder contains 11 convolutional layers. It gradually restores spatial resolution through upsampling (Up2×) and feature fusion, forming a symmetrical design with the encoder. Up2×, or "2x nearest neighbor interpolation upsampling", expands the spatial size of the feature map by a factor of 2 by copying pixel values ​​(e.g., from H / 16×W / 16 to H / 8×W / 8), thereby gradually improving the resolution and preparing for the reconstruction of a high-resolution background image. After each Up2× module, the upsampled feature map is concatenated with the 128-dimensional feature map from the corresponding layer of the encoder (block #1 or block #4) through skip connections to form a 256-dimensional input (128+128). This design allows the decoder to directly utilize the shallow details (such as edge information of block #1) and deep semantics (such as the global background mode of block #4) retained by the encoder when restoring resolution, avoiding the blurring of details caused by upsampling. The stitched 256-dimensional feature map is input into block #5, and the dimension is reduced to 128 dimensions through a 3×3 convolution. Then, the 1×1 convolution (stride 1) of block #6 restores the 128-dimensional feature map to the band dimension of the original hyperspectral image. Finally, the reconstruction result is output through the Sigmoid activation function, thus achieving high-precision reconstruction of the background.

[0046] The input to the fully convolutional autoencoder is a random noise image Z filled with uniform noise, which has the same dimension as the original hyperspectral image, i.e. Where w, h, and B are the width, height, and number of bands of the hyperspectral image, respectively. The values ​​of Z are sampled from a uniform distribution within the range [0, 0.1]. The final output of the fully convolutional autoencoder is an image with the same size as the original hyperspectral image, called the reconstructed background image. ,in This represents the mapping learned by the autoencoder. This represents the network parameters. The reason for inputting a random noisy image is that, according to the theory of deep hyperspectral priors, the network carries its own prior information, and can recover a clean background by inputting random noise, which is more effective than inputting the original image.

[0047] Furthermore, in step 2:

[0048] After constructing the autoencoder, the parameters of the autoencoder network can be trained by incorporating low-rank sparse prior constraints using the alternating direction multiplier method. Based on the traditional low-rank sparse matrix factorization model and the theory of autoencoders, hyperspectral images can be decomposed into a low-rank background component and a sparse target component:

[0049] (1)

[0050] in, This represents the hyperspectral image to be detected. This represents the reconstructed background image output by the trained autoencoder. A random, noisy image is used as the input to the autoencoder network. These are self-encoded, learnable parameters. This represents the mapping learned by the autoencoder. Represents the target matrix. B is the number of bands, and w×h is the image space size.

[0051] Because the background is low-rank and the target is sparse, the background and target can be solved by the following optimization problem:

[0052] (2)

[0053] in, The nuclear norm of a matrix is ​​used to constrain its rank. This means taking the L2 norm of each column of the matrix and then summing them, which allows us to... Set as many columns as possible to zero to achieve sparsity constraints. This is the regularization coefficient, used to balance the weights of the two optimization terms.

[0054] Furthermore, in step 3:

[0055] To avoid network parameters Its presence in the nuclear norm increases the difficulty of solving the problem. Firstly, the reconstructed background image is used. Adjust equation (2) to:

[0056] (3)

[0057] By using the augmented Lagrange function method, the constraint can be transformed into a penalty term in the Lagrange function:

[0058] (4)

[0059] in, Indicates the penalty factor. The trace of a matrix is ​​the sum of the elements on its diagonal. The Frobenius norm of a matrix is ​​represented by the square root of the sum of the squares of all its elements. The superscript T denotes the transpose of the Lagrange multiplier. Equation (4) is equivalently transformed into equation (5):

[0060] (5)

[0061] According to the ADMM algorithm, the original optimization problem can be solved by optimizing and updating the reconstructed background image separately. Target matrix and network parameters of autoencoders These three sub-problems are solved in the (k+1)th iteration, with the following iterative formula:

[0062] (6)

[0063] The solution to each subproblem is described below:

[0064] 1) Update and reconstruct the background image :fixed and , The update can be performed using equation (7):

[0065] (7)

[0066] in, It is a singular value thresholding function that measures the values ​​of elements in a matrix that are less than a certain value. The singular values ​​are filtered out, which can be specifically represented as:

[0067] (8)

[0068] in, , , Each is a matrix The left singular vector matrix, the singular value diagonal matrix, and the right singular vector matrix of the singular value decomposition. The contraction operator is defined as follows:

[0069] (9)

[0070] in, For real numbers, It is a symbolic function. Indicates taking and The larger one in equation (8). Will Effect on For each element on the diagonal, the absolute value is less than The element is set to zero, and the absolute value is greater than 0. The element sign remains unchanged, while the absolute value decreases. .

[0071] 2) Update autoencoder network parameters :fixed , , , Update network parameters The objective function corresponding to the optimization problem is:

[0072] (10)

[0073] This is used as the network's loss function, and each iteration is equivalent to training the network once. Furthermore, to further suppress the influence of potential target pixels during training, an adaptive weighting mechanism is introduced into the loss function:

[0074] (11)

[0075] in, Represents the loss function. It is an adaptive weighted graph; the symbol ⊙ represents element-wise multiplication, and It will be broadcast to all channel dimensions. This is for generating the adaptive weight graph. First, calculate the residual hyperspectral image. :

[0076] (12)

[0077] Where i is the column index, This represents the residual of the i-th pixel.

[0078] Subsequently, The expression is as follows:

[0079] (13)

[0080] Where i and j are column indices. This represents the reconstruction error of the i-th pixel. Let L be the reconstruction error (L2 norm) of the j-th pixel. Represents a weighted graph The i-th element in the image space is w×h. All values ​​are eventually normalized to the interval [0,1].

[0081] 3) Update the target matrix :fixed and Using equation (14) Update:

[0082] (14)

[0083] in, This is a soft thresholding function that sets the 2-norm of a vector in a matrix to be less than 1 / 2. The column becomes zero, greater than The column is scaled, specifically in the following form:

[0084] (15)

[0085] Where i is the column index, express The i-th column, express The i-th column, It is the 2-norm of a vector, which is the square root of the sum of the squares of all the elements of the vector.

[0086] 4) Update the Lagrange multipliers , :fixed , , Lagrange multipliers can be updated using the following formula:

[0087] (16)

[0088] Using formulas (7) to (16), update iteratively. , , , , , After N iterations, the background can be reconstructed using the proposed network:

[0089] (17)

[0090] Ultimately, the detection results can be obtained from the reconstruction error:

[0091] (18)

[0092] Where i is the column index, , The background of the reconstruction and the image to be detected The reconstruction error is calculated using the vector 2-norm, representing the spectrum of the i-th column, i.e., the i-th pixel. This represents the reconstruction error of the i-th pixel. A larger reconstruction error indicates a higher probability that the pixel is identified as a target. ( Write it in matrix form If the elements in D are normalized, then the values ​​in D represent the probability that each pixel is the target.

[0093] The effects of the present invention will be further explained below with reference to experiments.

[0094] This experiment evaluates the performance of the method of this invention on the HYDICE, Hyperion, and Pavia datasets. Figure 4 In this paper, I-III correspond to the HYDICE, Hyperion and Pavia datasets, respectively. On each dataset, the detection performance of the method of this invention is compared with that of six mainstream methods from both qualitative (including detection maps) and quantitative (including two AUC values) perspectives.

[0095] Figure 5 This is a comparison chart of the detection results of the method of this invention and mainstream methods on three datasets; where (a) represents the label, (b)-(g) correspond to six existing methods, namely GRX, LRASR, LRaSMD, Auto-AD, DeepLR, and DLRSPs-DAEs, respectively, and (h) corresponds to the method of this invention; see details: Figure 5In the diagram, (Ia) represents the label of the HYDICE dataset, and (Ib) to (Ih) represent the detection results of GRX, LRASR, LRaSMD, Auto-AD, DeepLR, DLRSPs-DAEs, and the method of this invention on the HYDICE dataset, respectively; (II-a) represents the label of the Hyperion dataset, and (II-b) to (II-h) represent the detection results of GRX, LRASR, LRaSMD, Auto-AD, DeepLR, DLRSPs-DAEs, and the method of this invention on the Hyperion dataset, respectively; (III-a) represents the label of the Pavia dataset, and (III-b) to (III-h) represent the detection results of GRX, LRASR, LRaSMD, Auto-AD, DeepLR, DLRSPs-DAEs, and the method of this invention on the Pavia dataset, respectively.

[0096] By comparing existing methods, the method of this invention, and the labeled methods, it can be seen that the method of this invention performs the best, significantly outperforming the six mainstream methods among existing technologies. Table 1 below lists the AUC values ​​(i.e., AUC values) of the method of this invention and the six mainstream methods on three datasets. and ). The value is between 0 and 1. The value is between 0 and 2. For The higher the value, the better the detection effect; for The larger the value, the stronger the ability to suppress the background and highlight the target.

[0097] Table 1

[0098]

[0099] As shown in the table above, the method of this invention has the largest [performance] on three different datasets (HYDICE, Hyperion, and Pavia). and This further demonstrates that the method of the present invention has the best detection performance compared to existing methods, and possesses the strongest overall ability to suppress background and highlight the target. Compared to DeepLR, which only applies low-rank constraints, the method of the present invention... The significantly higher performance compared to DeepLR indicates that the present invention, by simultaneously applying low-rank and sparse constraints, can take into account the characteristics of both the background and the target, thereby improving the separation between the background and the target. Compared to DLRSPs-DAEs, which also apply low-rank and sparse constraints but use a dual autoencoder structure, the present invention... It still has obvious advantages, demonstrating the superiority of the single-branch unified architecture of the present invention.

[0100] On the other hand, the present invention provides a hyperspectral detection device based on a low-rank sparse joint constraint autoencoder, the various modules of which can implement the various steps of the aforementioned method, specifically including:

[0101] The image acquisition and mapping module is used to acquire the original hyperspectral image and input the random noise image into the fully convolutional autoencoder to map it into the reconstructed background image;

[0102] The model building module is used to build a joint optimization model with low-rank constraints and sparse constraints. The low-rank constraints are used to constrain the kernel norm of the reconstructed background image, and the sparse constraints are used to constrain the column sparsity of the target matrix.

[0103] The iterative update module is used to transform the joint optimization model into an augmented Lagrangian function, and to iteratively update the reconstructed background image, the network parameters of the fully convolutional autoencoder, the target matrix, and the Lagrangian multipliers sequentially using the alternating direction multiplier method. Specifically, when updating the network parameters of the fully convolutional autoencoder, the augmented Lagrangian function containing low-rank and sparse regularization terms is used as the network's loss function, and parameter optimization is performed through gradient backpropagation. The update of the reconstructed background image depends on the current network parameters of the fully convolutional autoencoder, and the update of the target matrix depends on the updated reconstructed background image.

[0104] The result generation module is used to generate a final reconstructed background image using the trained fully convolutional autoencoder after the iteration, and to generate a target detection result based on the final reconstructed background image and the original hyperspectral image.

[0105] Thirdly, the present invention provides an electronic device, comprising: one or more processors; and a memory for storing one or more programs; wherein, when the one or more programs are executed by the one or more processors, the one or more processors implement the aforementioned hyperspectral detection method based on a low-rank sparse joint constraint autoencoder.

[0106] Fourthly, the present invention provides a computer-readable storage medium having executable instructions stored thereon, which, when executed by a processor, enable the processor to implement the aforementioned hyperspectral detection method based on a low-rank sparse joint constraint autoencoder.

[0107] The specific embodiments described above further illustrate the purpose, technical solution, and beneficial effects of the present invention. It should be understood that the above descriptions are merely specific embodiments of the present invention and are not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A hyperspectral detection method based on a low-rank sparse joint-constrained autoencoder, characterized in that, The method includes: Step 1: Obtain the original hyperspectral image and input the random noise image into a fully convolutional autoencoder to reconstruct the background image; Step 2: Construct a joint optimization model with low-rank constraints and sparse constraints. The low-rank constraints are used to constrain the nuclear norm of the reconstructed background image, and the sparse constraints are used to constrain the column sparsity of the target matrix. Step 3: Transform the joint optimization model into an augmented Lagrange function, and use the alternating direction multiplier method to iteratively update the reconstructed background image, the network parameters of the fully convolutional autoencoder, the target matrix, and the Lagrange multipliers. When updating the network parameters of the fully convolutional autoencoder, the loss function used includes regularization terms corresponding to the low-rank constraint and the sparse constraint. When updating the reconstructed background image, it depends on the current network parameters of the fully convolutional autoencoder. When updating the target matrix, it depends on the updated reconstructed background image. Step 4: After the iteration is completed, the trained fully convolutional autoencoder is used to generate the final reconstructed background image, and the target detection result is generated based on the final reconstructed background image and the original hyperspectral image.

2. The hyperspectral detection method based on a low-rank sparse joint constraint autoencoder according to claim 1, characterized in that, In step 1: the fully convolutional autoencoder includes an encoder and a decoder. The encoder includes five downsampling operations, each downsampling operation using a convolutional layer with a stride of 2 to gradually reduce the feature map resolution. The decoder includes five upsampling operations, each upsampling operation using nearest neighbor interpolation to double the feature map size. The feature map output from the first convolutional layer in the encoder and the feature map output from each downsampling stage both have 128 channels and are concatenated with the feature map from the corresponding upsampling stage in the decoder via skip connections. The last layer of the decoder uses a convolutional layer with a 1×1 kernel to restore the number of feature map channels to the number of bands in the original hyperspectral image and outputs a reconstructed background image through a Sigmoid activation function.

3. The hyperspectral detection method based on a low-rank sparse joint constraint autoencoder according to claim 1, characterized in that, In step 2: during the process of constructing the joint optimization model of low-rank constraint and sparse constraint, the low-rank constraint is achieved by minimizing the kernel norm of the reconstructed background image, where the kernel norm is the sum of the singular values ​​of the reconstructed background image matrix; the sparse constraint is achieved by minimizing the sum of the L2 norms of each column of the target matrix, where each column corresponds to the spectral vector of a pixel, and the sum of the L2 norms is used to force as many whole columns as possible in the target matrix to be zero.

4. The hyperspectral detection method based on a low-rank sparse joint constraint autoencoder according to claim 1, characterized in that, In step 3: when the reconstructed background image is iteratively updated using the alternating direction multiplier method, a singular value threshold function is used to perform singular value shrinkage processing on the matrix of the reconstructed background image. The singular value threshold function sets the singular values ​​in the matrix of the reconstructed background image that are less than the singular value threshold to zero, and subtracts the singular value threshold from the singular values ​​that are greater than the singular value threshold. The singular value threshold is equal to 1 divided by the penalty factor.

5. The hyperspectral detection method based on a low-rank sparse joint constraint autoencoder according to claim 1, characterized in that, In step 3: when iteratively updating the network parameters of the fully convolutional autoencoder using the alternating direction multiplier method, an adaptive weight map is introduced into the loss function. The adaptive weight map is calculated based on the residual image between the original hyperspectral image and the current reconstructed background image. The weight value of each pixel in the adaptive weight map is negatively correlated with the reconstruction error of the corresponding pixel. Pixels with larger reconstruction errors are assigned smaller weights, and all weight values ​​are normalized to the range of zero to one.

6. The hyperspectral detection method based on a low-rank sparse joint constraint autoencoder according to claim 1, characterized in that, In step 3: when the target matrix is ​​iteratively updated sequentially using the alternating direction multiplier method, a soft threshold function is used to set the columns in the matrix whose vector L2 norm is less than the soft threshold to zero, and the columns that are greater than or equal to the soft threshold are scaled. The scaled column vector is equal to the original column vector minus the soft threshold multiplied by the unit direction vector of the column vector. The soft threshold is equal to 1 divided by the penalty factor.

7. The hyperspectral detection method based on a low-rank sparse joint constraint autoencoder according to claim 1, characterized in that, In step 4: the target detection result is obtained by calculating the L2 norm reconstruction error of the spectral vector of each pixel in the final reconstructed background image and the original hyperspectral image. The larger the reconstruction error, the higher the probability that the pixel is identified as the target. The reconstruction errors of each pixel are arranged spatially according to the original image to form a two-dimensional detection result map. The elements in the two-dimensional detection result map are normalized, and the normalized value represents the probability that each pixel is the target.

8. A hyperspectral detection device based on a low-rank sparse joint constraint autoencoder, characterized in that, include: The image acquisition and mapping module is used to acquire the original hyperspectral image and input the random noise image into the fully convolutional autoencoder to map it into the reconstructed background image; The model building module is used to build a joint optimization model with low-rank constraints and sparse constraints. The low-rank constraints are used to constrain the kernel norm of the reconstructed background image, and the sparse constraints are used to constrain the column sparsity of the target matrix. The iterative update module is used to transform the joint optimization model into an augmented Lagrangian function, and to iteratively update the reconstructed background image, the network parameters of the fully convolutional autoencoder, the target matrix, and the Lagrangian multipliers sequentially using the alternating direction multiplier method. Specifically, when updating the network parameters of the fully convolutional autoencoder, the augmented Lagrangian function containing low-rank and sparse regularization terms is used as the network's loss function, and parameter optimization is performed through gradient backpropagation. The update of the reconstructed background image depends on the current network parameters of the fully convolutional autoencoder, and the update of the target matrix depends on the updated reconstructed background image. The result generation module is used to generate a final reconstructed background image using the trained fully convolutional autoencoder after the iteration, and to generate a target detection result based on the final reconstructed background image and the original hyperspectral image.

9. An electronic device, characterized in that, include: One or more processors; Memory, used to store one or more programs; When one or more programs are executed by the one or more processors, the one or more processors implement the hyperspectral detection method based on a low-rank sparse joint constraint autoencoder as described in any one of claims 1-7.

10. A computer-readable storage medium, characterized in that, It stores executable instructions that, when executed by a processor, enable the processor to implement the hyperspectral detection method based on a low-rank sparse joint constraint autoencoder as described in any one of claims 1-7.

Images