Patent Publication Number: US-2023154177-A1

Title: Autoregression Image Abnormity Detection Method of Enhancing Latent Space Based on Memory

Description:
CROSS-REFERENCES TO RELATED APPLICATION 
     The present application claims the priority of a Chinese patent application filed with the State Intellectual Property Office of China, on Nov. 4, 2020, with the application number 202011212882.X, entitled “Autoregression Image Abnormity Detection Method of Enhancing Latent Space Based on Memory”, all content of which is incorporated in the present application by reference. 
     TECHNICAL FIELD 
     The present application relates to the field of abnormity detection in computer vision, and in particular, to an autoregression image abnormity detection method of enhancing a latent space based on memory. 
     BACKGROUND ART 
     Abnormity detection, also known as outlier detection, novelty detection, etc., is a detection process in which objects whose behavior is significantly different from that of an expected object are found. These detected objects are also called as abnormal points or outliers. Abnormity detection is widely used in production activities and life, such as, credit card anti-fraud, advertisement click anti-cheating, network intrusion detection, and so on. 
     With rise of deep learning in recent years, research on the use of abnormity detection in computer vision has begun to flourish. The abnormity detection in computer vision meets the definition of abnormity detection, wherein an image, video and other information are regarded as the input object. For example, objects are found from a large number of images with the found objects not conforming to the type of images; components which are wrongly produced are detected during the industrial production; and the abnormity detection is used to surveillance videos to automatically analyze abnormal behaviors, objects and the like in surveillance videos. Due to the fiery development of computers and the rapid expansion of data, a technology capable of analyzing information such as images and videos is urgently demanded. 
     With the development of machine learning, especially deep learning technology, image abnormity detection technologies based on machine learning emerge continuously. Compared with traditional abnormity detection, more compact information expression needs to be extracted for images. In the stage of the traditional machine learning, abnormity detection requires manually analyzing the data distribution, designing appropriate characteristics, and then using the traditional machine learning algorithms (support vector machines, isolation forests, etc.) to model and analyze the data. Compared with traditional machine learning, deep learning can automatically learn the characteristics of the data and then perform modeling and analysis on the characteristics, which has higher robustness. 
     At present, the abnormity detection methods in computer vision mainly include: methods based on reconstruction loss differences, methods based on classification learning, and methods based on density estimation.
         1) The method based on reconstruction loss difference:
           In this type of methods, usually, the input data is reconstructed, using the characteristics of the data itself, through a deep autoencoder, wherein the autoencoder is used to be able to remember the characteristics of normal samples, and it is judged whether the data is an abnormal sample by reconstruction difference (usually the abnormal samples cannot be reconstructed well, and the abnormal samples can be detected by setting a threshold).   
           2) The method based on classification learning:
           This type of methods is mainly used for outlier detection, wherein usually, normal samples are a group of data with label information, and by applying classification algorithms to this group of data, the probability that the data belongs to a certain class can be learned, wherein during the testing stage, the value of the probability that a normal sample belongs to a certain class is very large, and because the abnormal sample does not belong to this distribution, the value of the probability that it belongs to all classes is very small, based on which characteristic, whether the data is abnormal data is distinguished.   
           3) The method based on density estimation:
           This kind of method is often aimed at the situation in which a small part of a large amount of data are abnormal samples, wherein the data is modeled, using a method of traditional machine learning or deep learning to extract characteristics, through applying the density estimation method, wherein the abnormal data is often located in the part where the probability value is relatively low.   
               

     Of course, many algorithms, that are variants and combinations of the above algorithms, may be used to achieve the effect of abnormity detection, including the combination of autoencoder and generated confrontation network, and the combination of autoencoder and density estimation method. 
     However, the existing abnormity detection methods, since lacking clear supervision information (abnormal data is difficult to be collected, and the collection of normal data is too time-consuming and laborious to obtain complete data), are difficult to achieve good effects. Especially the model based on the deep autoencoder lacks a good solution to the problems of large data distribution and large data variance, etc. 
     SUMMARY 
     The present application provides an autoregression image abnormity detection method of enhancing a latent space based on memory that can better determine abnormal images. 
     The technical solution adopted by the present application for solving its technical problems is as follows.
         An autoregression image abnormity detection method of enhancing a latent space based on memory may comprise following steps:   Step 1. selecting a data set, and dividing the data set into a training set and a test set,   Step 2. constructing a network structure of an autoregression model of enhancing a latent space based on memory;   Step 3. preprocessing the training set;   Step 4. initializing the autoregression model of enhancing a latent space based on memory;   Step 5. using the preprocessed training set to train the initialized autoregression model of enhancing a latent space based on memory; and   Step 6. verifying the trained autoregression model of enhancing a latent space based on memory through the test set, and using the trained autoregression model of enhancing a latent space based on memory to judge whether an input image is an abnormal image.   Optionally, in Step 1, the data set may comprise a MNIST data set and a CIFAR10 data set.   Optionally, in Step 2, the autoregression model of enhancing a latent space based on memory may comprise: an autoencoder, an autoregression module and a memory module, wherein   the autoencoder may comprises an encoder and a decoder, wherein the autoencoder may compress an image into a latent space through the encoder, learns a characteristic expression, and then may use the decoder to decode the characteristic expression of the latent space back to an image space;   the autoregression module may be configured to model the data using the characteristics of the latent space and fit to a true distribution, with a fitting process expressed by following formula:       

     
       
         
           
             
               
                 p 
                 ⁡ 
                 ( 
                 z 
                 ) 
               
               = 
               
                 
                   ∏ 
                   
                     i 
                     = 
                     1 
                   
                   d 
                 
                   
                 
                   p 
                   ⁡ 
                   ( 
                   
                     
                       z 
                       i 
                     
                     ❘ 
                     
                       z 
                       
                         &lt; 
                         i 
                       
                     
                   
                   ) 
                 
               
             
             ; 
           
         
       
         
         
           
             
               
                 where p(z) is a latent space distribution; p(z i |z &lt;i ) is a conditional probability distribution; d represents dimension of the feature vector z; z i  represents the ith dimension of the feature vector z; z &lt;i  represents the part of the feature vector z less than the ith dimension; 
                 the memory module may be configured to store the characteristic expression of the latent space, and then the characteristic expression that does not belong to the latent space will be forcibly converted into a most relevant characteristic expression in the memory by the memory module, with a process as follows: 
               
             
           
         
       
    
     
       
         
           
             
               
                 z 
                 ^ 
               
               = 
               
                 wM 
                 = 
                 
                   
                     ∑ 
                     
                       i 
                       = 
                       1 
                     
                     N 
                   
                     
                   
                     
                       w 
                       i 
                     
                     * 
                     
                       m 
                       i 
                     
                   
                 
               
             
             ; 
           
         
       
         
         
           
             
               
                 where is the memory module, {circumflex over (z)} is the expression to the characteristic, by the memory module,   represents the similarity between the latent space and each piece of memory, m i  represents the ith block of memory of the memory module,    i  represents the similarity between the feature vector z and m i , N represents the size of the memory module, 
               
             
           
         
       
    
     
       
         
           
             
               
                 w 
                 i 
               
               = 
               
                 
                   exp 
                   ⁡ 
                   ( 
                   
                     d 
                     ⁡ 
                     ( 
                     
                       z 
                       , 
                       
                         m 
                         i 
                       
                     
                     ) 
                   
                   ) 
                 
                 
                   
                     ∑ 
                     
                       j 
                       = 
                       1 
                     
                     N 
                   
                   
                     exp 
                     ⁡ 
                     ( 
                     
                       d 
                       ⁡ 
                       ( 
                       
                         z 
                         , 
                         
                           m 
                           j 
                         
                       
                       ) 
                     
                     ) 
                   
                 
               
             
             , 
             
 
             
               
                 
                   d 
                   ⁡ 
                   ( 
                   
                     z 
                     , 
                     
                       m 
                       i 
                     
                   
                   ) 
                 
                 = 
                 
                   
                     zm 
                     i 
                     T 
                   
                   
                     
                        
                       z 
                        
                     
                     ⁢ 
                     
                        
                       
                         m 
                         i 
                       
                        
                     
                   
                 
               
               ; 
             
           
         
       
         
         
           
             
               
                 where exp( ) represents an exponential function with e as a base, ∥•∥ is a modulus operation, m i   T  is transposition of m i , and m j  represents the jth block of memory of the memory module. 
               
             
             Optionally, in Step 2, in the network structure: 
             an encoder network structure of the autoencoder may comprise a down-sampling module, a down-sampling module and a fully connected layer, wherein each block uses a residual network structure and consists of three consecutive structures, namely convolutional layer+batch normalization+activation function, in cascade; 
             a decoder network structure of the autoencoder may comprise a fully connected layer, an up-sampling module, an up-sampling module, and a convolutional layer wherein each block uses a residual network structure, and consists of three structures in cascade, whose sub-structures are respectively: transposed convolutional layer+batch normalization+activation function; convolutional layer+batch normalization+activation function; and transposed convolutional layer+batch normalization+activation function; 
             a network structure of the autoregression module can be composed of multiple autoregression layers, 
             wherein an encoder in the autoencoder is expressed as a mathematical mode: z=en(X) and the decoder is expressed as a mathematical mode: {circumflex over (X)}=de(z) the autoregression module z dist =H(z) and {circumflex over (z)} act on z, and at this time {circumflex over (X)}=de({circumflex over (z)}). 
             Optionally, the autoencoder may process an image with a processing comprising following steps of: 
             a. inputting an image with a size of N*N, wherein after an encoding stage of the autoencoder, its size of the autoregression model of enhancing a latent space based on memory becomes 2 times smaller after being subjected to the down-sampling module once, dimensions of a channel are in number which changes from 1 to 32, and further to 64, and finally, it is input to the fully connected layer in the encoder after a leveling operation, and finally the latent space z∈R 64  is obtained, and at this time {circumflex over (z)}∈R 64 ; 
             b. sending z to the memory module to obtain a similarity   between z and each block of memory, and performing, for one time, an operation of 
           
         
       
    
     
       
         
           
             
               h 
               ⁡ 
               ( 
               
                 
                   w 
                   i 
                 
                 ; 
                 y 
               
               ) 
             
             = 
             
               { 
               
                 
                   
                     
                       
                         w 
                         i 
                       
                       , 
                           
                       
                         
                           if 
                           ⁢ 
                               
                           
                             w 
                             i 
                           
                         
                         &gt; 
                         y 
                       
                     
                   
                 
                 
                   
                     
                       0 
                       , 
                           
                       otherwise 
                     
                   
                 
               
             
           
         
       
     
     on   to obtain ŵ, and finally making 
     
       
         
           
             
               z 
               ^ 
             
             = 
             
               
                 
                   w 
                   ^ 
                 
                 ⁢ 
                 M 
               
               = 
               
                 
                   ∑ 
                   
                     i 
                     = 
                     1 
                   
                   N 
                 
                   
                 
                   
                     
                       w 
                       ^ 
                     
                     i 
                   
                   * 
                   
                     m 
                     i 
                   
                 
               
             
           
         
       
     
     expressed by the memory;
         c. making {circumflex over (z)}∈R 64  subjected to the fully connected layer of the decoder to obtain a characteristic of size of       

     
       
         
           
             
               64 
               * 
               
                 N 
                 4 
               
               * 
               
                 N 
                 4 
               
             
             , 
           
         
       
     
     and finally restoring to an original size after being subjected to the up-sampling module for two times, with dimensions of the channel of the up-sampling module in number which changes from 64 to 32, and further to 16; and
         d. restoring the characteristics to an original image space through a last convolutional layer.   Optionally, Step 2 may specifically comprise following steps:   Step  201 : selecting a training set;   Step  202 : analyzing information of the training set, wherein the training set information comprises image size, image intensity, and image noise;   Step  203 : constructing a network structure applicable to current data according to the obtained information; and   Step  204 : assembling the autoencoder, the autoregression module and the memory module together.   Optionally, Step 3 may specifically comprise following steps:   Step  301 : reading image data;   Step  302 : adjusting size of the image to a specific size;   Step  303 : processing a certain amount of images that are different from an image space of overall data, which is specifically: transferring a gray space to a RGB space and a RGB space to a gray space; and   Step  304 : performing a regularization operation on the image data.   Optionally, Step 4 may be specifically: using different initialization methods to initialize a network, namely: using a random initialization method for the autoencoder and the autoregression module, and using a uniformly distributed initialization for the memory module.   Optionally, Step 5 may specifically comprise following steps:   Step  501 : loading the preprocessed data;   Step  502 : setting learning rates for the autoencoder, the autoregression module, and the memory module, respectively;   Step  503 : fixing the memory module and training the autoregression module;   Step  504 : fixing the autoregression module and training the memory module; and   Step  505 : performing Step  503  and Step  504  iteratively until the autoregression model of enhancing a latent space based on memory converges.       

     Optionally, in Step 5, the model may have a loss function of: 
         L=L   rec   +αL   llk   +βL   mem ;             where L rec  represents a reconstruction loss of an original image with respect to a reconstructed image;           
     
       
         
           
             
               L 
               llk 
             
             = 
             
               
                 ∑ 
                 
                   i 
                   = 
                   1 
                 
                 N 
               
                 
               
                 log 
                 ⁢ 
                 
                   ( 
                   
                     z 
                     dist 
                   
                   ) 
                 
               
             
           
         
       
     
     represents a negative log likelihood loss; 
     
       
         
           
             
               L 
               mem 
             
             = 
             
               
                 ∑ 
                 
                   i 
                   = 
                   1 
                 
                 T 
               
               
                 
                   - 
                   
                     
                       w 
                       ^ 
                     
                     i 
                   
                 
                 ⁢ 
                 log 
                 ⁢ 
                 
                   ( 
                   
                     
                       w 
                       ^ 
                     
                     i 
                   
                   ) 
                 
               
             
           
         
       
     
     represents an entropy of a weight coefficient of the characteristic and the memory module; and α, β respectively represent the weight coefficients of the loss function to balance a ratio of different losses. α, β are different for different data sets. As for MNIST and CIFAR10, α is equal to 1, and 0.1, respectively, and β is equal to 0.0002, and 0.0002, respectively.
         Optionally Step 6 may specifically be: using a trained autoregression model of enhancing a latent space based on memory to input an image into the autoregression model of enhancing a latent space based on memory; acquiring a probability output by the autoregression module and a reconstruction difference between a reconstructed image of the autoencoder and the original image, respectively regarded as two fractions, and adding the two fractions to obtain a final fraction; and determining whether it is an abnormal image based on a previously set threshold.       

     The beneficial effects of the present application at least comprise the following. 
     Through the above-mentioned autoregression image abnormity detection method of enhancing a latent space based on memory, by constructing and training an autoregression model of enhancing a latent space based on memory, a prior distribution is not needed to be set such that the distribution of the data itself will not be damaged, and it can prevent the model from reconstructing abnormal images, and ultimately can better judge abnormal images. 
    
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
         FIG.  1    is a flowchart of an autoregression image abnormity detection method of enhancing a latent space based on memory in an embodiment of the application; 
         FIG.  2    is a schematic diagram of a network structure of an autoregression model of enhancing a latent space based on memory in an embodiment of the application; 
         FIG.  3    is a schematic diagram of an autoregression module in an embodiment of the application; 
         FIG.  4    is a schematic diagram of a memory module in an embodiment of the application; 
         FIG.  5    is a schematic diagram of the up-sampling and down-sampling modules in an embodiment of the application; 
         FIG.  6    is a comparison table of model performance (AUC) on the MNIST data set; and 
         FIG.  7    is a comparison table of model performance (AUC) on the CIFAR10 data set. 
     
    
    
     DETAILED DESCRIPTION OF EMBODIMENTS 
     The technical solutions of the present application will be described in detail below with reference to the drawings and embodiments. 
     This embodiment proposes an autoregression image abnormity detection method of enhancing a latent space based on memory. The flowchart is shown in  FIG.  1   , wherein the method may include the following steps. 
     S1: selecting a data set, and dividing the data set into a training set and a test set. 
     In this embodiment, two mainstream image abnormity detection data sets are selected for experimentation, capable of including MNIST and CIFAR10. 
     The MNIST data set is a handwritten data set that many tasks will choose. It totally contains a training set of 60,000 examples and a test set of 10,000 examples. The data set can contain handwritten characters of digits 0-9, in 10 categories totally. Each image is a gray-scale image with a size of 28*28. 
     The CIFAR10 data set is a color image data set that is more related to universal objects. Totally, it contains training data of 50,000 images and test data of 10,000 images. It totally contains 10 categories of color RGB images: airplanes, cars, birds, cats, deer, and dogs, frogs, horses, boats, and trucks, wherein each picture is a 32*32 color image. 
     The above two data sets are selected for verifying the adaptability and robustness of the model with respect to different types of data sets. Both MNIST and CIFAR10 contain 10 categories. Most experiments will choose these two data sets. 10 categories can be adaptable very well to the background setting of abnormity detection, and provide the characteristics of data diversity. 
     S2: constructing a network structure of an autoregression model of enhancing a latent space based on memory. 
     As shown in  FIGS.  2 ,  3 ,  4 , and  5   , the autoregression model of enhancing a latent space based on memory in this embodiment can include three parts: an autoencoder, an autoregression module, and a memory module, wherein: the autoencoder may comprise an encoder and a decoder, wherein the autoencoder compresses an image into a latent space through the encoder, so as to learn a characteristic expression, and then uses the decoder to decode the characteristic expression of the latent space back to an image space; 
     the autoregression module may be configured to model the data using the characteristics of the latent space and fit to a true distribution, with a fitting process expressed by following formula: 
     
       
         
           
             
               
                 p 
                 ⁡ 
                 ( 
                 z 
                 ) 
               
               = 
               
                 
                   ∏ 
                   
                     i 
                     = 
                     1 
                   
                   d 
                 
                   
                 
                   p 
                   ⁡ 
                   ( 
                   
                     
                       z 
                       i 
                     
                     ❘ 
                     
                       z 
                       
                         &lt; 
                         i 
                       
                     
                   
                   ) 
                 
               
             
             ; 
           
         
       
         
         
           
             where p(z) is a latent space distribution; p(z i |z &lt;i ) is a conditional probability distribution; d represents dimension of the feature vector z; z i  represents the ith dimension of the feature vector z; z &lt;i  represents the part of feature vector z less than the ith dimension, wherein the autoregressive module is used to learn the distribution of the data, which will not be same as the variational autoencoder and the adversarial autoencoder, both of which set a prior distribution for the data. The setting of the prior distribution will damage the distribution of the data itself. Using the autoregressive module can effectively avoid this problem; and
           the memory module may be configured to store the characteristic expression of the latent space, and then the characteristic expression that does not belong to the latent space will be forcibly converted into a most relevant characteristic expression in the memory by the memory module, with a process as follows:   
         
           
         
       
    
     
       
         
           
             
               
                 z 
                 ^ 
               
               = 
               
                 wM 
                 = 
                 
                   
                     ∑ 
                     
                       i 
                       = 
                       1 
                     
                     N 
                   
                     
                   
                     
                       w 
                       i 
                     
                     * 
                     
                       m 
                       i 
                     
                   
                 
               
             
             ; 
           
         
       
         
         
           
             
               
                 where is the memory module, {circumflex over (z)} is an expression to the characteristic, by the memory module,   represents a similarity between the latent space and each piece of memory, m i  represents the ith block of memory of the memory module,    i  represents a similarity between the feature vector z and m i , N represents size of the memory module, 
               
             
           
         
       
    
     
       
         
           
             
               
                 w 
                 i 
               
               = 
               
                 
                   exp 
                   ⁡ 
                   ( 
                   
                     d 
                     ⁡ 
                     ( 
                     
                       z 
                       , 
                       
                         m 
                         i 
                       
                     
                     ) 
                   
                   ) 
                 
                 
                   
                     ∑ 
                     
                       j 
                       = 
                       1 
                     
                     N 
                   
                   
                     exp 
                     ⁡ 
                     ( 
                     
                       d 
                       ⁡ 
                       ( 
                       
                         z 
                         , 
                         
                           m 
                           j 
                         
                       
                       ) 
                     
                     ) 
                   
                 
               
             
             , 
             
 
             
               
                 
                   d 
                   ⁡ 
                   ( 
                   
                     z 
                     , 
                     
                       m 
                       i 
                     
                   
                   ) 
                 
                 = 
                 
                   
                     zm 
                     i 
                     T 
                   
                   
                     
                        
                       z 
                        
                     
                     ⁢ 
                     
                        
                       
                         m 
                         i 
                       
                        
                     
                   
                 
               
               ; 
             
           
         
       
         
         
           
             where exp( ) represents an exponential function with e as base, ∥•∥ is a modulus operation, m i   T  is transposition of m i , and m j  represents the jth block of memory of the memory module. 
           
         
       
    
     Here, the memory module is used to store the distributed sparse characteristic expression, which strengthens the generation effect of the autoencoder, and limits the weight, which effectively prevents the problem that the model can reconstruct abnormal images. 
     See  FIG.  5   , which is a schematic diagram of the up- and down-sampling modules, wherein Conv2d represents the convolutional layer, Bn represents the batch normalization, ReLu represents the activation function, and DeConv represents the transposed convolutional layer. Here, the encoder network structure of the autoencoder can include a down sampling module, a down sampling module, and a fully connected layer. Each block uses a residual network structure and is composed of three consecutive structures, convolutional layer+batch normalization+activation function, in cascade. 
     In this embodiment, the decoder network structure of the autoencoder may include a fully connected layer, an up sampling module, an up sampling module, and a convolutional layer. Each block uses a residual network structure, and is composed of three structures, whose sub-structures can be respectively transposed convolutional layer+batch normalization+activation function, convolutional layer+batch normalization+activation function, transposed convolutional layer+batch normalization+activation function, in cascade. 
     The network structure of the autoregression module is constructed using the structure shown in  FIG.  3   .  FIG.  3    represents a running process of an autoregression layer. The number of characteristics input and output remains unchanged, and the characteristic dimension will change. Each autoregression layer is implemented by multiple mutation fully connected layers. The current characteristics are generated using the previous characteristics of the feature vector, and finally assembled into a feature vector. The autoregression network is composed of multiple such autoregression layers. 
     The network structure of the memory module can be constructed by using the structure shown in  FIG.  4   .  FIG.  4    shows the reading mechanism of the memory module. First, an extra memory space is selected as the memory, and the size of each memory block is consistent with the size of the input. The similarity between the input and each block of memory is calculated first, and then the similarity undergoes a filtering operation (filtering out the similarity with a relatively small value), and the similarity is multiplied by each block of memory and then the two are added to obtain the output. 
     It should be pointed out that the encoder in the autoencoder is expressed by the mathematical mode of: z=en(X) and the decoder is expressed by the mathematical mode of: {circumflex over (X)}=de(z), and the autoregression module z dist =H(z) and {circumflex over (z)} act on z, at this time {circumflex over (X)}=de({circumflex over (z)}). 
     In a specific application process, the process that the autoencoder processes an image may include the following steps: 
     a. inputting one image with a size of N*N, wherein after an encoding stage of the autoencoder, its size of the autoregression model of enhancing a latent space based on memory becomes 2 times smaller after being subjected to the down-sampling module once, dimensions of a channel are in number which becomes from 1 to 32, and further to 64, and finally, it is input to the fully connected layer in the encoder after a leveling operation, and finally the latent space z∈R 64  is obtained, and at this time {circumflex over (z)}∈R 64 ; 
     b. sending z to the memory module to obtain a similarity   between z and each block of memory, and performing, for one time, an operation of 
     
       
         
           
             
               h 
               ⁡ 
               ( 
               
                 
                   w 
                   i 
                 
                 ; 
                 y 
               
               ) 
             
             = 
             
               { 
               
                 
                   
                     
                       
                         w 
                         i 
                       
                       , 
                           
                       
                         
                           if 
                           ⁢ 
                               
                           
                             w 
                             i 
                           
                         
                         &gt; 
                         y 
                       
                     
                   
                 
                 
                   
                     
                       0 
                       , 
                           
                       otherwise 
                     
                   
                 
               
             
           
         
       
     
     on   to obtain   and finally making 
     
       
         
           
             
               z 
               ^ 
             
             = 
             
               
                 
                   w 
                   ^ 
                 
                 ⁢ 
                 M 
               
               = 
               
                 
                   ∑ 
                   
                     i 
                     = 
                     1 
                   
                   N 
                 
                   
                 
                   
                     
                       w 
                       ^ 
                     
                     i 
                   
                   * 
                   
                     m 
                     i 
                   
                 
               
             
           
         
       
     
     expressed by the memory; 
     c. making z∈R 64  subjected to the fully connected layer of the decoder to obtain a characteristic of size of 
     
       
         
           
             
               64 
               * 
               
                 N 
                 4 
               
               * 
               
                 N 
                 4 
               
             
             , 
           
         
       
     
     and finally restoring to an original size after being subjected to the up-sampling module for two times, with dimensions of the channel of the up-sampling module in number which changes from 64 to 32, and further to 16; and 
     d. restoring the characteristics to an original image space through a last convolutional layer. 
     S3: preprocessing the training set. 
     In the process of training the model, it is necessary to adjust the size of all images to N*N and convert them to the corresponding image space. According to the needs of the data, the operations, such as random rotation, flipping, and noise, can be appropriately used. 
     S4: initializing the autoregression model of enhancing a latent space based on memory. 
     Since the model initialization can effectively help the network to be trained and converge, the scheme adopted here is to use random initialization method for the autoencoder module and autoregression module. The process of random initialization is to ensure that the network weight is as small as possible, and the deviation is set to zero. 
     As for the memory module M∈R N*feature_dim , N represents the size of the memory module, feature_dim means that the size of the information stored in each block of memory is consistent with dimension of the latent space. As for ∀n∈N, the uniform distribution π˜U(0,1) is used to perform feature_dim operation for the initialization, that is: any n belongs to N, and every small block in the memory is initialized. 
     S5: using the preprocessed training set to train the initialized autoregression model of enhancing a latent space based on memory. 
     In the training process, two data sets, MNIST and CIFAR10, are mainly used. 
     Here, the size of the image input to the network is 28*28 and 32*32, respectively, feature_dim is all set to 64, the output dimension of the autoregression module is all 100, the numbers of memory are respectively set to 100 and 500, and the Batch_Size size is all 256. The learning rates are set to 0.0001 and 0.001, respectively. The Adam optimizer is used for learning. The total epoch is set to 100, and the learning rate is multiplied by 0.1 every 20 epochs. Here, the memory module proposes to use uniform distribution for initialization and set a separate learning rate, which effectively solves the problem that the memory module is difficult to be trained. 
     In addition, the loss function of the model is as follows: 
         L=L   rec   +αL   llk   +βL   mem ; 
     where L rec  represents the reconstruction loss of the original image with respect to the reconstructed image, 
     
       
         
           
             
               L 
               llk 
             
             = 
             
               - 
               
                 
                   ∑ 
                   
                     i 
                     = 
                     1 
                   
                   N 
                 
                   
                 
                   log 
                   ⁢ 
                   
                     ( 
                     
                       z 
                       dist 
                     
                     ) 
                   
                 
               
             
           
         
       
     
     represents the negative log likelihood loss, 
     
       
         
           
             
               L 
               mem 
             
             = 
             
               
                 ∑ 
                 
                   i 
                   = 
                   1 
                 
                 T 
               
               
                 
                   - 
                   
                     
                       w 
                       ^ 
                     
                     i 
                   
                 
                 ⁢ 
                 
                   log 
                   ⁡ 
                   ( 
                   
                     
                       w 
                       ^ 
                     
                     i 
                   
                   ) 
                 
               
             
           
         
       
     
     represents the entropy of the weight coefficient of the characteristic and the memory module, and α, β respectively represent the weight coefficient of the loss function to balance the ratio of different losses. α, β are different for different data sets. For MNIST and CIFAR10, α are equal to 1, and 0.1, respectively, and β are 0.0002, and 0.0002, respectively. 
     S6: verifying the trained autoregression model of enhancing a latent space based on memory through the test set, and using the trained autoregression model of enhancing a latent space based on memory, to judge whether an input image is an abnormal image. 
     This embodiment mainly uses the area AUC under the ROC curve to evaluate the pros and cons of the method. Usually this indicator is calculated based on four elements of the confusion matrix of the classification problem: True Positive (TP), False Positive (FP), False Negative (FN) and True Negative (TN), wherein the confusion matrix is shown in Table 1 below: 
     
       
         
           
               
               
               
             
               
                   
                 TABLE 1 
               
               
                   
                   
               
               
                   
                 Predicted as abnormal 
                 Predicted as normal 
               
               
                   
                   
               
             
            
               
                   
               
            
           
           
               
               
               
            
               
                 Actually abnormal 
                 True Positive (TP) 
                 False Negative (FN) 
               
               
                 Actually normal 
                 False Positive (FP) 
                 True Negative (TN) 
               
               
                   
               
            
           
         
       
     
     In addition, the following formula is calculated: 
     
       
         
           
             
               
                 
                   True 
                   ⁢ 
                       
                   Positive 
                   ⁢ 
                       
                   
                     Rate 
                     ⁢ 
                     
                         
                         
                     
                     ( 
                     TPR 
                     ) 
                   
                 
                 = 
                 
                   TP 
                   
                     
                       T 
                       ⁢ 
                       P 
                     
                     + 
                     
                       F 
                       ⁢ 
                       N 
                     
                   
                 
               
                 
             
             ⁢ 
             
 
             
               
                 
                   False 
                   ⁢ 
                       
                   Positive 
                   ⁢ 
                       
                   Rate 
                   ⁢ 
                      
                   
                     ( 
                     FPR 
                     ) 
                   
                 
                 = 
                 
                   FP 
                   
                     
                       F 
                       ⁢ 
                       P 
                     
                     + 
                     
                       T 
                       ⁢ 
                       N 
                     
                   
                 
               
                  
             
             ⁢ 
             
 
             
               
                 True 
                 ⁢ 
                     
                 Negative 
                 ⁢ 
                     
                 
                   Rate 
                   ⁢ 
                   
                       
                       
                   
                   ( 
                   TNR 
                   ) 
                 
               
               = 
               
                 TN 
                 
                   
                     F 
                     ⁢ 
                     P 
                   
                   + 
                   
                     T 
                     ⁢ 
                     N 
                   
                 
               
             
           
         
       
     
     The ROC curve is composed of two coordinates, i.e. the abscissa FPR and the ordinate TPR. One curve can be drawn by adjusting different thresholds. AUC is the area size of the part lower than the curve. 
     In addition, the performance of the model can be tested on the two data sets of MNIST and CIFAR10, respectively, which always achieves good performance compared with the current popular methods. The test comparison results are shown in  FIGS.  6  and  7   , wherein  FIG.  6    is a comparison table of model performance (AUC) on the MNIST data set, and  FIG.  7    is a comparison table of model performance (AUC) on the CIFAR10 data set. 
     It can be seen from  FIG.  6    that this embodiment is better than the existing method in individual category of the MNIST data set. The final avg score of the method in this embodiment reaches 0.981, which is the best performance so far. It can be seen from  FIG.  7    that the performance of this embodiment on the 4, 6, and 9 of the CIFAR10 data set has been greatly improved, and the final avg score reaches 0.673, which is the best performance so far. This proves that the autoregression model of enhancing a latent space based on memory proposed in the present application can be effectively applied to image abnormity detection and can greatly compensate for the shortcomings of the existing methods. 
     INDUSTRIAL APPLICABILITY 
     The present application provides an autoregression image abnormity detection method of enhancing a latent space based on memory, which belongs to the field of abnormity detection in computer vision. The present application comprises: selecting a training data set; constructing a network structure of an autoregression model of enhancing a latent space based on memory; preprocessing the training data set; initializing the autoregression model of enhancing a latent space based on memory; training the autoregression model of enhancing a latent space based on memory; and verifying the model on the selected data set, and using the trained model to judge whether the input image is an abnormal image. The present application does not need to set a prior distribution such that the distribution of the data itself will not be damaged, and it can prevent the model from reconstructing abnormal images, and ultimately can better judge abnormal images. 
     In addition, it can be understood that the autoregression image abnormity detection method of enhancing a latent space based on memory of the present application is reproducible and can be used in a variety of industrial applications. For example, the autoregression image abnormity detection  5  method of enhancing a latent space based on memory of the present application can be used in applications that require the image abnormity detection.