Self-supervised image denoising method and system

Abstract

Disclosed in the present invention are a self-supervised image denoising method and system. The method comprises: by means of an input interface, acquiring a noise image and transmitting same to a memory; configuring, in the memory, a search space based on a U-Net framework; a graphics processing unit reading configuration information, executing coarse-grained population initialization on the basis of a decimal modular encoding strategy, and writing population data into the memory as a contiguous memory block; the graphics processing unit executing distance-guided parent selection and modular crossover and mutation operations in parallel; decoding offspring individuals into network structures, then executing self-supervised denoising processing in parallel, and calculating PSNR values; and a central processing unit executing environment selection and controlling an iteration process, finally selecting an optimal network structure, and outputting a denoised image. By means of the optimization of search space design and the collaboration of heterogeneous computing architectures, the present invention simultaneously realizes high-quality image detail restoration and efficient denoising processing, without requiring paired data.

Description

Self-supervised image denoising method and system Technical Field

[0001] This invention belongs to the interdisciplinary field of computer vision and computer hardware optimization, and specifically relates to a self-supervised image denoising method and system. Background Technology

[0002] Image denoising is a crucial preprocessing task in computer vision systems, aiming to eliminate noise introduced into images during acquisition, transmission, or storage, thus providing a high-quality data foundation for subsequent advanced vision tasks. Supervised learning-based methods heavily rely on large-scale, precisely paired clean-noise image datasets; however, in real-world computer system applications, acquiring such data is costly and difficult, significantly limiting their practical deployment.

[0003] Self-supervised learning offers a feasible path to solving this problem. For example, Quan Y et al. designed a high-performance denoising structure based on U-Net by introducing Dropout and integrating it with the model (Quan Y, Chen M, Pang T, et al. Self2Self With Dropout: Learning Self-Supervised Denoising From Single Image[C]. 2020 IEEE / CVF Conference on Computer Vision and Pattern Recognition (CVPR), Seattle, WA, USA, 2020: 1887-1895); Jo Y et al. used a Dropout-free network combined with a stochastic time set method to accelerate processing (Jo Y, Chun SY, Choi J. Rethinking Deep Image Prior for Denoising[C]. 2021 IEEE / CVF International Conference on Computer Vision (ICCV), Montreal, QC, Canada, 2021: 5067-5076.). However, the performance of these methods is limited by their pre-defined fixed network structure. Designing high-performance networks manually is an iterative process of trial and error, which consumes a lot of resources and time on computing systems and is highly dependent on expert experience.

[0004] Neural Architecture Search (NAS) techniques have emerged to automate network design. However, existing NAS methods still have significant shortcomings in image denoising tasks. Some methods fail to break free from their dependence on supervised learning; for example, the scheme proposed by Ning Q et al. still relies on image pairs for its entire search and training process (Ning Q, Dong W, Li X, et al. Searching Efficient Model-Guided Deep Network for Image Denoising[J].IEEE Transactions on Image Processing,2023,32:668-681). More importantly, the search space design of existing methods has limitations at the computer system implementation level. For example, the NAS-DIP method by Chen YC et al. (Chen YC, Gao C, Robb E, et al. NAS-DIP: Learning Deep Image Prior with Neural Architecture Search[C]. Computer Vision–ECCV 2020:16th European Conference, Glasgow, United Kingdom,2020:442-459.) ignores the diversity of encoder structure in its search space and does not fully consider multi-scale feature fusion. As a result, when computing resources are limited, the searched network is difficult to make full use of the parallel computing power of GPU for efficient and fine feature extraction, thus limiting the restoration effect of image details and the final output quality.

[0005] Furthermore, existing self-supervised NAS methods suffer from serious deficiencies in utilizing the underlying computing architecture. Their search process is often treated as a purely algorithmic problem, failing to fully consider the collaborative characteristics of CPUs and GPUs. Specifically: (1) a large number of computational tasks are not effectively parallelized, failing to leverage the massive parallel advantages of GPUs; (2) there is a lack of optimization for memory data layout, resulting in low data transfer efficiency and high communication overhead between CPUs and GPUs; (3) evolutionary operations are not integrated with network structure characteristics, leading to low search efficiency and high resource consumption. These inefficiencies at the implementation level make the entire search process computationally intensive and time-consuming, severely hindering its application in real-world systems requiring rapid response or with limited resources.

[0006] In summary, existing technologies lack a method and system for efficiently and automatically searching for neural network structures specifically designed for self-supervised image denoising on computer systems. Such a method and system should not only improve the network's feature extraction and detail recovery capabilities by refining search strategies and spatial design without requiring paired data, but also significantly reduce search time by optimizing the parallel processing and data storage efficiency of the underlying computing architecture. This would allow for the simultaneous achievement of high-quality denoising output and a highly efficient search process within the computing system. Summary of the Invention

[0007] In view of the problems of insufficient image detail recovery capability, low efficiency of neural network structure search, and lack of complete technical solutions in the existing technology, the purpose of this invention is to provide a self-supervised image denoising method and system.

[0008] In a first aspect, the present invention provides a self-supervised image denoising method, the method comprising:

[0009] Step 1: Obtain noisy image data through the input interface and transfer the noisy image data to the memory;

[0010] Step 2: Configure a search space based on the U-Net framework in the memory, wherein the search space includes encoder scale type, downsampling type, upsampling type and convolution type; wherein the network structure based on the U-Net framework includes a first convolution module FC, an L-layer encoder module EB, an L-layer decoder module DB and a second convolution module LC connected in sequence.

[0011] Step 3: The graphics processing unit reads the configuration information of the search space from the memory and performs coarse-grained population initialization based on the decimal modular encoding strategy. An initial population with multiple individuals is generated in the search space, wherein each individual in the initial population is encoded as a continuously stored fixed-length decimal encoding sequence.

[0012] The different segments of the encoded sequence correspond to the parameter configurations of encoder and decoder modules at different levels in the U-Net architecture.

[0013] The graphics processing unit writes the entire population data as a contiguous block of memory into the population data region of the memory.

[0014] Step 4: The graphics processing unit reads all individual data of the current population from the population data area of ​​the memory into the video memory, and performs a distance-guided parent selection operation;

[0015] The distance-guided parent selection operation includes: computing the feature map of each individual network for the noisy image data in parallel in the video memory, measuring the distance between individuals by comparing the differences between the feature maps, and selecting the set of parent individuals based on this distance.

[0016] Step 5: The graphics processing unit performs modular crossover and mutation operations in parallel on the parent individual set in the video memory; wherein the crossover and mutation operations are based on the symmetric architecture constraints of U-Net, specifically: while modifying the encoder-level encoding, the corresponding decoder-level encoding is modified simultaneously to generate a new child individual encoding sequence.

[0017] Step 6: The graphics processing unit maps the encoding sequence of the offspring individuals into a specific neural network structure according to the decimal modular encoding strategy; then, the noisy image data is loaded from memory to video memory, and the forward propagation of these network structures is executed in parallel by multiple computing cores of the graphics processing unit to perform self-supervised noise reduction processing, and the noise reduction evaluation index PSNR value of each network output is calculated; after the calculation is completed, the set of PSNR values ​​is written into memory;

[0018] Step 7: The central processing unit reads all individuals, offspring individuals and their corresponding PSNR values ​​from the memory, executes the environment selection algorithm to select individuals to constitute the next generation population; the central processing unit updates the list of selected individuals of the next generation population to the population data area of ​​the memory; and controls the iteration process to repeatedly execute the parent selection, crossover and mutation, decoding and noise reduction processing steps until all evolutionary iterations are completed;

[0019] Step 8: The central processing unit selects the individual with the highest PSNR value from the final generation population data, instructs the graphics processing unit to decode it into the final network structure and perform noise reduction processing on the target noisy image; the graphics processing unit writes the processed noise-reduced image data back to the memory, and finally reads and outputs the noise-reduced image from the memory through the output interface.

[0020] Optionally, the processing flow of the network structure based on the U-Net framework includes:

[0021] The first convolutional module FC is used to extract features from the input noisy image data;

[0022] The features are extracted and compressed using multiple encoder modules (EB). Each EB module includes a downsampling module and a convolution module, and each EB module receives the output features from the EB module of the previous layer.

[0023] The compressed features are extracted and augmented using multiple decoder modules (DB). Each DB module includes a convolution module and an upsampling module. Each DB module receives the output features from the DB module of the previous layer and the output features from the EB module of the same layer.

[0024] The augmented image features are converted into a denoised image using the second convolution module LC.

[0025] Optionally, the coarse-grained population initialization includes:

[0026] Iterate through the predefined set of convolution types to obtain the convolution type;

[0027] Based on the obtained convolution type, the downsampling type is obtained by traversing the set of downsampling types;

[0028] Based on the obtained downsampling type, iterate through the set of upsampling types to obtain the upsampling types;

[0029] The convolution type and downsampling type are assigned to the convolution type parameter and downsampling type parameter of the L-layer encoder module, wherein the encoder scale type of the 1st layer encoder module is assigned a value of 1, and the encoder scale type of the 2nd to Lth layer encoder modules is assigned a value of 0.

[0030] The convolution type and upsampling type are assigned to the convolution type parameter and upsampling type parameter of the L-layer decoder module to generate coarse-grained individuals;

[0031] Repeat the above traversal and assignment steps until all convolution types, downsampling types, and upsampling types have been traversed, generating all coarse-grained individuals;

[0032] The DIP-STE self-supervised denoising method is used to denoise the network structure corresponding to each coarse-grained individual, calculate the PSNR value, and retain the top N individuals with the highest PSNR values ​​as the initial population for the search algorithm.

[0033] Optionally, the distance-guided parent selection includes:

[0034] Two individuals p from the population are selected using a binary bidding process. i and p j Parallel calculation of the distance (p) between the two individuals i ,p j The calculation formula is as follows: Wherein d(EB ik ,EB jk d(DB) represents the distance between the encoder modules at position k for two individuals. ik DB jk) represents the distance between the decoder modules of two individuals at position k; EB ik and EB jk Representing individual p respectively i and p j The k-th encoder module; DB ik and DB jk Representing individual p respectively i and p j The k-th decoder module;

[0035] The distance d(EB) between the encoder modules ik ,EB jk The formula for calculating d(EB) is: ik ,EB jk )=eq(st ik ,st jk )+eq(dt ik ,dt jk )+eq(ect jk ,ect jk ), where st ik and st jk They are EB ik With EB jk The scale type value, dt ik and dt jk They are EB ik With EB jk The downsampling type value, ect jk and ect jk They are EB ik With EB jk The convolution type value;

[0036] The distance d(DB) between the decoder modules ik DB jk The formula for calculating d(DB) is: ik DB jk ) = eq(ut ik ,ut jk )+eq(dct ik ,dct jk ), where ut ik and ut jk They are DB ik With DB jk upsampled type value, dct ik and dct jk They are DB ik With DB jk The convolution type value; the eq(a,b) function indicates whether the two parameter values ​​are equal. If a equals b, it returns 0; otherwise, it returns 1.

[0037] Determine distance(p) i ,p j Is it greater than the preset threshold μ? If it is, then select p. i and p j If the two individuals are selected as the parent individuals, then the binary bidding process is repeated to select two new individuals. If, after 10 selections, the distance between the two selected individuals is still not greater than the preset threshold μ, then the last selected individual is used as the parent individual.

[0038] Optionally, the modular crossover and mutation operations include:

[0039] Randomly generate a decimal r1 in the range [0,1]; if r1 is greater than or equal to the preset crossover rate r c Then, a crossover operation is performed, randomly selecting a module position pos1 from all modules of the parent individual, and then moving it to the parent individual p. i and p j In the process, the corresponding parameter values ​​of the modules at position pos1 are swapped to generate a new individual o. i and o j If r1 is less than the preset crossover rate r c If p, then no crossover operation will be performed. i p j Assign directly to o i o j ;

[0040] Randomly generate a decimal r2 in the range [0,1]; if r2 is greater than or equal to the mutation rate r m For individual o i Perform mutation operations from individual o i Randomly select a module position pos2 from all modules, and in individual o i In the middle, all parameters of the module at position pos2 are randomly regenerated to produce a new individual o′. i If r² is less than the rate of variation r m If the mutation operation is not performed, o i Assign directly to o′ i ;

[0041] For individual o j Perform the same mutation operation to generate a new individual o′ j .

[0042] Optionally, the environment selection includes:

[0043] From the current population P t and the set of offspring Q tThe five most fit individuals are selected and added to the next generation of population P. t+1 And remove these 5 elite individuals from the collection;

[0044] Using a binary bidding selection method, individuals are selected from the remaining union set and added to P. t+1 And remove this individual from the union;

[0045] Repeat the selection steps until P. t+1 The number of individuals reaches the preset scale m.

[0046] Optionally, the encoder scale type includes:

[0047] First scale type: k-th layer encoder EB k Only receive the output features of the previous layer encoder module

[0048] Second scale type: k-th layer encoder EB k Receive the output features of the first convolutional module FC and the output features of the previous layer encoder module

[0049] Optionally, the downsampling types include: max pooling layer, downsampling convolution, bilinear interpolation, nearest neighbor interpolation, and region interpolation.

[0050] In a second aspect, the present invention provides a self-supervised image denoising system, the system comprising:

[0051] Processor, memory, and input / output interfaces;

[0052] The memory stores computer-executable instructions that, when executed by the processor, configure the system to perform the following operations:

[0053] Receive noisy image data;

[0054] Configure a search space based on the U-Net framework, wherein the search space includes encoder scale type, downsampling type, upsampling type and convolution type;

[0055] Coarse-grained population initialization is performed based on a decimal modular encoding strategy, generating an initial population with multiple individuals in the search space, wherein the decimal modular encoding strategy allocates each individual in the initial population as a contiguous memory block and stores it in the memory.

[0056] The individual distance calculation in the distance-guided parent selection method is decomposed into multiple parallel computing tasks;

[0057] Modular crossover and mutation operations are performed on parent individuals in parallel to generate new offspring individuals;

[0058] According to the decimal modular coding strategy, the offspring individuals are decoded into the corresponding network structure, and the network structure is used to perform self-supervised denoising on the noisy image data to calculate the denoising evaluation index PSNR value.

[0059] Based on the PSNR value, environmental selection is performed to select individuals for the new population, and the parent selection, crossover and mutation, decoding and noise reduction steps are repeated until all evolutionary iterations are completed.

[0060] The individual with the highest PSNR value from the last generation of the population is selected and decoded into the corresponding network structure. This network structure is then used to perform noise reduction on the noisy image, and the denoised image is output.

[0061] Thirdly, the present invention provides a non-transitory computer-readable storage medium storing a computer program containing instructions that, when executed by one or more processors, cause the one or more processors to perform the self-supervised image denoising method as described above.

[0062] The beneficial effects of this invention are:

[0063] 1. The method of this invention constructs a search space containing a multi-scale encoder. This design enables the searched network structure to fuse feature information at different scales, effectively restoring image details and improving the quality of the final output image. Experiments demonstrate that on the fluorescence microscopy dataset FMD, the method of this invention significantly improves the removal of Poisson-Gaussian mixed noise, achieving a PSNR value of 30.58 dB on Widefield-BPAE cell images, which is superior to the comparative methods. This verifies the technical advantage of the search space design of this invention in restoring image details and is the core of improving the quality of the final output.

[0064] 2. The coarse-grained population initialization, distance-guided parent selection, and modular crossover and mutation operations proposed in this invention constitute an improved genetic algorithm for optimizing computer systems. Specifically, coarse-grained initialization directly optimizes the layout of population data in memory through a decimal modular encoding strategy, reducing memory access conflicts; distance-guided selection and modular operations are designed for large-scale parallel execution on graphics processing units. These improvements directly reduce the computational load on the GPU, achieving faster convergence speeds. GPU runtime data shows that on multiple public datasets (Set12, CBSD68), the denoising processing time of this method is significantly lower than that of comparative algorithms, demonstrating that this invention substantially improves the utilization efficiency of computer system computing resources.

[0065] 3. This invention deeply integrates the improved search algorithm with an optimized computing system, realizing a highly efficient and automated process from noisy image input to optimal denoising network structure output on a system including a processor and memory. This not only reduces reliance on manual design experience, but more importantly, it provides a complete technical solution that is repeatable and scalable on computing systems, combining high-quality output and high search efficiency.

[0066] In summary, this invention provides a complete technical solution that can be implemented on a computing system and simultaneously overcomes the challenges of image quality and search efficiency through hardware-software co-optimization. Its technical effectiveness is reflected in the substantial optimization achieved in both output image quality and computational efficiency during the search process through hardware-aware search space and algorithm design. This has been validated by experimental data on medical image datasets and general datasets, demonstrating significant industrial application value. Attached Figure Description

[0067] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the accompanying drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are merely embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on the provided drawings without creative effort.

[0068] Figure 1 is an overall flowchart of the self-supervised image denoising method provided by the present invention.

[0069] Figure 2 is a schematic diagram of the hardware execution of the network structure based on the U-Net framework provided by the present invention in a computing system.

[0070] Figure 3 is a schematic diagram of the specific structure of two multi-scale encoders in the computing system provided in the embodiments of the present invention.

[0071] Figure 4 is a schematic diagram of the data structure of an individual in memory defined by the decimal modular encoding strategy provided by the present invention.

[0072] Figure 5 is a schematic diagram comparing the initialization phase of random individuals and individuals generated using the coarse-grained population initialization method in the embodiments provided by the present invention.

[0073] Figure 6 is a schematic diagram of the modular crossover and mutation operations performed in parallel by the GPU provided by the present invention.

[0074] Figure 7 is a visual comparison of the noise reduction effects of the network structure searched by the present invention with other noise reduction methods. Detailed Implementation

[0075] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0076] Both Embodiment 1 and Embodiment 2 were implemented on a computer system configured with two NVIDIA GeForce RTX 3090Ti GPUs (totaling approximately 48GB of video memory), CUDA 12.2, and PyTorch 2.9.0. The central processing unit (CPU), graphics processing unit (GPU), memory (video memory and system memory), input interfaces, and output interfaces included in this system collectively provide the necessary hardware computing resources and data throughput capabilities for the technical solution of this invention.

[0077] Example 1

[0078] This embodiment provides a self-supervised image denoising method, as shown in Figure 1. The method includes:

[0079] Step 1: Obtain the noisy image data through the input interface and transfer the noisy image data to the memory.

[0080] Step 2: Configure the search space based on the U-Net framework in the memory, where the search space includes encoder scale type, downsampling type, upsampling type and convolution type; wherein, the network structure based on the U-Net framework includes a first convolutional module FC, an L-layer encoder module EB, an L-layer decoder module DB and a second convolutional module LC connected in sequence.

[0081] Step 3: The GPU reads the configuration information of the search space from memory and performs coarse-grained population initialization based on the decimal modular encoding strategy. An initial population with multiple individuals is generated in the search space. Each individual in the initial population is encoded as a contiguous fixed-length decimal encoding sequence. Different segments of the encoding sequence correspond to the parameter configurations of encoder and decoder modules at different levels in the U-Net architecture. The GPU writes the entire population data as a contiguous memory block to the population data region of memory.

[0082] As shown in Figures 4 and 5, the core of this strategy lies in the GPU encoding each individual in the population as a contiguous, fixed-length decimal encoding sequence. This innovative data structure allows individual data to form contiguous memory blocks in memory, significantly reducing memory access conflicts, optimizing data layout, and thus improving the computer's memory access efficiency.

[0083] Step 4: The GPU reads all individual data of the current population from the population data region of memory into video memory and performs a distance-guided parent selection operation. The distance-guided parent selection operation includes: computing the feature map of each individual network against the noisy image data in parallel in video memory, measuring the distance between individuals by comparing the differences between the feature maps, and selecting the set of parent individuals based on this distance.

[0084] The key innovation of this method lies in the fact that it does not use abstract mathematical distance, but rather measures distance based on the difference in features extracted by two individual networks when processing the same noisy image. This approach, which deeply integrates the algorithm with the image denoising task, ensures that the selected parent individuals have greater diversity and potential in the denoising task, solving the problem of blind search direction in traditional genetic algorithms for specific applications.

[0085] Step 5: In the GPU memory, modular crossover and mutation operations are performed in parallel on the parent set of individuals. The crossover and mutation operations are based on the symmetric architecture constraints of U-Net, specifically: while modifying the encoder-level encoding, the corresponding decoder-level encoding is modified simultaneously to generate new child individual encoding sequences.

[0086] Crossover and mutation operations strictly adhere to the symmetric architecture constraints of U-Net, exchanging or resetting parameters only between corresponding layers in the encoder and decoder. This modular design, tailored to a specific network architecture, ensures the effectiveness of genetic operations and avoids generating invalid network structures. This is crucial for the successful application of the algorithm to this specific technical problem and also facilitates parallel implementation on GPUs.

[0087] Step 6: The GPU maps the encoding sequence of the offspring individuals into a specific neural network structure according to the decimal modular encoding strategy; then, the noisy image data is loaded from memory to video memory, and the forward propagation of these network structures is performed in parallel by multiple computing cores of the GPU to perform self-supervised denoising processing, and the PSNR value of the denoising evaluation index of each network output is calculated; after the calculation is completed, the set of PSNR values ​​is written to memory.

[0088] Step 7: The CPU reads all individuals, offspring individuals and their corresponding PSNR values ​​from the memory, executes the environment selection algorithm to select individuals to form the next generation of the population; the CPU updates the list of individuals selected for the next generation of the population to the population data area in the memory; and controls the iteration process, repeating steps 4 to 6 until all evolutionary iterations are completed.

[0089] Step 8: The CPU selects the individual with the highest PSNR value from the final generation population data, instructs the GPU to decode it into the final network structure and denoise the target noisy image; the GPU writes the denoised image data back to memory, and finally reads and outputs the denoised image from memory through the output interface.

[0090] This method significantly reduces image denoising processing time by improving the computer's capabilities, including optimizing the GPU's parallel computing architecture and memory data layout to reduce memory access conflicts and improve neural network search efficiency. Simultaneously, it integrates neural network architecture search algorithms into the specific task of self-supervised image denoising, addressing the specific technical problems of insufficient image detail recovery and low search efficiency.

[0091] Example 2

[0092] This embodiment elaborates on a self-supervised image denoising method of Embodiment 1 in more detail, providing implementation details of the method. This embodiment assumes that the noisy image data has been received in advance via the input interface and the noisy image data has been transferred to the memory.

[0093] The method includes the following steps:

[0094] Step 1: Configure the search space based on the U-Net framework in the memory, where the search space includes encoder scale type, downsampling type, upsampling type and convolution type; wherein, the network structure based on the U-Net framework includes a first convolutional module FC, an L-layer encoder module EB, an L-layer decoder module DB and a second convolutional module LC connected in sequence.

[0095] As shown in Figure 2, the network structure processing flow based on the U-Net framework is as follows:

[0096] Step 11: The GPU executes the first convolutional module (FC) to extract features from the input image; the FC module is a 3*3 convolution operation.

[0097] Step 12: The GPU executes the encoder block (EB) to extract and compress the features from step 11. The EB consists of downsampling and convolutional blocks. Step 12 is repeated L times, with each EB block receiving the output features from the previous EB block.

[0098] Step 13: The GPU executes the decoder block (DB) to extract and augment the features output in step 12. The DB consists of a convolutional block (ConvBlock) and an upsampling block (UpSampling). Step 13 is repeated L times, with each DB block receiving the output features from the previous DB block and the output features from the same layer's EB block.

[0099] Step 14: The GPU executes the last convolutional module (LC) to convert the image features output in step 13 into a denoised image; the LC module consists of two convolutional modules and one sigmoid activation function.

[0100] The specific dimensions of the search space include:

[0101] Encoder scale types include: The first scale type is the k-th layer encoder EB. k Only receive the output features of the previous layer encoder module The second scale type is the k-th layer encoder EB. k Receive the output features of the first convolutional module FC and the output features of the previous layer encoder module

[0102] Downsampling types include: Max Pooling, ConvDown, Bilinear Down, Nearest Down, and AreaDown.

[0103] Upsampling types include: TransposeConv, SubPixel, BilinearUp, NearestUp, and AreaUp.

[0104] Convolution types include: 3×3 convolution, 5×5 convolution, and 7×7 convolution.

[0105] Step 2: The GPU reads the search space configuration information from Step 1 and performs coarse-grained population initialization based on the decimal modular encoding strategy, generating an initial population with multiple individuals in the search space (individual structure shown in Figure 4). The decimal modular encoding strategy encodes each individual in the initial population into a continuously stored fixed-length decimal encoding sequence. Different segments correspond to the parameter configurations of different levels of encoder and decoder modules in U-Net. The value range of each parameter and its corresponding candidate values ​​are shown in Table 1.

[0106] Table 1: Range of values ​​for individual structural parameters

[0107] The GPU writes the entire population data as a contiguous block of memory to the population data region of the memory.

[0108] Each individual in the population consists of an encoder module and a decoder module. Each encoder module is composed of parameters of scale type (scale_type), downsampling type (down_type), and convolution type (conv_type). Each decoder module is composed of parameters of upsampling type (up_type) and convolution type (conv_type).

[0109] The specific sub-steps executed by the GPU are as follows:

[0110] Step 21: Iterate through the convolution type set (conv_type_list) to obtain the convolution type (conv_type);

[0111] Step 22: Based on the conv_type obtained in Step 21, traverse the downsampled type set (down_type_list) to obtain the downsampled type (down_type);

[0112] Step 23: Based on the down_type obtained in Step 22, iterate through the upsampled type set (up_type_list) to obtain the upsampled type (up_type);

[0113] Step 24: Based on Step 23, assign conv_type and down_type to the convolution type parameter and downsampling type parameter of the L-layer encoder module, assign the encoder scale type of the 1st layer encoder module to 1, and assign the encoder scale type of the 2nd to Lth layer encoder modules to 0. Assign conv_type and up_type to the convolution type parameter and upsampling type parameter of the L-layer decoder module to complete the generation of coarse-grained individuals;

[0114] Step 25: Repeat steps 21, 22, and 23 to traverse all conv_type, down_type, and up_type, and complete the generation of all coarse-grained individuals;

[0115] Step 26: Run the DIP-STE method for self-supervised denoising. DIP-STE uses the Stochastic Time Set (STE) method to define the model's loss function, thereby achieving self-supervised single-image denoising. Calculate the PSNR value for all coarse-grained individuals generated in Step 25, and retain the 50 individuals with the highest PSNR values ​​as the initial population for the search algorithm.

[0116] Using the coarse-grained population initialization method described above, the GPU efficiently traverses key combinations in the search space, generating a high-quality initial population within limited GPU computing resources and time. This method is particularly advantageous for rapidly initiating searches in scenarios such as medical imaging, where data fidelity is extremely critical.

[0117] Step 3: The GPU reads all individual data of the current population from the population data region of the memory into the video memory, and performs a distance-guided parent selection operation. The distance-guided parent selection operation includes: computing the feature map of each individual network against the noisy image data in parallel in the video memory, measuring the distance between individuals by comparing the differences between the feature maps, and selecting the set of parent individuals based on this distance.

[0118] The specific sub-steps are as follows:

[0119] First, a binary bidding process is used to select two individuals p. i p j Then, the distance (p) between the two individuals is calculated in parallel. i ,p j ), determine distance(p) i ,p j Does it meet the threshold μ? If it is greater than μ, then p i p j If the differences between the individuals are significant, one can be used as the parent individual. Otherwise, a new binary selection process is used to choose two more individuals. If the individual distance still does not meet μ after 10 iterations, the last selected individual is used as the parent individual, and distance(p) is used as the parent individual. i ,p j The specific calculation formula is as follows:

[0120] Wherein d(EB ik ,EB jk d(DB) represents the distance between the encoder modules at position k for two individuals. ik DB jk) represents the distance between the decoder modules of two individuals at position k; EB ik and EB jk Representing individual p respectively i and p j The k-th encoder module; DB ik and DB jk Representing individual p respectively i and p j The k-th decoder module.

[0121] d(EB ik ,EB jk The specific calculation formula for d(EB) is as follows: ik ,EB jk )=eq(st ik ,st jk )+eq(dt ik ,dt jk )+eq(ect jk ,ect jk )

[0122] Among them, st ik and st jk They are EB ik With EB jk The scale type value, dt ik and dt jk They are EB ik With EB jk The downsampling type value, ect jk and ect jk They are EB ik With EB jk The convolution type value.

[0123] d(DB ik DB jk The specific calculation formula for d(DB) is as follows: ik DB jk ) = eq(ut ik ,ut jk )+eq(dct ik ,dct jk )

[0124] Among them, ut ik and ut jk They are DB ik With DB jk upsampled type value, dct ik and dct jk They are DB ik With DB jkThe convolution type value. eq(a,b) indicates whether the two parameter values ​​are equal, and the calculation formula is as follows:

[0125] Where a and b represent the two parameter values ​​being compared.

[0126] Step 4: In the GPU memory, modular crossover and mutation operations are performed in parallel on the parent individual set from Step 3. The crossover and mutation operations are based on the symmetric architecture constraints of U-Net, specifically: while modifying the encoder-level encoding, the corresponding decoder-level encoding is modified simultaneously to generate new child individual encoding sequences.

[0127] As shown in Figure 6, the modular crossover and mutation processing flow is as follows:

[0128] Step 41: Randomly generate a decimal r1 within the range [0,1];

[0129] Step 42: If r1 is greater than or equal to the crossover rate r c If so, then the parent generation crossover operation is performed;

[0130] Step 43: Under the condition of satisfying step 42, randomly select a module position pos1 from all modules of the individual;

[0131] Step 44: In the parent individual p i p j In the process, select the modules at position pos1 respectively, and swap all the corresponding parameter values ​​in these two modules to generate two new individuals o. i o j ;

[0132] Step 45: If r1 is less than the crossover rate r c If p, then no crossover operation is performed. i p j Assign directly to o i o j ;

[0133] Step 46: Randomly generate a decimal r2 within the range [0,1];

[0134] Step 47: If r² is greater than or equal to the mutation rate r m For individual o i Perform mutation operations;

[0135] Step 48: Based on step 47, randomly select a module position pos2 from all modules of the individual;

[0136] Step 49: In individual o iIn the middle, select the module at position pos2, and regenerate all parameters of the module randomly to generate a new individual o′. i ;

[0137] Step 410: If r² is less than the mutation rate r m If the mutation operation is not performed, o i Assign directly to o′ i ;

[0138] Step 411: Repeat steps 46, 47, 48, 49, and 410 to complete. j The mutation operation generates a new offspring individual o′ j Complete the modular crossover and mutation operations of the parent individuals.

[0139] Step 5: The GPU maps the encoding sequences of the offspring individuals in Step 4 to specific neural network structures according to the decimal modular encoding strategy; then, the noisy image data is loaded from memory to video memory, and the forward propagation of these network structures is performed in parallel by multiple computing cores of the GPU to perform self-supervised denoising processing, and the PSNR value of the denoising evaluation index of each network output is calculated; after the calculation is completed, the set of PSNR values ​​is written to memory.

[0140] The GPU performs self-supervised denoising on noisy input images (such as cell, zebrafish, or mouse brain tissue images from the fluorescence microscopy dataset FMD) based on the decoded network structure. This process fully utilizes the massively parallel computing power of the GPU to improve the PSNR value of the image through iterative optimization.

[0141] Step 6: The CPU reads all individuals, offspring individuals, and PSNR values ​​calculated in Step 5 from the memory, executes the environment selection algorithm to select individuals to form the next generation population; the CPU updates the list of selected individuals of the new generation population to the population data area in the memory; and controls the iteration process, repeating Steps 3 to 5 until all evolutionary iterations are completed.

[0142] The process for environment selection is as follows:

[0143] Step 61: From the newly generated child set Q t and population set P t Union of P t ∪Q t Five elite individuals with high fitness are selected and placed into the next generation population. t+1 And from P t ∪Q t Remove elite;

[0144] Step 62: Using a binary bidding selection method, select P after processing in step 61. t ∪Q t Select individual p from the set;

[0145] Step 63: Place the individual p selected in step 62 into the next generation population P. t+1 In the middle, from P t ∪Q t Remove individual p from the middle

[0146] Step 64: Repeat step 63 until P. t+1 When the number of individuals reaches m, the environment selection operation is completed.

[0147] Step 7: The CPU obtains the individuals of the last generation population from Step 6, selects the individual with the highest PNSR value to decode into the corresponding network structure, which is the best network structure found by the search, and instructs the GPU to decode it into the final network structure and perform noise reduction processing on the target noisy image; the GPU writes the processed noise-reduced image data back to the memory, and finally reads and outputs the noise-reduced image from the memory through the output interface.

[0148] To further illustrate the beneficial effects of the present invention, a series of experiments were conducted, and the experimental process and results are described below:

[0149] Experimental parameter settings: population size m for the genetic algorithm is 50, number of evolutionary iterations T is 50, threshold μ for distance-guided parent selection, and crossover rate r. c The value is 0.7, and the mutation rate r is 0.7. m The learning rate is 0.3, and the number of elite individuals, e, is 5. The network structure has 5 layers for the encoder and decoder, ef for the encoder, df for the decoder, 96 channels, RAdam for the optimizer, and a learning rate l of 0.1.

[0150] The optimal network structure searched by this invention at a noise level of 50 was subjected to self-supervised denoising, and its performance was compared with BM3D, DIP, and S2S methods. The test datasets were the color image datasets CSet9 and CBSD68, and the grayscale image datasets Set12 and BSD68, with noise levels of 15, 25, and 50, respectively. PSNR was used to represent the denoising performance of the algorithm; a higher PSNR is better. Table 2 shows the experimental comparison results. * in the table indicates the peak PSNR of the method during denoising, and SDNAS is used to denote the method of this invention.

[0151] Table 2: Comparison of SDNAS and single-image noise reduction algorithms under PSNR.

[0152] Table 2 shows that the PSNR value of the SDNAS method of this invention is higher than that of the traditional BM3D method on the CSet9 dataset. Simultaneously, the PSNR value of SDNAS* on the CSBSD68 and BSD68 datasets surpasses all compared single-image denoising methods (see Figure 7 for a comparison of denoised images). With noise levels of 15 and 25 on the CSet9 dataset and noise level 15 on the Set12 dataset, SDNAS* outperforms all compared methods. This indicates that the method of this invention is highly competitive in self-supervised single-image denoising. It is worth noting that the SDNAS method of this invention is consistent with the self-supervised denoising method of DIP-STE, but the corresponding neural network structures are different. Except for the conditions of σ=15 and σ=25 on the CBSD68 dataset, the PSNR value of SDNAS surpasses that of the DIP-STE method on other datasets. Furthermore, the PSNR value of SDNAS* surpasses that of DIP-STE* on all datasets. This demonstrates that this invention can search for a better neural network structure than existing methods in the self-supervised single-image denoising task.

[0153] This invention is compared with the denoising performance of the single-image denoising NAS method NAS-DIP. Experiments were conducted on four datasets: CSet9, CBSD68, Set12, and BSD68, using PSNR, SSIM, and LPIPS as metrics for denoising performance analysis. The SSIM metric considers image brightness, contrast, and structural information; a higher SSIM indicates better denoising performance. The LPIPS metric more effectively reflects human visual perception of the image; a lower LPIPS indicates better denoising performance. Table 3 shows the experimental results, where higher PSNR and SSIM are generally better, and lower LPIPS are generally better.

[0154] Table 3: Experimental Results of SDNAS and NAS-DIP

[0155] As shown in Table 3, the PSNR, SSIM, and LPIPS values ​​of the SDNAS method of the present invention are all better than those of the NAS-DIP method, indicating that the image after noise reduction by the method of the present invention retains more structural and texture information, is more similar to a clean image, and is more in line with human visual perception.

[0156] To verify and analyze the effectiveness of the structure search and coarse-grained initialization evolutionary algorithm of the multi-scale encoder in the SDNAS method of this invention, the following ablation experiment was designed.

[0157] This invention conducted five sets of experiments on the Set12 dataset. The PSNR metric was used to represent the denoising effect at σ=15, σ=25, and σ=50 in each set of experiments. The first set of experiments used DIP-STE for self-supervised denoising, and the remaining four sets of experiments used four different SDNAS methods to verify the denoising effect. The four SDNAS methods are: SDNAS with parent selection without coarse-grained population initialization and distance guidance (SDNAS w / o CGI_DGS), SDNAS with coarse-grained initialization without CGI, SDNAS with encoder multi-scale search space without scale (SDNAS w / o scale), and the complete method SDNAS. Table 4 shows the experimental results.

[0158] Table 4: Ablation Experiment Results

[0159] Experimental results show that all four SDNAS algorithms outperform DIP-STE on the Set12 dataset, indicating that the genetic algorithm can find better-performing network structures in a multi-scale search space. Regarding the improvement over DIP-STE, at noise levels of 25 and 50, the PSNR of SDNAS w / o CGI is improved by 0.05 and 0.1 respectively compared to SDNAS w / o CGI_DGS, demonstrating that the distance-guided parent selection method improves population diversity and enhances the search capability of the genetic algorithm.

[0160] Under noise levels of 15, 25, and 50, the PSNR values ​​of SDNAS were improved by 0.12, 0.02, and 0.08 compared to SDNAS without CGI, respectively, indicating that the higher-performing coarse-grained individuals generated by the coarse-grained population initialization method help to find better-performing individuals. The PSNR values ​​of SDNAS were improved by 0.12, 0.07, and 0.18 compared to SDNAS without CGI_DGS, respectively, indicating that combining the coarse-grained population initialization method with the distance-guided parent selection method significantly improves the search capability of the genetic algorithm.

[0161] Furthermore, comparing SDNAS with SDNAS without scale, the PSNR values ​​were improved by 0.12, 0.08, and 0.16 respectively under the three noise levels. This indicates that multi-scale type search of the encoder in the search space can obtain a network structure with better noise reduction effect, which plays an important role in improving the performance of SNDAS.

[0162] To further illustrate the beneficial effects of the present invention and its practical value in the field of medical image diagnosis and computing systems, a series of experiments were conducted in this embodiment. All experiments were performed on the aforementioned computer system equipped with two NVIDIA GeForce RTX 3090Ti GPUs.

[0163] The method of this invention demonstrates significant value in the field of medical image processing. This invention was tested using the Fluorescence Microscopy Dataset (FMD), which contains realistic Poisson-Gaussian mixture noise commonly found in cell, zebrafish, and mouse brain tissue images acquired by confocal, two-photon, and wide-field microscopy. As shown in the table below, the method of this invention (SDNAS) achieved leading or competitive results on key metrics, especially in processing noisy Widefield-BPAE images, where the PSNR reached 30.58 dB, significantly outperforming the comparison algorithms. This demonstrates its technical advantages and practical application potential in restoring the fine structure of biological samples.

[0164] Table 5: Experimental Results of Medical Image Processing (Indicator: PSNR Value)

[0165] Another significant technical advantage of this invention lies in its high computational efficiency on computer systems. As shown in the table below, under different datasets and noise levels, the denoising processing time (GPU Days) of the method of this invention (SDNAS) is generally lower than or comparable to the fastest comparison method, especially at higher noise levels (σ = 50), where the efficiency advantage is even more pronounced. This demonstrates that the improved genetic algorithm and its implementation method of this invention can utilize GPU computing resources more efficiently, completing the search and denoising tasks within an acceptable time, and possesses practical deployment value.

[0166] Table 5: Experimental results of GPU runtime on the Set12 dataset (unit: seconds)

[0167] Table 5: Experimental results of GPU running days on the CBSD68 dataset (unit: seconds)

[0168] The above experimental results all demonstrate that the technical solution provided by the present invention can be effectively executed on the computer system, and achieves the expected results in terms of image noise reduction performance and computational efficiency.

[0169] Example 3

[0170] This embodiment provides a self-supervised image denoising system, the system comprising:

[0171] Processor, memory, and input / output interfaces; preferably in this embodiment, the processor includes a central processing unit (CPU) and a graphics processing unit (GPU), wherein the GPU is configured to perform parallel computing tasks, and the CPU is configured to coordinate task scheduling;

[0172] The memory stores computer-executable instructions, which, when executed by the CPU and GPU, configure the system to perform the following operations:

[0173] Receive noisy image data;

[0174] Configure a search space based on the U-Net framework, wherein the search space includes encoder scale type, downsampling type, upsampling type and convolution type;

[0175] Coarse-grained population initialization is performed based on a decimal modular encoding strategy, generating an initial population with multiple individuals in the search space, wherein the decimal modular encoding strategy allocates each individual in the initial population as a contiguous memory block and stores it in the memory.

[0176] The individual distance calculation in the distance-guided parent selection method is decomposed into multiple parallel computing tasks;

[0177] Modular crossover and mutation operations are performed on parent individuals in parallel to generate new offspring individuals;

[0178] According to the decimal modular coding strategy, the offspring individuals are decoded into the corresponding network structure, and the network structure is used to perform self-supervised denoising on the noisy image data to calculate the denoising evaluation index PSNR value.

[0179] Based on the PSNR value, environmental selection is performed to select individuals for the new population, and the parent selection, crossover and mutation, decoding and noise reduction steps are repeated until all evolutionary iterations are completed.

[0180] The individual with the highest PSNR value from the last generation of the population is selected and decoded into the corresponding network structure. This network structure is then used to perform noise reduction on the noisy image, and the denoised image is output.

[0181] Example 4

[0182] This embodiment provides a non-transitory computer-readable storage medium storing a computer program containing instructions that, when executed by one or more processors, cause the one or more processors to perform the self-supervised image denoising method described above.

[0183] In summary, this invention improves the detail recovery capability of the network structure and enhances image quality by constructing a search space containing a multi-scale encoder. Secondly, it optimizes the parallel computing and storage access of the heterogeneous computing architecture through an improved search algorithm, thereby improving search efficiency. Thus, it achieves high-quality and high-efficiency collaborative output without the need for paired data.

[0184] Some steps in the embodiments of the present invention can be implemented using software, and the corresponding software program can be stored in a readable storage medium, such as an optical disc or a hard disk.

[0185] The above description is only a preferred embodiment of the present invention and is 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 self-supervised image denoising method, characterized in that, The method includes: Step 1: Obtain noisy image data through the input interface and transfer the noisy image data to the memory; Step 2: Configure a search space based on the U-Net framework in the memory, wherein the search space includes encoder scale type, downsampling type, upsampling type and convolution type; wherein the network structure based on the U-Net framework includes a first convolution module FC, an L-layer encoder module EB, an L-layer decoder module DB and a second convolution module LC connected in sequence. Step 3: The graphics processing unit reads the configuration information of the search space from the memory and performs coarse-grained population initialization based on the decimal modular encoding strategy. An initial population with multiple individuals is generated in the search space, wherein each individual in the initial population is encoded as a continuously stored fixed-length decimal encoding sequence. The different segments of the encoded sequence correspond to the parameter configurations of encoder and decoder modules at different levels in the U-Net architecture. The graphics processing unit writes the entire population data as a contiguous block of memory into the population data region of the memory. Step 4: The graphics processing unit reads all individual data of the current population from the population data area of ​​the memory into the video memory, and performs a distance-guided parent selection operation; The distance-guided parent selection operation includes: computing the feature map of each individual network for the noisy image data in parallel in the video memory, measuring the distance between individuals by comparing the differences between the feature maps, and selecting the set of parent individuals based on this distance. Step 5: The graphics processing unit performs modular crossover and mutation operations in parallel on the parent individual set in the video memory; wherein the crossover and mutation operations are based on the symmetric architecture constraints of U-Net, specifically: while modifying the encoder-level encoding, the corresponding decoder-level encoding is modified simultaneously to generate a new child individual encoding sequence. Step 6: The graphics processing unit maps the encoding sequence of the offspring individuals into a specific neural network structure according to the decimal modular encoding strategy; then, the noisy image data is loaded from memory to video memory, and the forward propagation of these network structures is executed in parallel by multiple computing cores of the graphics processing unit to perform self-supervised noise reduction processing, and the noise reduction evaluation index PSNR value of each network output is calculated; after the calculation is completed, the set of PSNR values ​​is written into memory; Step 7: The central processing unit reads all individuals, offspring individuals and their corresponding PSNR values ​​from the memory, executes the environment selection algorithm to select individuals to constitute the next generation population; the central processing unit updates the list of selected individuals of the next generation population to the population data area of ​​the memory; and controls the iteration process to repeatedly execute the parent selection, crossover and mutation, decoding and noise reduction processing steps until all evolutionary iterations are completed; Step 8: The central processing unit selects the individual with the highest PSNR value from the final generation population data, instructs the graphics processing unit to decode it into the final network structure and perform noise reduction processing on the target noisy image; the graphics processing unit writes the processed noise-reduced image data back to the memory, and finally reads and outputs the noise-reduced image from the memory through the output interface.

2. The method according to claim 1, characterized in that, The processing flow of the network structure based on the U-Net framework includes: The first convolutional module FC is used to extract features from the input noisy image data; The features are extracted and compressed using multiple encoder modules (EB). Each EB module includes a downsampling module and a convolution module, and each EB module receives the output features from the EB module of the previous layer. The compressed features are extracted and augmented using multiple decoder modules (DB). Each DB module includes a convolution module and an upsampling module. Each DB module receives the output features from the DB module of the previous layer and the output features from the EB module of the same layer. The augmented image features are converted into a denoised image using the second convolution module LC.

3. The method according to claim 2, characterized in that, The coarse-grained population initialization includes: Iterate through the predefined set of convolution types to obtain the convolution type; Based on the obtained convolution type, the downsampling type is obtained by traversing the set of downsampling types; Based on the obtained downsampling type, iterate through the set of upsampling types to obtain the upsampling types; The convolution type and downsampling type are assigned to the convolution type parameter and downsampling type parameter of the L-layer encoder module, wherein the encoder scale type of the 1st layer encoder module is assigned a value of 1, and the encoder scale type of the 2nd to Lth layer encoder modules is assigned a value of 0. The convolution type and upsampling type are assigned to the convolution type parameter and upsampling type parameter of the L-layer decoder module to generate coarse-grained individuals; Repeat the above traversal and assignment steps until all convolution types, downsampling types, and upsampling types have been traversed, generating all coarse-grained individuals; The DIP-STE self-supervised denoising method is used to denoise the network structure corresponding to each coarse-grained individual, calculate the PSNR value, and retain the top N individuals with the highest PSNR values ​​as the initial population for the search algorithm.

4. The method according to claim 3, characterized in that, The distance-guided parent selection includes: Two individuals p from the population are selected using a binary bidding process. i and p j Parallel calculation of the distance (p) between the two individuals i ,p j The calculation formula is as follows: where d(EB ik ,EB jk ) denotes the distance between the encoder modules of two individuals at position k, d(DB ik , DB jk ) denotes the distance between the decoder modules of two individuals at position k; EB ik and EB jk denote the kth encoder module in individuals p i and p j , respectively; DB ik and DB jk denote the kth decoder module in individuals p i and p j , respectively. The distance d(EB ik ,EB jk ) between the encoder modules is calculated as follows: d(EB ik ,EB jk ) = eq(st ik ,st jk ) + eq(dt ik ,dt jk ) + eq(ect jk ,ect jk ), where st ik and st jk are the scale type values of EB ik and EB jk , dt ik and dt jk are the downsample type values of EB ik and EB jk , and ect jk and ect jk are the convolution type values of EB ik and EB jk . The distance d(DB) between the decoder modules ik DB jk The formula for calculating d(DB) is: ik DB jk ) = eq(ut ik ,ut jk )+eq(dct ik ,dct jk ), where ut ik and ut jk They are DB ik With DB jk upsampled type value, dct ik and dct jk They are DB ik With DB jk The convolution type value; the eq(a,b) function indicates whether the two parameter values ​​are equal. If a equals b, it returns 0; otherwise, it returns 1. Determine distance(p) i ,p j Is it greater than the preset threshold μ? If it is, then select p. i and p j If the two individuals are selected as the parent individuals, then the binary bidding process is repeated to select two new individuals. If, after 10 selections, the distance between the two selected individuals is still not greater than the preset threshold μ, then the last selected individual is used as the parent individual.

5. The method according to claim 4, characterized in that, The modular crossover and mutation operations include: Randomly generate a decimal r1 in the range [0,1]; if r1 is greater than or equal to the preset crossover rate r c Then, a crossover operation is performed, randomly selecting a module position pos1 from all modules of the parent individual, and then moving it to the parent individual p. i and p j In the process, the corresponding parameter values ​​of the modules at position pos1 are swapped to generate a new individual o. i and o j If r1 is less than the preset crossover rate r c If p, then no crossover operation is performed. i p j Assign directly to o i o j ; Randomly generate a decimal r2 in the range [0,1]; if r2 is greater than or equal to the mutation rate r m For individual o i Perform mutation operations from individual o i Randomly select a module position pos2 from all modules, and in individual o i In the middle, all parameters of the module at position pos2 are randomly regenerated to produce a new individual o′. i If r² is less than the rate of variation r m If the mutation operation is not performed, o i Assign directly to o′ i ; For individual o j Perform the same mutation operation to generate a new individual o′ j .

6. The method according to claim 5, characterized in that, The environment selection includes: From the current population P t and the set of offspring Q t The five most fit individuals are selected and added to the next generation of population P. t+1 And remove these 5 elite individuals from the collection; Using a binary bidding selection method, individuals are selected from the remaining union set and added to P. t+1 And remove this individual from the union; Repeat the selection steps until P. t+1 The number of individuals reaches the preset scale m.

7. The method according to claim 1, characterized in that, The encoder scale types include: First scale type: k-th layer encoder EB k Only receive the output features of the previous layer encoder module Second scale type: k-th layer encoder EB k Receive the output features of the first convolutional module FC and the output features of the previous layer encoder module 8. The method according to claim 1, characterized in that, The downsampling types include: max pooling layer, downsampling convolution, bilinear interpolation, nearest neighbor interpolation, and region interpolation.

9. A self-supervised image denoising system, characterized in that, The system includes: Processor, memory, and input / output interfaces; The memory stores computer-executable instructions that, when executed by the processor, configure the system to perform the following operations: Receive noisy image data; Configure a search space based on the U-Net framework, wherein the search space includes encoder scale type, downsampling type, upsampling type and convolution type; Coarse-grained population initialization is performed based on a decimal modular encoding strategy, generating an initial population with multiple individuals in the search space, wherein the decimal modular encoding strategy allocates each individual in the initial population as a contiguous memory block and stores it in the memory. The individual distance calculation in the distance-guided parent selection method is decomposed into multiple parallel computing tasks; Modular crossover and mutation operations are performed on parent individuals in parallel to generate new offspring individuals; According to the decimal modular coding strategy, the offspring individuals are decoded into the corresponding network structure, and the network structure is used to perform self-supervised denoising on the noisy image data to calculate the denoising evaluation index PSNR value. Based on the PSNR value, environmental selection is performed to select individuals for the new population, and the parent selection, crossover and mutation, decoding and noise reduction steps are repeated until all evolutionary iterations are completed. The individual with the highest PSNR value from the last generation of the population is selected and decoded into the corresponding network structure. This network structure is then used to perform noise reduction on the noisy image, and the denoised image is output.

10. A non-transitory computer-readable storage medium, characterized in that, The storage medium stores a computer program containing instructions that, when executed by one or more processors, cause the one or more processors to perform the method as described in any one of claims 1 to 8.

Images