# Patent

## Title
Efficient convolutional sparse coding

## Abstract

Computationally efficient algorithms may be applied for fast dictionary learning solving the convolutional sparse coding problem in the Fourier domain. More specifically, efficient convolutional sparse coding may be derived within an alternating direction method of multipliers (ADMM) framework that utilizes fast Fourier transforms (FFT) to solve the main linear system in the frequency domain. Such algorithms may enable a significant reduction in computational cost over conventional approaches by implementing a linear solver for the most critical and computationally expensive component of the conventional iterative algorithm. The theoretical computational cost of the algorithm may be reduced from O(M3N) to O(MN log N), where N is the dimensionality of the data and M is the number of elements in the dictionary. This significant improvement in efficiency may greatly increase the range of problems that can practically be addressed via convolutional sparse representations.

## Background
CROSS REFERENCE TO RELATED APPLICATION
This application claims the benefit of U.S. provisional patent application No. 61/972,779 filed on Mar. 31, 2014. The subject matter of this earlier filed application is hereby incorporated by reference in its entirety.


STATEMENT OF FEDERAL RIGHTS
The United States government has rights in this invention pursuant to Contract No. DE-AC52-06NA25396 between the United States Department of Energy and Los Alamos National Security, LLC for the operation of Los Alamos National Laboratory.


FIELD
The present invention generally relates to sparse coding, and more particularly, to efficient convolutional sparse coding derived within an alternating direction method of multipliers (ADMM) framework that utilizes fast Fourier transforms (FFT) for convolutional sparse representations.
BACKGROUND
Sparse representation is a widely used technique for a broad range of signal and image processing applications. For instance, sparse representations may be used for labeling objects in images to identify and classify what objects are present. Given a signal s and a dictionary matrix D, sparse coding is the inverse problem of finding the sparse representation x with only a few non-zero entries such that Dx≈s. The process of arriving at these identifications is non-trivial and complex.
Different approaches to sparse coding have been proposed. However, most sparse coding algorithms optimize a functional consisting of a data fidelity term and a sparsity inducing penalty of the form




  
    
      
        
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
              
            
            
              
                x
              
            
          
          ⁢
          
            1
            2
          
          ⁢
          
            
              
              
                
                  D
                  ⁢
                  
                    
                  
                  ⁢
                  x
                
                -
                s
              
              
            
            2
            2
          
        
        +
        
          λ
          ⁢
          
            
          
          ⁢
          
            R
            ⁡
            
              (
              x
              )
            
          
        
      
    
    
      
        (
        1
        )
      
    
  




or constrained forms such as




  
    
      
        
          
            
              
                
                  
                    arg
                    ⁢
                    
                      
                    
                    ⁢
                    min
                  
                
              
              
                
                  x
                
              
            
            ⁢
            
              R
              ⁡
              
                (
                x
                )
              
            
            ⁢
            
              
            
            ⁢
            such
            ⁢
            
              
            
            ⁢
            that
            ⁢
            
              
            
            ⁢
            
              
                
                
                  Dx
                  -
                  s
                
                
              
              2
            
          
          ≤
          ε
        
        ⁢
        
          

        
        ⁢
        or
      
    
    
      
        (
        2
        )
      
    
  
  
    
      
        
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
              
            
            
              
                x
              
            
          
          ⁢
          
            
              
              
                Dx
                -
                s
              
              
            
            2
          
          ⁢
          
            
          
          ⁢
          such
          ⁢
          
            
          
          ⁢
          that
          ⁢
          
            
          
          ⁢
          
            R
            ⁡
            
              (
              x
              )
            
          
        
        ≤
        τ
      
    
    
      
        (
        3
        )
      
    
  




where D is a dictionary matrix, x is the sparse representation, λ is a regularization parameter, ε is a reconstruction error threshold, τ is a sparsity threshold, and R(•) denotes a sparsity inducing function such as the l1 norm or the l0 “norm.” While the l0 norm does not conform to all of the requirements of a real norm, it is convenient to write it using norm notation. Regularization parameter λ controls the relative importance of the data fidelity term that penalizes a solution that does not match the data and the regularization term that penalizes a solution that is not sparse (i.e., one that has too many non-zero entries). When applied to images, this decomposition is usually applied independently to a set of overlapping image patches covering the image. This approach is convenient, but often necessitates somewhat ad hoc subsequent handling of the overlap between patches. This results in a representation over the whole image that is suboptimal.
The two leading families of sparse coding methods are: (1) a wide variety of convex optimization algorithms (e.g., Alternating Direction Method of Multipliers (ADMM)) for solving Eq. (1) when R(x)=∥x∥1; and (2) a family of greedy algorithms (e.g., matching Pursuit (MP) and Orthogonal Matching Pursuit (OMP)) for providing an approximate solution for Eq. (2) or Eq. (3) when R(x)=∥x∥0.
If the dictionary D is analytically defined and corresponds to a linear operator with a fast transform (e.g., the Discrete Wavelet Transform), a representation for an entire signal or image can readily be computed. More recently, however, it has been realized that improved performance can be obtained by learning the dictionary from a set of training data relevant to a specific problem. This inverse problem is known as “dictionary learning.” In this case, computing a sparse representation for an entire signal is not feasible, with the usual approach being to apply the decomposition independently to a set of overlapping blocks covering the signal, as illustrated in independent sparse representation 100 of FIG. 1. This approach is relatively straightforward to implement, but results in a representation that is multi-valued and suboptimal over the signal as a whole, often necessitating somewhat ad hoc handling of the overlap between blocks.
An optimal representation for a given block structure would involve solving a single optimization problem for a block matrix dictionary {tilde over (D)} with blocks consisting of appropriately shifted versions of the single-block dictionary D, as illustrated in jointly optimized sparse representation 200 of FIG. 2. If the block structure is modified such that the step between blocks is a single sample, as in equivalence 300 of FIG. 3, the representation on the resulting block dictionary {tilde over (D)} is both optimal for the entire signal and shift-invariant. Furthermore, in this case, the linear representation on the block dictionary {tilde over (D)} can be expressed as a sum of convolutions of columns dm of D with a set of spatial coefficient maps corresponding to the subsets of x associated with different shifts of each column of D. In other words, by a straightforward change of indexing of coefficients, the representation {tilde over (D)}x≈s is equivalent to Σmdm*xm≈s. This form of sparse representation is referred to here as a “convolutional” sparse representation.
Convolutional BPDN
While convolutional forms can be constructed for each of Eq. (1)-(3), the focus herein is on the convolutional form of Eq. (1) with R(x)=∥x∥1, i.e. the BPDN problem




  
    
      
        
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
              
            
            
              
                x
              
            
          
          ⁢
          
            1
            2
          
          ⁢
          
            
              
              
                
                  D
                  ⁢
                  
                    
                  
                  ⁢
                  x
                
                -
                s
              
              
            
            2
            2
          
        
        +
        
          λ
          ⁢
          
            
          
          ⁢
          
            
              
              x
              
            
            1
          
        
      
    
    
      
        (
        4
        )
      
    
  




Recently, these techniques have been applied to computer vision problems such as face recognition and image classification. In this context, convolutional sparse representations were introduced, replacing Eq. (4) with




  
    
      
        
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
              
            
            
              
                
                  {
                  
                    x
                    m
                  
                  }
                
              
            
          
          ⁢
          
            1
            2
          
          ⁢
          
            
              
              
                
                  
                    ∑
                    m
                  
                  ⁢
                  
                    
                      d
                      m
                    
                    *
                    
                      x
                      m
                    
                  
                
                -
                s
              
              
            
            2
            2
          
        
        +
        
          λ
          ⁢
          
            
              ∑
              m
            
            ⁢
            
              
                
                
                  x
                  m
                
                
              
              1
            
          
        
      
    
    
      
        (
        5
        )
      
    
  




where {dm} is a set of M dictionary filters, * denotes convolution, and {xm} is a set of coefficient maps, each of which is the same size as s. Here, s is a full image, and the set of dictionary filters {dm} is usually much smaller. For notational simplicity, s and xm are considered to be N dimensional vectors, where N is the number of pixels in an image, and the notation {xm} is adopted to denote all M of xm stacked as a single column vector. The derivations presented here are for a single image with a single color band, but the extension to multiple color bands for both image and filters and simultaneous sparse coding of multiple images is also possible. The extension to color and other multi-band images is mathematically straightforward, at the price of some additional notations.
The original algorithm proposed for convolutional sparse coding adopted a splitting technique with alternating minimization of two sub-problems—the first consisting of the solution of a large linear system via an iterative method and the second consisting of a simple shrinkage. The resulting alternating minimization algorithm is similar to one that would be obtained within an ADMM framework, but requires continuation on the auxiliary parameter that controls the strength of the additional term penalizing the violation of the constraint inherent in the splitting. All computation is performed in the spatial domain since it was expected that computation in the discrete Fourier transform (DFT) domain would result in undesirable boundary artifacts. The DFT converts a finite list of equally spaced samples of a function into a list of coefficients of a finite combination of complex sinusoids, ordered by their frequencies. DFTs convert the sampled function from its original domain, such as time or a position along a line, to the frequency domain, as is known. Other algorithms that have been proposed for this problem include coordinate descent and a proximal gradient method, both operating in the spatial domain.
Recently, an ADMM algorithm operating in the DFT domain has been proposed for dictionary learning for convolutional sparse representations. The use of fast Fourier transforms (FFTs) in solving the relevant linear systems has been shown to give substantially better asymptotic performance than the original spatial domain method. FFTs are algorithms that compute the DFT and its inverse, as is known. Also, evidence is presented to support the claim that the resulting boundary effects are not significant.
However, the computation time for solving for linear systems in this algorithm, which dominates the computational cost of the algorithm, is (M3N). This significant cost renders the algorithm inefficient and impractical for large values of M (i.e., dictionaries with a large number of filters), and is likely the reason that this form of sparse representation has received little attention for image processing applications. Accordingly, an improved, more efficient approach may be beneficial.
SUMMARY
Certain embodiments of the present invention may provide solutions to the problems and needs in the art that have not yet been fully identified, appreciated, or solved by conventional sparse coding algorithms. For example, some embodiments of the present invention pertain to application of a convolutional sparse coding algorithm that is derived within the ADMM framework and solves the main linear system in the frequency domain for a significant computational advantage over conventional algorithms. Efficient convolutional sparse coding may be derived within an ADMM framework using FFTs. Coefficient maps of a signal or image vector s may be determined using the derived efficient convolutional sparse coding. More specifically, coefficient maps {xm} in the frequency domain {{circumflex over (x)}m} may be computed using Eq. (31) below such that the coefficient maps are determined with an efficiency of O(MN log N), where N is the dimensionality of the data and M is the number of elements in the dictionary. The coefficient maps may be computed in the frequency domain using only inner products, element-wise addition, and scalar multiplication, avoiding slower matrix-vector operations.
In an embodiment, a computer-implemented method includes deriving efficient convolutional sparse coding in a frequency domain, by a computing system, within an alternating direction method of multipliers (ADMM) framework using fast Fourier transforms (FFTs). The computer-implemented method also includes determining, by the computing system, coefficient maps of a signal or image vector s using the derived efficient convolutional sparse coding. The computer-implemented method further includes outputting the coefficient maps, by the computing system, as a sparse representation of s when stopping criteria are met.
In another embodiment, a computer program is embodied on a non-transitory computer-readable medium. The program is configured to cause at least one processor to precompute fast Fourier transforms (FFTs) of {dm}→{{circumflex over (D)}m} and s→ŝ, where {dm} is a filter dictionary and s is a signal or image vector and initialize {ym}={um}=0, where {ym} is a set of auxiliary variables and {um} is a set of Lagrange multipliers. While stopping criteria are not met, the program is also configured to cause the at least one processor to compute FFTs of {ym}→{ŷm}, {um}→{ûm}, compute {{circumflex over (x)}m} using




  
    
      v
      n
    
    =
    
      
        ρ
        
          -
          1
        
      
      ⁡
      
        (
        
          
            b
            n
          
          -
          
            
              
                
                  a
                  n
                  H
                
                ⁢
                
                  b
                  n
                
              
              
                ρ
                +
                
                  
                    a
                    n
                    H
                  
                  ⁢
                  
                    a
                    n
                  
                
              
            
            ⁢
            
              a
              n
            
          
        
        )
      
    
  
  ,




compute inverse FFTs of {xm}→{{circumflex over (x)}m}, set {ym}=λ/ρ({xm}+{um}) and {um}={um}+{xm}−{ym}, and update ρ when convergence to a desired accuracy has not occurred. The program is further configured to output coefficient maps {xm} as a sparse representation of s when the stopping criteria are met.

In yet another embodiment, a system includes memory storing computer program instructions and at least one processor configured to execute the stored computer program instructions. The at least one processor, by executing the stored computer program instructions, is configured to compute a dictionary in a frequency domain ĝm ∀m using ŷk,m as coefficient maps and using an iterated Sherman-Morrison algorithm for a dictionary update. The at least one processor is also configured to output a dictionary {gm} when stopping tolerances are met.



BRIEF DESCRIPTION OF THE DRAWINGS
In order that the advantages of certain embodiments of the invention will be readily understood, a more particular description of the invention briefly described above will be rendered by reference to specific embodiments that are illustrated in the appended drawings. While it should be understood that these drawings depict only typical embodiments of the invention and are not therefore to be considered to be limiting of its scope, the invention will be described and explained with additional specificity and detail through the use of the accompanying drawings, in which:
FIG. 1 is an independent sparse representation of overlapping blocks.
FIG. 2 is a jointly optimized sparse representation of overlapping blocks.
FIG. 3 illustrates equivalence between the jointly optimized sparse representation and a convolutional sparse representation.
FIG. 4A is a graph illustrating the single precision execution times of solution methods for a range of dictionary sizes, according to an embodiment of the present invention.
FIG. 4B is a graph illustrating the double precision execution times of solution methods for a range of dictionary sizes, according to an embodiment of the present invention.
FIG. 4C is a graph illustrating the single precision relative residual solution errors of solution methods for a range of dictionary sizes, according to an embodiment of the present invention.
FIG. 4D is a graph illustrating the double precision relative residual solution errors of solution methods for a range of dictionary sizes, according to an embodiment of the present invention.
FIG. 5 is a graph illustrating a comparison of primal residual evolution with time for the ADMM algorithm with Eq. (19) solved in single precision using Sherman-Morrison and CG with three different relative residual tolerances, according to an embodiment of the present invention.
FIG. 6 is a graph illustrating a comparison of functional value evolution with time for the ADMM algorithm with Eq. (20) solved in single precision using Sherman-Morrison and CG with three different relative residual tolerances, according to an embodiment of the present invention.
FIG. 7 is a graph illustrating dictionary learning functional value evolution for different choices of σo, with and without the automatic parameter adaptation scheme, according to an embodiment of the present invention.
FIG. 8A is a graph illustrating execution times versus the number of images for a single precision solution of a linear system corresponding to an 8×8×64 dictionary with λ=0.1, according to an embodiment of the present invention.
FIG. 8B is a graph illustrating solution error versus the number of images for a single precision solution of a linear system corresponding to an 8×8×64 dictionary with λ=0.1, according to an embodiment of the present invention.
FIG. 9A is a graph illustrating execution times versus the dictionary size for a single precision solution of a linear system corresponding to an 8×8×M dictionary with K=32 and λ=0.1, according to an embodiment of the present invention.
FIG. 9B is a graph illustrating solution error versus the dictionary size for a single precision solution of a linear system corresponding to an 8×8×M dictionary with K=32 and λ=0.1, according to an embodiment of the present invention.
FIG. 10 is a graph illustrating a comparison of functional value evolution with time for the ADMM algorithm with Eq. (50) solved in single precision using Sherman-Morrison and CG with three different relative residual tolerances as well as an automatic tolerance selection method and an 8×8×64 dictionary with λ=0.1, according to an embodiment of the present invention.
FIG. 11 illustrates a multi-scale dictionary with 8×8, 12×12, and 16×16 filters learned with λ=0.1 learned from a set of 32 512×512 training images, according to an embodiment of the present invention.
FIG. 12 is a flowchart illustrating a process for solving the convolutional sparse coding problem in the Fourier domain, according to an embodiment of the present invention.
FIG. 13 is a flowchart illustrating a process for fast dictionary learning, according to an embodiment of the present invention.
FIG. 14 is a block diagram of a computing system configured to perform fast dictionary learning and solve the convolutional sparse coding problem in the Fourier domain, according to an embodiment of the present invention.



DETAILED DESCRIPTION OF THE EMBODIMENTS
Some embodiments of the present invention pertain to fast algorithms for convolutional sparse coding that are derived within the ADMM framework and exploit FFT, as well as fast algorithms for dictionary learning. Such embodiments provide a significant computational advantage as compared with conventional algorithms. This is somewhat similar to the sparse coding component of the dictionary learning algorithm of Bristow et al., but introduces an approach for solving the linear systems that dominate the computational cost of the algorithm in time that is linear in the number of filters, instead of cubic (i.e., (M3N)) in conventional techniques. See H. Bristow, A. Eriksson, and S. Lucey, “Fast Convolutional Sparse Coding,” Proc. IEEE Conf. Comp. Vis. Pat. Recog. (CVPR), pp. 391-398 (June 2013). This significant improvement in efficiency may greatly increase the range of problems that can practically be addressed via convolutional sparse representations. Applications of the fast algorithms of some embodiments include, but are not limited to, computer vision problems (e.g., identifying objects in images), improving the quality of images (e.g., removing noise, repairing damage, etc.). Generally speaking, there are two parts to the process of some embodiments: (1) learn a model describing the data (i.e., “dictionary learning”); and (2) apply the model (i.e., “sparse coding”).
The most expensive component is solving a very large linear system. A key insight that enables some embodiments to run orders of magnitude faster than conventional approaches is the realization that the matrices occurring in the frequency domain have a special structure that allows for a much faster solution. More specifically, the matrices that represent the dictionary in the frequency domain are block matrices where every block is a diagonal, as is described in more detail below.
In practice, some embodiments are 10-100 times faster than conventional approaches. Due to the improvements in speed presented by some embodiments, new supercomputers (e.g., high performance, multi-parallel cluster systems) may be able to process at least some classes of images in real time. With further advances in computing, real time applications may be possible generally. Parallelization is the key for this improvement, and real time applications are within the scope of the present disclosure.
ADMM Algorithm for Convolutional BPDN
Given the recent success of ADMM for the standard BPDN problem, it follows that ADMM may be considered for convolutional BPDN. The general outline of the method derived here is similar to the sparse coding component of the Augmented Lagrangian dictionary learning algorithm developed by Bristow et al. At a superficial level, the only difference is that for convolutional BPDN, the ADMM algorithm is derived in the spatial domain with one of the sub-problems being solved in the frequency domain, whereas the sparse coding component of the Augmented Lagrangian dictionary learning algorithm is directly derived using a mixture of spatial and frequency domain variables. A much more important difference and benefit of using the new ADMM algorithm in some embodiments for convolutional BPDN, however, is the use of a far more efficient method for solving the linear system that represents the bulk of the computational cost of the algorithm, which is a new way of solving the main sub-problem.
The ADMM iterations for solving the optimization




  
    
      
        
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
              
            
            
              
                
                  x
                  ,
                  y
                
              
            
          
          ⁢
          
            f
            ⁡
            
              (
              x
              )
            
          
        
        +
        
          
            g
            ⁡
            
              (
              y
              )
            
          
          ⁢
          
            
          
          ⁢
          such
          ⁢
          
            
          
          ⁢
          that
          ⁢
          
            
          
          ⁢
          Ax
        
        +
        By
        +
        c
      
    
    
      
        (
        6
        )
      
    
  




are, in scaled form,




  
    
      
        
          x
          
            (
            
              j
              +
              1
            
            )
          
        
        =
        
          
            
              
                
                  
                    arg
                    ⁢
                    
                      
                    
                    ⁢
                    min
                  
                
              
              
                
                  x
                
              
            
            ⁢
            
              f
              ⁡
              
                (
                x
                )
              
            
          
          +
          
            
              ρ
              2
            
            ⁢
            
              
                
                
                  Ax
                  +
                  
                    By
                    
                      (
                      j
                      )
                    
                  
                  -
                  c
                  +
                  
                    u
                    
                      (
                      j
                      )
                    
                  
                
                
              
              2
              2
            
          
        
      
    
    
      
        (
        7
        )
      
    
  
  
    
      
        
          y
          
            (
            
              j
              +
              1
            
            )
          
        
        =
        
          
            
              
                
                  
                    arg
                    ⁢
                    
                      
                    
                    ⁢
                    min
                  
                
              
              
                
                  y
                
              
            
            ⁢
            
              g
              ⁡
              
                (
                y
                )
              
            
          
          +
          
            
              ρ
              2
            
            ⁢
            
              
                
                
                  
                    Ax
                    
                      (
                      
                        j
                        +
                        1
                      
                      )
                    
                  
                  +
                  By
                  -
                  c
                  +
                  
                    u
                    
                      (
                      j
                      )
                    
                  
                
                
              
              2
              2
            
          
        
      
    
    
      
        (
        8
        )
      
    
  
  
    
      
        
          u
          
            (
            
              j
              +
              1
            
            )
          
        
        =
        
          
            u
            
              (
              j
              )
            
          
          +
          
            Ax
            
              (
              
                j
                +
                1
              
              )
            
          
          +
          
            By
            
              (
              
                j
                +
                1
              
              )
            
          
          -
          c
        
      
    
    
      
        (
        9
        )
      
    
  




It is possible to rewrite Eq. (5) above in a form suitable for ADMM by introducing auxiliary variables {ym}. The variables {ym}, referred to in the plural since there is a set thereof indexed by m, can be thought of as copies of the main {ym} variables. The constraint {xm}−{ym}=0 ensures that the problem with these “copies” is equivalent to the original problem. However, the introduction of these copies makes it possible to try to solve the problem by an alternating minimization approach, holding {ym} constant and minimizing {xm}, followed by minimizing {ym}, then returning to {xm}, and so on. In some cases, such as here, solving these two sub-problems turns out to be easier than solving the original problem. This yields




  
    
      
        
          
            
              
                
                  
                    arg
                    ⁢
                    
                      
                    
                    ⁢
                    min
                  
                
              
              
                
                  
                    
                      {
                      
                        x
                        m
                      
                      }
                    
                    ,
                    
                      {
                      
                        y
                        m
                      
                      }
                    
                  
                
              
            
            ⁢
            
              1
              2
            
            ⁢
            
              
                
                
                  
                    
                      Σ
                      m
                    
                    ⁢
                    
                      d
                      m
                    
                    *
                    
                      x
                      m
                    
                  
                  -
                  s
                
                
              
              2
              2
            
          
          +
          
            
              λΣ
              m
            
            ⁢
            
              
                
                
                  y
                  m
                
                
              
              1
            
          
        
        ⁢
        
          

        
        ⁢
        
          
            
              such
              ⁢
              
                
              
              ⁢
              that
              ⁢
              
                
              
              ⁢
              
                x
                m
              
            
            -
            
              y
              m
            
          
          =
          
            0
            ⁢
            
              ∀
              m
            
          
        
      
    
    
      
        (
        10
        )
      
    
  




for which the corresponding ADMM iterations with dual variables {ym} are




  
    
      
        
          
            {
            
              x
              m
            
            }
          
          
            (
            
              j
              +
              1
            
            )
          
        
        =
        
          
            
              
                
                  
                    arg
                    ⁢
                    
                      
                    
                    ⁢
                    min
                  
                
              
              
                
                  
                    {
                    
                      x
                      m
                    
                    }
                  
                
              
            
            ⁢
            
              1
              2
            
            ⁢
            
              
                
                
                  
                    
                      ∑
                      m
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        d
                        m
                      
                      *
                      
                        x
                        m
                      
                    
                  
                  -
                  s
                
                
              
              2
              2
            
          
          +
          
            
              ρ
              2
            
            ⁢
            
              
                ∑
                m
              
              ⁢
              
                
                  
                  
                    
                      x
                      m
                    
                    -
                    
                      y
                      m
                      
                        (
                        j
                        )
                      
                    
                    +
                    
                      u
                      m
                      
                        (
                        j
                        )
                      
                    
                  
                  
                
                2
                2
              
            
          
        
      
    
    
      
        (
        11
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            
              {
              
                y
                m
              
              }
            
            
              (
              
                j
                +
                1
              
              )
            
          
          =
          
            
              
                
                  
                    
                      arg
                      ⁢
                      
                        
                      
                      ⁢
                      min
                    
                  
                
                
                  
                    
                      {
                      
                        y
                        m
                      
                      }
                    
                  
                
              
              ⁢
              λ
              ⁢
              
                
                  ∑
                  M
                
                ⁢
                
                  
                    
                    
                      y
                      m
                    
                    
                  
                  1
                
              
            
            +
            
              
                ρ
                2
              
              ⁢
              
                
                  ∑
                  m
                
                ⁢
                
                  
                    
                    
                      
                        x
                        m
                        
                          (
                          
                            j
                            +
                            1
                          
                          )
                        
                      
                      -
                      
                        y
                        m
                      
                      +
                      
                        u
                        m
                        
                          (
                          j
                          )
                        
                      
                    
                    
                  
                  2
                  2
                
              
            
          
        
      
    
    
      
        (
        12
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            u
            m
            
              (
              
                j
                +
                1
              
              )
            
          
          =
          
            
              u
              m
              
                (
                j
                )
              
            
            +
            
              x
              m
              
                (
                
                  j
                  +
                  1
                
                )
              
            
            -
            
              y
              m
              
                (
                
                  j
                  +
                  1
                
                )
              
            
          
        
      
    
    
      
        (
        13
        )
      
    
  




The set {um} are Lagrange multipliers in the ADMM approach. This is a standard formulation that is known to those of ordinary skill in the art of optimization. ρ is the penalty parameter that plays a similar role to that discussed above. ρ controls the “strength” of the term that enforces the constraint that {xm}={ym}, which is necessary for the split problem to be equivalent to the original one. ρ is an important algorithm parameter that ends up controlling how fast the iterative algorithm converges.
The sub-problem of Eq. (12) can be solved via shrinkage/soft thresholding as

ym(j+1)=λ/ρ(xm(j+1)+um(j))  (14)

where

γ(u)=sign(u)⊙max(0,|u|−γ)  (15)

with sign(•) and |•| of a vector considered to be applied element-wise, and ⊙ denoting element-wise multiplication. The computational cost of this sub-problem is (MN). The only computationally expensive step is solving Eq. (11), which is of the form




  
    
      
        
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
              
            
            
              
                
                  {
                  
                    x
                    m
                  
                  }
                
              
            
          
          ⁢
          
            1
            2
          
          ⁢
          
            
              
              
                
                  
                    ∑
                    m
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      d
                      m
                    
                    *
                    
                      x
                      m
                    
                  
                
                -
                s
              
              
            
            2
            2
          
        
        +
        
          
            ρ
            2
          
          ⁢
          
            
              ∑
              m
            
            ⁢
            
              
                
                
                  
                    x
                    m
                  
                  -
                  
                    z
                    m
                  
                
                
              
              2
              2
            
          
        
      
    
    
      
        (
        16
        )
      
    
  




DFT Domain Formulation
It is possible to attempt to exploit the FFT for efficient implementation of the convolution via the DFT convolution theorem. This involves some increase in memory requirements since dm is zero-padded to the size of xm before application of the FFT.
Linear operators Dm are defined such that Dmxm=dm*xm, and the variables Dm, xm, s, and zm are denoted in the DFT domain by {circumflex over (D)}m, {circumflex over (x)}m, ŝ, and {circumflex over (z)}m, respectively. It can be shown via the DFT convolution theorem that Eq. (16) is equivalent to




  
    
      
        
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
              
            
            
              
                
                  {
                  
                    
                      x
                      ^
                    
                    m
                  
                  }
                
              
            
          
          ⁢
          
            1
            2
          
          ⁢
          
            
              
              
                
                  
                    ∑
                    m
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      
                        D
                        ^
                      
                      m
                    
                    ⁢
                    
                      
                        x
                        ^
                      
                      m
                    
                  
                
                -
                
                  s
                  ^
                
              
              
            
            2
            2
          
        
        +
        
          
            ρ
            2
          
          ⁢
          
            
              ∑
              m
            
            ⁢
            
              
                
                
                  
                    
                      x
                      ^
                    
                    m
                  
                  -
                  
                    
                      z
                      ^
                    
                    m
                  
                
                
              
              2
              2
            
          
        
      
    
    
      
        (
        17
        )
      
    
  




with the {xm} minimizing in Eq. (16) being given by the inverse DFT of the {{circumflex over (x)}m} minimizing in Eq. (17). By defining




  
    
      
        
          
            D
            ^
          
          =
          
            (
            
              
                
                  
                    
                      D
                      ^
                    
                    0
                  
                
                
                  
                    
                      D
                      ^
                    
                    1
                  
                
                
                  ...
                
              
            
            )
          
        
        ,
        
          
            x
            ^
          
          =
          
            (
            
              
                
                  
                    
                      x
                      ^
                    
                    0
                  
                
              
              
                
                  
                    
                      x
                      ^
                    
                    1
                  
                
              
              
                
                  ⋮
                
              
            
            )
          
        
        ,
        
          
            z
            ^
          
          =
          
            (
            
              
                
                  
                    
                      z
                      ^
                    
                    0
                  
                
              
              
                
                  
                    
                      z
                      ^
                    
                    1
                  
                
              
              
                
                  ⋮
                
              
            
            )
          
        
      
    
    
      
        (
        18
        )
      
    
  




this problem can be expressed as




  
    
      
        
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
              
            
            
              
                
                  {
                  
                    x
                    ^
                  
                  }
                
              
            
          
          ⁢
          
            1
            2
          
          ⁢
          
            
              
              
                
              
              ⁢
              
                
                  
                    D
                    ^
                  
                  ⁢
                  
                    x
                    ^
                  
                
                -
                
                  s
                  ^
                
              
              
            
            2
            2
          
        
        +
        
          
            ρ
            2
          
          ⁢
          
            
              
              
                
                  x
                  ^
                
                -
                
                  z
                  ^
                
              
              
            
            2
            2
          
        
      
    
    
      
        (
        19
        )
      
    
  




the solution being given by the linear system

({circumflex over (D)}H{circumflex over (D)}+ρI){circumflex over (x)}={circumflex over (D)}Hŝ+ρ{circumflex over (z)}  (20)

Independent Linear Systems
Matrix {circumflex over (D)} has a block structure consisting of M concatenated N×N diagonal matrices, where M is the number of filters and N is the number of samples in s. {circumflex over (D)}H{circumflex over (D)} is an MN×MN matrix, but due to the diagonal block (not block diagonal) structure of {circumflex over (D)}, a row of {circumflex over (D)}H with its non-zero element at column n will only have a non-zero product with a column of {circumflex over (D)} with its non-zero element at row n. As a result, there is no interaction between elements of {circumflex over (D)} corresponding to different frequencies, so that one need only solve N independent M×M linear systems to solve Eq. (20). The cost of the FFTs and solving these linear systems dominate the computational cost of the algorithm.
The previous approach of Bristow et al. did not specify how to solve these linear systems. However, since the computational cost of solving the linear systems is rated as (M3N), it can be concluded that a direct method, such as Gaussian elimination (GE), is applied. This can be effective when it is possible to precompute and store a lower upper (LU), which is a standard decomposition in linear algebra, or a Cholesky decomposition (or similar decomposition) of the system matrix. In the present case, such an approach is not practical, and generally impossible unless M is very small, due to the (M2N) memory requirement for storage of these decompositions. Nevertheless, this remains a reasonable approach for small values of M, with the only apparent alternative being an iterative method such as conjugate gradient (CG).
However, a careful analysis of the unique structure of this problem reveals that there is an alternative and vastly more effective solution. More specifically, there is a special structure to the matrices, which are block matrixes where every block is a diagonal. The mth block of the right hand side of Eq. (20) may be defined as

{circumflex over (r)}m={circumflex over (D)}mHŝ+ρ{circumflex over (z)}m  (21)

so that




  
    
      
        
          (
          
            
              
                
                  
                    r
                    ^
                  
                  0
                
              
            
            
              
                
                  
                    r
                    ^
                  
                  1
                
              
            
            
              
                ⋮
              
            
          
          )
        
        =
        
          
            
              
                D
                ^
              
              H
            
            ⁢
            
              s
              ^
            
          
          +
          
            ρ
            ⁢
            
              z
              ^
            
          
        
      
    
    
      
        (
        22
        )
      
    
  




Denoting the nth element of a vector x by x(n) to avoid confusion between indexing of the vectors themselves and selection of elements of these vectors, define




  
    
      
        
          v
          n
        
        =
        
          
            
              (
              
                
                  
                    
                      
                        
                          x
                          ^
                        
                        0
                      
                      ⁡
                      
                        (
                        n
                        )
                      
                    
                  
                
                
                  
                    
                      
                        
                          x
                          ^
                        
                        1
                      
                      ⁡
                      
                        (
                        n
                        )
                      
                    
                  
                
                
                  
                    ⋮
                  
                
              
              )
            
            ⁢
            
              
            
            ⁢
            
              b
              n
            
          
          =
          
            (
            
              
                
                  
                    
                      
                        r
                        ^
                      
                      0
                    
                    ⁡
                    
                      (
                      n
                      )
                    
                  
                
              
              
                
                  
                    
                      
                        r
                        ^
                      
                      1
                    
                    ⁡
                    
                      (
                      n
                      )
                    
                  
                
              
              
                
                  ⋮
                
              
            
            )
          
        
      
    
    
      
        (
        23
        )
      
    
  




and define an as the column vector containing all of the non-zero entities from column n of {circumflex over (D)}H, that is




  
    
      
        
          D
          ^
        
        =
        
          (
          
            
              
                
                  
                    d
                    ^
                  
                  
                    0
                    ,
                    0
                  
                
              
              
                0
              
              
                0
              
              
                ...
              
              
                
                  
                    d
                    ^
                  
                  
                    1
                    ,
                    0
                  
                
              
              
                0
              
              
                0
              
              
                ...
              
            
            
              
                0
              
              
                
                  
                    d
                    ^
                  
                  
                    0
                    ,
                    1
                  
                
              
              
                0
              
              
                ...
              
              
                0
              
              
                
                  
                    d
                    ^
                  
                  
                    1
                    ,
                    1
                  
                
              
              
                0
              
              
                ...
              
            
            
              
                0
              
              
                0
              
              
                
                  
                    d
                    ^
                  
                  
                    0
                    ,
                    2
                  
                
              
              
                ...
              
              
                0
              
              
                0
              
              
                
                  
                    d
                    ^
                  
                  
                    1
                    ,
                    2
                  
                
              
              
                ...
              
            
            
              
                ⋮
              
              
                ⋮
              
              
                ⋮
              
              
                ⋱
              
              
                ⋮
              
              
                ⋮
              
              
                ⋮
              
              
                ⋱
              
            
          
          )
        
      
    
    
      
        (
        24
        )
      
    
  




then




  
    
      
        
          a
          n
        
        =
        
          (
          
            
              
                
                  
                    d
                    ^
                  
                  
                    0
                    ,
                    n
                  
                  *
                
              
            
            
              
                
                  
                    d
                    ^
                  
                  
                    1
                    ,
                    n
                  
                  *
                
              
            
            
              
                ⋮
              
            
          
          )
        
      
    
    
      
        (
        25
        )
      
    
  




where * denotes complex conjugation. The linear system to solve corresponding to an element n of {xm} is

(ananH+ρI)vn=bn  (26)

The independent systems have a left hand side consisting of a diagonal matrix plus a rank-one component, which can be solved very efficiently by the Sherman-Morrison formula




  
    
      
        
          
            (
            
              A
              +
              
                uv
                H
              
            
            )
          
          
            -
            1
          
        
        =
        
          
            A
            
              -
              1
            
          
          -
          
            
              
                A
                
                  -
                  1
                
              
              ⁢
              
                uv
                H
              
              ⁢
              
                A
                
                  -
                  1
                
              
            
            
              1
              +
              
                
                  u
                  H
                
                ⁢
                
                  A
                  
                    -
                    1
                  
                
                ⁢
                v
              
            
          
        
      
    
    
      
        (
        27
        )
      
    
  




which yields




  
    
      
        
          
            (
            
              
                ρ
                ⁢
                
                  
                
                ⁢
                I
              
              +
              
                aa
                H
              
            
            )
          
          
            -
            1
          
        
        =
        
          
            ρ
            
              -
              1
            
          
          ⁡
          
            (
            
              I
              -
              
                
                  aa
                  H
                
                
                  ρ
                  +
                  
                    
                      a
                      H
                    
                    ⁢
                    a
                  
                
              
            
            )
          
        
      
    
    
      
        (
        28
        )
      
    
  




so that the solution to Eq. (26) is




  
    
      
        
          v
          n
        
        =
        
          
            ρ
            
              -
              1
            
          
          ⁡
          
            (
            
              
                b
                n
              
              -
              
                
                  
                    
                      a
                      n
                      H
                    
                    ⁢
                    
                      b
                      n
                    
                  
                  
                    ρ
                    +
                    
                      
                        a
                        n
                        H
                      
                      ⁢
                      
                        a
                        n
                      
                    
                  
                
                ⁢
                
                  a
                  n
                
              
            
            )
          
        
      
    
    
      
        (
        29
        )
      
    
  




The only vector operations are scalar multiplication, subtraction, and inner products, rendering this method (M) instead of (M3) as in Eq. (20). The cost of solving such a system at all N frequency indices is (MN), and the cost of the FFTs is (MN log N). The cost of the FFTs dominates the computational complexity, whereas in Eq. (20), the cost of the solutions of the linear systems in the DFT domain dominates the cost of the FFTs.
This approach can be implemented in an interpreted language such as MatlabTM in a form that avoids explicit iteration (i.e., loops) over the N frequency indices by passing data for all N frequency indices as a single array to the relevant linear-algebraic routines, commonly referred to as “vectorization” in MatlabTM terminology. Some additional computation time improvement is possible, at the cost of additional memory requirements, by precomputing components of Eq. (28), e.g., anH/(ρ+anHan).
ADMM Algorithm Summary for Convolutional BPDN
An ADMM algorithm for Convolutional BPDN according to some embodiments is summarized below. Some typical values for the penalty auto-update parameters in some embodiments are Jp=1, μ=10, and τ=2. A subscript indexed variable written without the superscript denotes the entire set of vectors concatenated as a single vector, e.g., x denotes the vector constructed by concatenating all vectors xm.












Input: image s (N pixels), filter dictionary {dm} (M filters), regularization


parameter λ, initial penalty parameter ρ0, penalty auto-update parameters 


Jp, μ, τ, relaxation parameter α, maximum iterations Jmax, and absolute 


and relative stopping tolerances εabs, εrel


Precompute: ŝ = FFT(s), {circumflex over (D)}m = FFT(dm)∀m


Initialize: ym = ymprev = um = 0 ∀m,ρ = ρ0,j = 1


repeat


 {circumflex over (z)}m = FFT(ym − um) ∀m


 compute {circumflex over (x)}m ∀m as in Eq. (21)-(29)


 xm = IFFT({circumflex over (x)}m)


 xrelax,m = αxm + (1 − α)ym ∀m


 ym =  λ/ρ (xrelax,m + um) ∀m


 um = um + xrelax,m − ym ∀m


 r = ∥x − y∥2


 s = ρ∥yprev − y∥2


 εpri=εabs {square root over (MN)} +εrel max{∥x∥2, ∥y∥2}


 εdua=εabs {square root over (MN)} +εre1 ρ∥u∥2


 ymprev = ym ∀m


 if j ≠ 1 and j mod Jp = 0 then


  if r > μs then


   ρ = τρ


   um = um/τ ∀m


  else if s > μr then


   ρ = ρ/τ


   um = τum ∀m


  end


 end


 j = j + 1


until j > Jmax or (r ≦εpri and s ≦εdua)


Output: coefficient maps ym









The computational cost of the algorithm components is O(MN log N) for the FFTs, order O(MN) for the proposed linear solver, and O(MN) for both the shrinkage and dual variable update. Thus, the entire cost of the algorithm is O(MN log N), dominated by the cost of the FFTs.
In contrast, the cost of the algorithm of Bristow et al. is O(M3N), which tends to be computationally expensive for a practical sized dictionary. There is also a O(MN log N) cost for FFTs under conventional approaches, but it is dominated by the O(M3N) cost of the linear solver, and the cost of the original spatial-domain algorithm in conventional approaches is O(M2N2L), where L is the dimensionality of the filters.
Performance Comparison: Linear Solvers for ADMM
The execution times and solution accuracies of four different methods of solving the linear system are compared in graphs 400, 410, 420, 430 of FIGS. 4A-D, respectively. Computations were performed in both single and double precision arithmetic to allow evaluation of the corresponding execution time and solution accuracy tradeoff. Dictionaries of different sizes were constructed by selecting subsets of a 12×12×512 dictionary (12×12 filters) learned using standard (nonconvolutional) methods, and s was the 512×512 grayscale Lena image. λ was set to 0.01. The solution methods are Gaussian elimination (GE), Conjugate Gradient (CG) with relative residual tolerances of 10−3 and 10−5, and Sherman-Morrison implemented with a loop over each spatial location (SM-L) or jointly over all spatial locations (SM-V). The combined runtime for a forward and inverse FFT is provided as a reference.
After an initial 20 iterations of the ADMM algorithm to avoid any unique characteristics of the linear system directly after initialization of the iterations, the four different methods were used to solve Eq. (20) for the following iteration, recording the time required by each method. Reconstruction error was computed as the relative residual error with which solution {circumflex over (x)} satisfied the linear equation of Eq. (20). The relative residual error of x in the linear equation Ax=b is ∥Ax−b∥2/∥b∥2.
A corresponding comparison for a double precision solution for these systems is presented here in graph 500 of FIG. 5. From the results, it can be seen that the variation in execution times between single and double precision is far smaller than the variation between the different solution methods. SM-V runtime has very small variation with precision, while CG can be almost twice as slow in double precision as in single precision, and GE run time dependence on precision increases with M. The variation in execution times between single and double precision is far smaller than the variation between the different solution methods.
SM-V runtime has very small variation with precision, while CG can be almost twice as slow in double precision as in single precision, and GE runtime dependence on precision increases with M. GE gives solutions accurate to floating point precision, but is the slowest of all the methods, being vastly slower than SM-V, and having much worse scaling with M. CG provides a better accuracy/time trade-off than GE, being substantially faster, while still providing solutions of acceptable accuracy. SM-V is by far the fastest method, giving acceptable solution accuracy in single precision, and very high accuracy in double precision. The negligible variation in run time with precision suggests that use of a double precision solution might be preferred, but empirical evidence (see below) indicates that, in practice, the single precision solution accuracy is sufficient, and gives approximately the same rate of convergence for the ADMM algorithm as double precision solution.
Since these methods all exhibit a different trade-off between accuracy and speed, it is reasonable to investigate what the effect is on algorithm performance. It is not worth expending a large amount of time to compute a very accurate solution since ADMM algorithms only require approximate solutions of each step, but convergence will be slow or unreliable if the solutions are sufficiently inaccurate. The results presented in graph 600 of FIG. 6 show that SM-V gives a faster reduction in functional value with time than CG with any choice of tolerance, even for the smallest M considered in FIGS. 4A-D. The 512×512 grayscale Lena test image was used with a learned 8×8×64 dictionary and λ=0.01.
In an ADMM algorithm such as this, different functional values will be obtained depending on whether the functional values are computed using the primary ({xm}) or auxiliary ({ym}) variable. The auxiliary {ym} is used for the experiments reported here since: (1) {xm} is merely an intermediate result and not part of the algorithm state; and (2) it has been found empirically to give a curve that decays faster and is less subject to oscillations. Smaller CG tolerances than in FIGS. 4A-D are used in FIG. 6 since it is already clear from FIGS. 4A-D that tolerances smaller than 10−3 are not competitive.
In this case, CG with a relative residual tolerance of 10−1 is not much slower than SM-V, but the algorithm does not converge. Larger tolerance values give a more reliable decrease in functional value with each iteration, but are much slower. It should be noted that on a longer timescale than that displayed in FIG. 6, CG with tolerances of 10−2 and 10−3 also begins to exhibit some oscillations. If plotted on the same graph, the double precision SM-V result is indistinguishable from the single precision SM-V result, as shown.
Dictionary Learning
The extension of Eq. (5) to learning a dictionary from training data involves replacing the minimization with respect to xm with minimization with respect to both xm and dm. The optimization is performed via alternating minimization between the two variables, the most common approach consisting of a sparse coding step followed by a dictionary update. The commutativity of convolution suggests that the DFT domain solution discussed above can be directly applied in minimizing with respect to dm instead of xm. However, this is not possible since dm is of constrained size and must be zero-padded to the size of xm prior to a DFT domain implementation of the convolution.
If the size constraint is implemented in an ADMM framework, however, the problem is decomposed into a computationally cheap sub-problem corresponding to a projection onto a constraint set and another sub-problem that can be efficiently solved by extending the approach discussed above. This iterative algorithm for the dictionary update can alternate with a sparse coding stage to form a more traditional dictionary learning method, or the sub-problems of the sparse coding and dictionary update algorithms can be combined into a single ADMM algorithm.
In contrast to standard sparse representations, it is possible to define the convolutional dictionary learning problem in the Single Measurement Vector (SMV) case, but for full generality, it should be construed in the Multiple Measurement Vector (MMV) context. Including the usual constraint on the norm of dictionary elements, the problem can be expressed as




  
    
      
        
          
            
              arg
              ⁢
              
                
              
              ⁢
              min
            
            
              
                {
                
                  d
                  m
                
                }
              
              ,
              
                {
                
                  x
                  
                    k
                    ,
                    m
                  
                
                }
              
            
          
          ⁢
          
            1
            2
          
          ⁢
          
            
              ∑
              k
            
            ⁢
            
              
                
                
                  
                    
                      ∑
                      m
                    
                    ⁢
                    
                      
                        d
                        m
                      
                      *
                      
                        x
                        
                          k
                          ,
                          m
                        
                      
                    
                  
                  -
                  
                    s
                    k
                  
                
                
              
              2
              2
            
          
        
        +
        
          λ
          ⁢
          
            
              ∑
              k
            
            ⁢
            
              
                ∑
                m
              
              ⁢
              
                
                  
                  
                    x
                    
                      k
                      ,
                      m
                    
                  
                  
                
                1
              
            
          
        
      
    
    
      
        (
        30
        )
      
    
  
  
    
      
        
          such
          ⁢
          
            
          
          ⁢
          that
        
        ⁢
        
          

        
        ⁢
        
          
            
              
              
                d
                m
              
              
            
            2
          
          =
          
            1
            ⁢
            
              ∀
              m
            
          
        
      
    
    
      
        (
        31
        )
      
    
  




The standard approach is to solve via alternating minimization with respect to {xk,m} and {dm}. The minimization with respect to {xk,m} involves solving the MMV extension of Convolutional BPDN, which is trivial since the problems for each k are decoupled from one another, but {dm} is more challenging since the problems for different k are coupled.
Ignoring the constraint on the norm of dm, which is usually applied as a post-processing normalization step after the update, the minimization with respect to {dm} can be expressed as




  
    
      
        
          
            arg
            ⁢
            
              
            
            ⁢
            min
          
          
            {
            
              d
              m
            
            }
          
        
        ⁢
        
          1
          2
        
        ⁢
        
          
            ∑
            k
          
          ⁢
          
            
              
              
                
                  
                    ∑
                    m
                  
                  ⁢
                  
                    
                      d
                      m
                    
                    *
                    
                      x
                      
                        k
                        ,
                        m
                      
                    
                  
                
                -
                
                  s
                  k
                
              
              
            
            2
            2
          
        
      
    
    
      
        (
        32
        )
      
    
  




which is a convolutional form of the Method of Optimal Directions (MOD). When computing the convolutions dm*xk,m in the DFT domain, there is an implicit zero-padding of the filters dm to the size of the coefficient maps xk,m. This can be overlooked when minimizing with respect to the coefficient maps, but must be explicitly represented when minimizing with respect to the filters to ensure that the filters resulting from the optimization have an appropriately constrained support in the spatial domain. Defining zero-padding operator P, Eq. (32) can be expressed in the DFT domain as




  
    
      
        
          
            arg
            ⁢
            
              
            
            ⁢
            min
          
          
            {
            
              d
              m
            
            }
          
        
        ⁢
        
          1
          2
        
        ⁢
        
          
            ∑
            k
          
          ⁢
          
            
              
              
                
                  
                    ∑
                    m
                  
                  ⁢
                  
                    
                      (
                                            )
                    
                    ⊙
                    
                      
                        x
                        ^
                      
                      
                        k
                        ,
                        m
                      
                    
                  
                
                -
                
                  
                    s
                    ^
                  
                  k
                
              
              
            
            2
            2
          
        
      
    
    
      
        (
        33
        )
      
    
  




Unfortunately, the spatial-domain operator P does not have a compact representation in the DFT domain, making an efficient direct DFT domain solution impossible. A variable splitting approach, however, makes it possible to solve this problem, including dictionary norm constraints, via an ADMM algorithm.
Constrained MOD Update
The desired filters can be obtained as PTdm after solving the constrained problem




  
    
      
        
          
            
              arg
              ⁢
              
                
              
              ⁢
              min
            
            
              {
              
                d
                m
              
              }
            
          
          ⁢
          
            1
            2
          
          ⁢
          
            
              ∑
              k
            
            ⁢
            
              
                
                
                  
                    
                      ∑
                      m
                    
                    ⁢
                    
                      
                        x
                        
                          k
                          ,
                          m
                        
                      
                      *
                      
                        d
                        m
                      
                    
                  
                  -
                  
                    s
                    k
                  
                
                
              
              2
              2
            
          
        
        ⁢
        
          

        
        ⁢
        
          such
          ⁢
          
            
          
          ⁢
          that
        
        ⁢
        
          

        
        ⁢
        
          
            d
            m
          
          ∈
          
            
              C
              p
            
            ⁢
            
              ∀
              m
            
          
        
      
    
    
      
        (
        34
        )
      
    
  




where the dm have the same spatial support as the xk,m, and

CP={xεN:(I−PPT)x=0}  (35)

Since a constrained problem requiring an iterative solution is being setup, however, it is reasonable to also include the normalization ∥dm∥2=1 or ∥dm∥2≦1 of the dictionary elements that is often, and suboptimally, performed as a postprocessing step after the dictionary update. Including the normalization requirement ∥dm∥2=1, the constraint set becomes

CPN={xεN:(I−PPT)x=0, ∥x∥2=1}  (36)

Employing the indicator function ιCPN of the constraint set CPN, the constrained problem can be written in unconstrained form




  
    
      
        
          
            
              arg
              ⁢
              
                
              
              ⁢
              min
            
            
              {
              
                d
                m
              
              }
            
          
          ⁢
          
            1
            2
          
          ⁢
          
            
              ∑
              k
            
            ⁢
            
              
                
                
                  
                    
                      ∑
                      m
                    
                    ⁢
                    
                      
                        x
                        
                          k
                          ,
                          m
                        
                      
                      *
                      
                        d
                        m
                      
                    
                  
                  -
                  
                    s
                    k
                  
                
                
              
              2
              2
            
          
        
        +
        
          
            ∑
            m
          
          ⁢
          
            
              ι
              
                C
                PN
              
            
            ⁡
            
              (
              
                d
                m
              
              )
            
          
        
      
    
    
      
        (
        37
        )
      
    
  




and rewriting with an auxiliary variable in a form suitable for ADMM gives




  
    
      
        
          
            
              
                arg
                ⁢
                
                  
                
                ⁢
                min
              
              
                {
                
                  d
                  m
                
                }
              
            
            ⁢
            
              1
              2
            
            ⁢
            
              
                ∑
                k
              
              ⁢
              
                
                  
                  
                    
                      
                        ∑
                        m
                      
                      ⁢
                      
                        
                          x
                          
                            k
                            ,
                            m
                          
                        
                        *
                        
                          d
                          m
                        
                      
                    
                    -
                    
                      s
                      k
                    
                  
                  
                
                2
                2
              
            
          
          +
          
            
              ∑
              m
            
            ⁢
            
              
                ι
                
                  C
                  PN
                
              
              ⁡
              
                (
                
                  g
                  m
                
                )
              
            
          
        
        ⁢
        
          

        
        ⁢
        
          such
          ⁢
          
            
          
          ⁢
          that
        
        ⁢
        
          

        
        ⁢
        
          
            
              d
              m
            
            -
            
              g
              m
            
          
          =
          
            0
            ⁢
            
              ∀
              m
            
          
        
      
    
    
      
        (
        38
        )
      
    
  




The indicator function of a set S is defined as




  
    
      
        
          ι
          S
        
        =
        
          {
          
            
              
                0
              
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    X
                  
                  ∈
                  S
                
              
            
            
              
                ∞
              
              
                
                  
                    if
                    ⁢
                    
                      
                    
                    ⁢
                    X
                  
                  ∉
                  S
                
              
            
          
        
      
    
    
      
        (
        39
        )
      
    
  




This problem can be solved via an ADMM algorithm




  
    
      
        
          
            {
            
              d
              m
            
            }
          
          
            (
            
              j
              +
              1
            
            )
          
        
        =
        
          
            
              
                arg
                ⁢
                
                  
                
                ⁢
                min
              
              
                {
                
                  d
                  m
                
                }
              
            
            ⁢
            
              1
              2
            
            ⁢
            
              
                ∑
                k
              
              ⁢
              
                
                  
                  
                    
                      
                        ∑
                        m
                      
                      ⁢
                      
                        
                          x
                          
                            k
                            ,
                            m
                          
                        
                        *
                        
                          d
                          m
                        
                      
                    
                    -
                    
                      s
                      k
                    
                  
                  
                
                2
                2
              
            
          
          +
          
            
              ρ
              2
            
            ⁢
            
              
                ∑
                m
              
              ⁢
              
                
                  
                  
                    
                      d
                      m
                    
                    -
                    
                      g
                      m
                      
                        (
                        j
                        )
                      
                    
                    -
                    
                      h
                      m
                      
                        (
                        j
                        )
                      
                    
                  
                  
                
                2
                2
              
            
          
        
      
    
    
      
        (
        40
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            
              {
              
                g
                m
              
              }
            
            
              (
              
                j
                +
                1
              
              )
            
          
          =
          
            
              
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                
                
                  {
                  
                    g
                    m
                  
                  }
                
              
              ⁢
              
                
                  ∑
                  m
                
                ⁢
                
                  
                    ι
                    
                      C
                      PN
                    
                  
                  ⁡
                  
                    (
                    
                      g
                      m
                    
                    )
                  
                
              
            
            +
            
              
                ρ
                2
              
              ⁢
              
                
                  ∑
                  m
                
                ⁢
                
                  
                    
                    
                      
                        d
                        m
                        
                          (
                          
                            j
                            +
                            1
                          
                          )
                        
                      
                      -
                      
                        g
                        m
                        
                          
                        
                      
                      -
                      
                        h
                        m
                        
                          (
                          j
                          )
                        
                      
                    
                    
                  
                  2
                  2
                
              
            
          
        
      
    
    
      
        (
        41
        )
      
    
  
  
    
      
        
          
        
        ⁢
        
          
            h
            m
            
              (
              
                j
                +
                1
              
              )
            
          
          =
          
            
              h
              m
              
                (
                j
                )
              
            
            +
            
              d
              m
              
                (
                
                  j
                  +
                  1
                
                )
              
            
            -
            
              g
              m
              
                (
                
                  j
                  +
                  1
                
                )
              
            
          
        
      
    
    
      
        (
        42
        )
      
    
  




The {gm} update is of the form




  
    
      
        
          
            
              
                arg
                ⁢
                
                  
                
                ⁢
                min
              
              x
            
            ⁢
            
              1
              2
            
            ⁢
            
              
                
                
                  x
                  -
                  y
                
                
              
              2
              2
            
          
          +
          
            
              ι
              
                C
                PN
              
            
            ⁡
            
              (
              x
              )
            
          
        
        =
        
          
            prox
            
              ι
              
                C
                PN
              
            
          
          ⁡
          
            (
            y
            )
          
        
      
    
    
      
        (
        43
        )
      
    
  




It is clear from the geometry of the problem that




  
    
      
        
          
            
              pro
              ⁢
              x
            
            
              ι
              
                C
                PN
              
            
          
          ⁡
          
            (
            y
            )
          
        
        =
        
          
            
              PP
              T
            
            ⁢
            y
          
          
            
              
              
                
                  PP
                  T
                
                ⁢
                y
              
              
            
            2
          
        
      
    
    
      
        (
        44
        )
      
    
  




or, if the normalization ∥dm∥2≦1 is desired instead,




  
    
      
        
          
            
              pro
              ⁢
              x
            
            
              ι
              
                C
                PN
              
            
          
          ⁡
          
            (
            y
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      PP
                      T
                    
                    ⁢
                    y
                  
                
              
              
                
                  
                    
                      
                        PP
                        T
                      
                      ⁢
                      y
                    
                    
                      
                        
                        
                          
                            PP
                            T
                          
                          ⁢
                          y
                        
                        
                      
                      2
                    
                  
                
              
            
            ⁢
            
              
                
                  
                    
                      if
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                          
                          
                            
                              PP
                              T
                            
                            ⁢
                            y
                          
                          
                        
                        2
                      
                    
                    ≤
                    1
                  
                
              
              
                
                  
                    
                      if
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                          
                          
                            
                              PP
                              T
                            
                            ⁢
                            y
                          
                          
                        
                        2
                      
                    
                    >
                    1
                  
                
              
            
          
        
      
    
    
      
        (
        45
        )
      
    
  




The problem for the {dm} update is of the form




  
    
      
        
          
            
              arg
              ⁢
              
                
              
              ⁢
              min
            
            
              {
              
                d
                m
              
              }
            
          
          ⁢
          
            1
            2
          
          ⁢
          
            
              ∑
              k
            
            ⁢
            
              
                
                
                  
                    
                      ∑
                      m
                    
                    ⁢
                    
                      
                        x
                        
                          k
                          ,
                          m
                        
                      
                      *
                      
                        d
                        m
                      
                    
                  
                  -
                  
                    s
                    k
                  
                
                
              
              2
              2
            
          
        
        +
        
          
            σ
            2
          
          ⁢
          
            
              ∑
              m
            
            ⁢
            
              
                
                
                  
                    d
                    m
                  
                  -
                  
                    z
                    m
                  
                
                
              
              2
              2
            
          
        
      
    
    
      
        (
        46
        )
      
    
  




In the DFT domain, where {circumflex over (X)}k,m=diag({circumflex over (x)}k,m), this becomes




  
    
      
        
          
            
              arg
              ⁢
              
                
              
              ⁢
              min
            
            
              {
              
                d
                m
              
              }
            
          
          ⁢
          
            1
            2
          
          ⁢
          
            
              ∑
              k
            
            ⁢
            
              
                
                
                  
                    
                      ∑
                      m
                    
                    ⁢
                    
                      
                        
                          X
                          ^
                        
                        
                          k
                          ,
                          m
                        
                      
                      *
                      
                        
                          d
                          ^
                        
                        m
                      
                    
                  
                  -
                  
                    
                      s
                      ^
                    
                    k
                  
                
                
              
              2
              2
            
          
        
        +
        
          
            σ
            2
          
          ⁢
          
            
              ∑
              m
            
            ⁢
            
              
                
                
                  
                    
                      d
                      ^
                    
                    m
                  
                  -
                  
                    
                      z
                      ^
                    
                    m
                  
                
                
              
              2
              2
            
          
        
      
    
    
      
        (
        47
        )
      
    
  




Defining




  
    
      
        
          X
          k
        
        =
        
          
            
              (
              
                
                  X
                  
                    k
                    ,
                    0
                  
                
                ⁢
                
                  
                
                ⁢
                
                  X
                  
                    k
                    ,
                    1
                  
                
                ⁢
                
                  
                
                ⁢
                ⋯
              
              ⁢
              
                
              
              )
            
            ⁢
            
              
            
            ⁢
            
              d
              ^
            
          
          =
          
            
              
                (
                
                  
                    
                      
                        
                          d
                          ^
                        
                        0
                      
                    
                  
                  
                    
                      
                        
                          d
                          ^
                        
                        1
                      
                    
                  
                  
                    
                      ⋮
                    
                  
                
                )
              
              ⁢
              
                
              
              ⁢
              
                z
                ^
              
            
            =
            
              (
              
                
                  
                    
                      
                        z
                        ^
                      
                      0
                    
                  
                
                
                  
                    
                      
                        z
                        ^
                      
                      1
                    
                  
                
                
                  
                    ⋮
                  
                
              
              )
            
          
        
      
    
    
      
        (
        48
        )
      
    
  




this problem can be expressed as




  
    
      
        
          
            
              arg
              ⁢
              
                
              
              ⁢
              min
            
            
              d
              ^
            
          
          ⁢
          
            1
            2
          
          ⁢
          
            
              ∑
              k
            
            ⁢
            
              
                
                
                  
                    
                      
                        X
                        ^
                      
                      k
                    
                    ⁢
                    
                      d
                      ^
                    
                  
                  -
                  
                    
                      s
                      ^
                    
                    k
                  
                
                
              
              2
              2
            
          
        
        +
        
          
            σ
            2
          
          ⁢
          
            
              
              
                
                  d
                  ^
                
                -
                
                  z
                  ^
                
              
              
            
            2
            2
          
        
      
    
    
      
        (
        49
        )
      
    
  




with the solution




  
    
      
        
          
            (
            
              
                
                  ∑
                  k
                
                ⁢
                
                  
                    
                      X
                      ^
                    
                    k
                    H
                  
                  ⁢
                  
                    
                      X
                      ^
                    
                    k
                  
                
              
              +
              
                σ
                ⁢
                I
              
            
            )
          
          ⁢
          
            d
            ^
          
        
        =
        
          
            
              ∑
              k
            
            ⁢
            
              
                
                  X
                  ^
                
                k
                H
              
              ⁢
              
                
                  s
                  ^
                
                k
              
            
          
          +
          
            σ
            ⁢
            
              z
              ^
            
          
        
      
    
    
      
        (
        50
        )
      
    
  




This linear system can be solved by iterated application of the Sherman-Morrison formula. The separable components of Eq. (50) are of the form

(J+a0a0H+a1a1H+ . . . +aKaKH)x=b  (51)

Define A0=J and Ak+1=Ak+akakH. Application of the Sherman-Morrison formula yields




  
    
      
        
          A
          
            k
            +
            1
          
          
            -
            1
          
        
        =
        
          
            
              (
              
                
                  A
                  k
                
                +
                
                  
                    a
                    k
                  
                  ⁢
                  
                    a
                    k
                    H
                  
                
              
              )
            
            
              -
              1
            
          
          =
          
            
              A
              k
              
                -
                1
              
            
            -
            
              
                
                  A
                  k
                  
                    -
                    1
                  
                
                ⁢
                
                  a
                  k
                
                ⁢
                
                  a
                  k
                  H
                
                ⁢
                
                  A
                  k
                  
                    -
                    1
                  
                
              
              
                1
                +
                
                  
                    a
                    k
                    H
                  
                  ⁢
                  
                    A
                    k
                    
                      -
                      1
                    
                  
                  ⁢
                  
                    a
                    k
                  
                
              
            
          
        
      
    
    
      
        (
        52
        )
      
    
  




Now define αl,k=Al−1ak and βk=Ak−1b such that α0,k=J−1ak and β0=J−1b, so that




  
    
      
        
          
            
              
                
                  β
                  
                    k
                    +
                    1
                  
                
                =
                
                ⁢
                
                  
                    A
                    k
                    
                      -
                      1
                    
                  
                  ⁢
                  b
                
              
            
          
          
            
              
                
                  =
                  
                  ⁢
                  
                    
                      
                        A
                        k
                        
                          -
                          1
                        
                      
                      ⁢
                      b
                    
                    -
                    
                      
                        
                          
                            A
                            k
                            
                              -
                              1
                            
                          
                          ⁢
                          
                            a
                            k
                          
                          ⁢
                          
                            a
                            k
                            H
                          
                          ⁢
                          
                            A
                            k
                            
                              -
                              1
                            
                          
                          ⁢
                          b
                        
                        
                          1
                          +
                          
                            
                              a
                              k
                              H
                            
                            ⁢
                            
                              A
                              k
                              
                                -
                                1
                              
                            
                            ⁢
                            
                              a
                              k
                            
                          
                        
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        (
                        54
                        )
                      
                    
                  
                
                ⁢
                
                  
                
              
            
          
          
            
              
                
                  =
                  
                  ⁢
                  
                    
                      β
                      k
                    
                    -
                    
                      
                        
                          
                            α
                            
                              k
                              ,
                              k
                            
                          
                          ⁢
                          
                            a
                            k
                            H
                          
                          ⁢
                          
                            
                          
                          ⁢
                          
                            β
                            k
                          
                        
                        
                          1
                          +
                          
                            
                              a
                              k
                              H
                            
                            ⁢
                            
                              α
                              
                                k
                                ,
                                k
                              
                            
                          
                        
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        (
                        55
                        )
                      
                    
                  
                
                ⁢
                
                  
                
              
            
          
        
        ⁢
        
          

        
        ⁢
        and
      
    
    
      
        (
        53
        )
      
    
  
  
    
      
        
          
            
              
                α
                
                  
                    l
                    +
                    1
                  
                  ,
                  k
                
              
              =
              
              ⁢
              
                
                  A
                  
                    l
                    +
                    1
                  
                  
                    -
                    1
                  
                
                ⁢
                
                  a
                  k
                
              
            
          
        
        
          
            
              
                =
                
                ⁢
                
                  
                    
                      A
                      l
                      
                        -
                        1
                      
                    
                    ⁢
                    
                      a
                      k
                    
                  
                  -
                  
                    
                      
                        
                          A
                          l
                          
                            -
                            1
                          
                        
                        ⁢
                        
                          a
                          l
                        
                        ⁢
                        
                          a
                          l
                          H
                        
                        ⁢
                        
                          A
                          l
                          
                            -
                            1
                          
                        
                        ⁢
                        
                          a
                          k
                        
                      
                      
                        1
                        +
                        
                          
                            a
                            l
                            H
                          
                          ⁢
                          
                            A
                            l
                            
                              -
                              1
                            
                          
                          ⁢
                          
                            a
                            k
                          
                        
                      
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      (
                      57
                      )
                    
                  
                
              
              ⁢
              
                
              
            
          
        
        
          
            
              
                =
                
                ⁢
                
                  
                    α
                    
                      l
                      ,
                      k
                    
                  
                  -
                  
                    
                      
                        
                          α
                          
                            l
                            ,
                            l
                          
                        
                        ⁢
                        
                          a
                          l
                          H
                        
                        ⁢
                        
                          
                        
                        ⁢
                        
                          α
                          
                            l
                            ,
                            k
                          
                        
                      
                      
                        1
                        +
                        
                          
                            a
                            l
                            H
                          
                          ⁢
                          
                            α
                            
                              l
                              ,
                              k
                            
                          
                        
                      
                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      (
                      58
                      )
                    
                  
                
              
              ⁢
              
                
              
            
          
        
      
    
    
      
        (
        56
        )
      
    
  




An iterative algorithm to compute the solution for the system of Eq. (51), given by βK, may be derived from these equations. An algorithm for solving Eq. (51) when J=ρI is presented below.













 
Input: vectors {ak}, parameter ρ



Initialize: α = ρ−1a0, β = ρ−1b



for k ε {1 . . . K}do



 



  
    γ
    
      k
      -
      1
    
  
  =
  
    α
    
      1
      +
      
        
          a
          
            k
            -
            1
          
          H
        
        ⁢
        α
      
    
  







 β = β − γk−1aHk−1β



 if k ≦ K − 1 then



  α = ρ−1ak



  for l ε {1 . . . K}do



   α = α − γl−1aHl−1α



  end



 end



end



Output: linear equation solution β









Alternatively, other equivalent solutions for iterative application of the Sherman-Morrison formula may be applied, such as that proposed by N. Egidi and P. Maponi in “A Sherman-Morrison Approach to the Solution of Linear Systems,” Journal of Computational and Applied Mathematics, vol. 189, no. 1-2, pp. 703-718 (May 2006).
Interleaved xk,m and dm Updates
Given iterative algorithms for the xk,m and dm updates (i.e., the ADMM algorithms for Convolutional BPDN and Constrained MOD respectively), the immediate question is how these should be combined into a full dictionary learning algorithm. The standard approach is to alternate between sparse coding and dictionary update, solving the sparse coding problem with reasonable accuracy before moving on to the dictionary update. Since each sub-problem is an iterative algorithm, this would entail performing multiple iterations of each sub-problem before switching to the other. A reasonable strategy is to maintain the auxiliary variables for each sub-problem across the top-level iterations since performing a cold start at each switch of sub-problems would entail substantially reduced efficiency. The necessity of retaining these variables, in turn, suggests interleaving the ADMM iterations for each sub-problem into a single set of iterations, rather than combining the xk,m and dm updates in a way that treats each as a single functional unit. This general strategy, of interleaving the algorithms for sparse code and dictionary updates, has previously been proposed, but with substantially different algorithms for each update. A single iteration of the resulting algorithm consists of updates Eq. (11), (12), (13), (40), (41), and (42) in sequence.
The most obvious way of combining these updates is to transfer the primary variables across to the other update steps, i.e., dm represent the dictionary in the sparse coding steps and xk,m represent the sparse code in the dictionary update steps. Such a combination turns out to be quite unstable in practice, with convergence being very sensitive to suitable choices of the ρ and σ parameters for each update. A far more stable algorithm is obtained if the updates are interleaved on their auxiliary variables, i.e., gm represent the dictionary in the sparse coding steps, and yk,m represent the sparse code in the dictionary update steps. It is worth noting that such a combination is not derivable from single Augmented Lagrangian functional. Additional differences in derivation and algorithm from Bristow et al. include that the Augmented Lagrangian is constructed using a mixture of spatial and frequency domain variables, while the derivation presented here presents the problem in the spatial domain, switching into the frequency domain where appropriate for efficient solution of relevant sub-problems. Also, the ADMM algorithm from Bristow et al. is derived in unscaled rather than scaled form. These choices appear to lead to a slightly more complicated path to deriving solutions to at least one of the sub-problems.
Dictionary Learning Algorithm Summary
The entire algorithm for Convolutional BPDN, including dictionary learning, in some embodiments is summarized below. A subscript indexed variable written without the subscript denotes the entire set of vectors concatenated as a single vector, e.g., x denotes the vector constructed by concatenating all vectors xk,m.












Input: images sk (K images of N pixels each), initial dictionary d0m


(M filters), regularization parameter λ, initial penalty parameters σ0, ρ0,


penalty auto-update parameters Jx,p, μx, τx, Jd,p, μd, τd, relaxation para-


meters αx, αd, maximum iterations Jmax, and absolute and relative


stopping tolerances εabs, εrel


Precompute: ŝk = FFT(sk) ∀k


Initialize: ykm = yprevk,m = uk,m = 0 ∀k, m hm = 0 gprevm = d0m ∀m,ρ =


ρ0, σ = σ0, j = 1


repeat


 ĝm = FFT(gm) ∀m


 {circumflex over (z)}k,m = FFT(yk,m − uk,m) ∀k,m


 Compute {circumflex over (x)}k,m ∀k,m as in Eq. (16)-(29) using ĝk,m as the dictionary


 xk,m = IFFT({circumflex over (x)}k,m)


 xrelax,k,m = αxxk,m + (1 − αx)yk,m ∀k,m


 yk,m =  λ/ρ(xrelax,k,m + uk,m) ∀k,m


 uk,m = uk,m + xrelax,k,m − yk,m ∀k,m


 ŷk,m = FFT(yk,m) ∀k,m


 {circumflex over (z)}m = FFT(gm − hm) ∀m


 Compute {circumflex over (d)}m ∀m as in Eq. (46)-(58) using ŷk,m as the coefficient maps


 dm = IFFT({circumflex over (d)}m)


 drelax,m = αddm + (1 − αd)gm ∀m


 



  
    g
    m
  
  =
  
    
      
        prox
        
          ι
          
            C
            PN
          
        
      
      ⁡
      
        (
        
          
            d
            
              relax
              ,
              m
            
          
          +
          
            h
            m
          
        
        )
      
    
    ⁢
    
      ∀
      m
    
  






 hm = hm + drelax,m − xm ∀m


 rx = ||x − y||2


 sx = ρ||yprev − y||2


 rd = ||d − g||2


 sd = σ||gprev − g||2


 εx,pri =εabs {square root over (KMN)} +εrel max{||x||2, ||y||2}


 εx,dua =εabs {square root over (KMN)} +εrel ρ||u||2


 εd,pri =εabs {square root over (MN)} +εrel max{||d||2, ||g||2}


 εd,dua =εabs {square root over (MN)} +εrel σ||h||2


 yprevm = ym ∀m


 gprevm = gm ∀m


 if j ≠ 1 and j mod Jx,p = 0 then


  if rx > μxsx then


   ρ = τxρ


   um = um/τx ∀m


  else if sx > μxrx then


   ρ = ρ/τx


   um = τxum ∀m


  end


 end


 if j ≠ 1 and j mod Jd,p = 0 then


  if rd > μdsd then


   σ = τdσ


   hm = hm/τd ∀m


  else if sd > μdrd then


   σ = σ/τd


   hm = τdhm ∀m


  end


 end


until  j > Jmax or (rx εx,pri and sx ≦ εx,dua and rd εd,pri and sd ≦


εd,dua)


Output: Dictionary {gm}, coefficient maps {ym}









The effects of different algorithm parameters are explored in graph 700 of FIG. 7. In FIG. 7, the dictionary was 8×8×64 with Gaussian random initialization and the training data was a set of five 256×256 images from the MIRFlickr dataset. In FIG. 7, λ=0.1 and ρ0=10.5. Penalty auto-update parameters for the curves for which the automatic adaptation was active were Jx,p=Jd,p=10, μx=μd=10, and τx=τd=2, and relaxation parameters were αx=αd=1.8. σ0=5 with automatic adaptation gives the best overall performance. Performance varies widely for different values of σ0 when σ is fixed, but the effect of σ0 is small when automatic adaptation is enabled. It should be noted that the apparent relative differences between these curves are exaggerated by the scaling of the vertical axis. If the vertical axis were expanded to include the entire range of functional values, most of these differences would be observed to be relatively small, with no perceptible difference between any of the curves beyond 2000 iterations except for “σ=5×102 fixed” and “σ=5×103 fixed”. It should also be noted that the effect of parameter σ scales linearly with the number of training images K so that σ0≈K is a reasonable choice when applying the same parameters to a training set of a different size than the K=5 in this experiment.
Performance Comparison: Linear Solvers for ADMM
The execution times and solution accuracies of three different methods of solving the linear system are compared in graphs 800, 810, 900, 910 of FIGS. 8A, 8B, 9A, and 9B, respectively. Dictionaries D of different sizes M were constructed by initializing with Gaussian random dictionaries of the appropriate sizes, and the different training image sets S of size K were selected from a set of 256×256 training images derived from the MIRFlickr dataset. After an initial 20 iterations of the ADMM algorithm, the different methods were used to solve Eq. (50) for the following iteration, recording the time required by each. Reconstruction error was computed as the relative residual error with which solution {circumflex over (d)} satisfies the linear equation of Eq. (50).
From these results, it can be seen that the CG 10−1 method is by far the fastest, but the solution accuracy is inadequate. The CG 10−5 method has similar solution accuracy to SM, but is substantially slower for small K values. In the sparse coding problem, the SM solution greatly outperforms the alternatives, but that is not always the case here, with other methods, including GE, becoming competitive for larger K values. This is not surprising since GE has a (KM3N) cost, while SM has a (K2MN) cost.
The effects of the different tradeoffs between time and accuracy represented by the different solution methods can only be evaluated by comparing performance within a number of iterations of the full dictionary learning algorithm. Such a comparison was performed using the same dictionary size, value, and training data (with K=32) as for the experiments above, the results being presented in graph 1000 of FIG. 10. The double precision SM result is not shown since it would be indistinguishable from the single precision version on this graph. For this experiment, the maximum fractional difference between the two, occurring within the first few iterations, is 3.3×10−5, and the median is 3.8×10−6. Thus, double precision SM gives effectively the same solution, but at the cost of doubling the memory requirements and running approximately 30% slower than single precision. Since CG with a sufficiently large tolerance gives approximately the same solution accuracy independent of precision at an even greater computation time penalty, double precision CG is also not a useful option.
In addition to three different CG tolerances, these experiments also include an automatic CG tolerance method that starts with a tolerance of 10−1 at each iteration setting the CG tolerance to 1/20 times the primal residual for the dm update if that quantity is smaller than the current tolerance. In this experiment, the auto-tolerance method is quite competitive, giving the overall best performance in terms of functional value reduction with time. In contrast, the best reduction with respect to the number of iterations is provided by SM and CG 10−3.
Multi-Scale Dictionaries
Prior methods all have structural constraints that are either imposed by the properties of the transform domain within which the sparse representation is computed or from the quadtree spatial structure imposed on the dictionary. This ultimately results from the difficulty of applying a multi-scale dictionary in a natural way within a patch-based framework.
In the convolutional sparse representation framework, in contrast, there is no reason why the dictionary filters should be of the same size, and multi-scale dictionaries can be defined in a natural way, without any structural constraints on their form. An example of this shown in image 1100 of FIG. 11. Learning of such dictionaries is no more difficult than learning a single-scale dictionary, simply by replacing P with Pm in Eq. (33), (35), (36), (44), and (45). Nonetheless, the learning and use of multi-scale convolutional dictionaries has not previously been considered in imaging applications, and has only received very limited attention in a signal processing context. For instance, the possibility of using filters of different lengths has been identified, but not discussed in any detail.
The potential advantage of a multi-scale dictionary is demonstrated by some simple experiments. A set of five different dictionaries, all with 72 filters, was learned using the same set of 16 images, and then used to solve the Convolutional BPDN problem using a separate set of 16 images as a test set. A corresponding experiment was also performed using a set of four dictionaries, all with 96 filters, trained on the same set of 32 images and tested on the same set of 23 images. The results in Table 1 show that a multi-scale dictionary can provide a lower cost representation than a single-scale dictionary with the same number of filters of the same size as one of the filter sizes in the multi-scale dictionary. More specifically, Table 1 shows a comparison of functional values for the Convolutional BPDN problem computed with λ=0.01 for the same set of images and with different dictionaries. The comparison in the upper rows was computed on the same set of 16 images and the comparison in the lower rows was computed with the same set of 23 images.







TABLE 1







SAME SET OF 16 IMAGES












Dict.
8 × 8 × 72
12 × 12 × 72
8 × 8 × 24,
16 × 16 × 72
8 × 8 × 24,





12 × 12 × 48

16 × 16 × 48


Func.
4.96 × 102
4.81 × 102
4.79 × 102
4.79 × 102
4.76 × 102







SAME SET OF 23 IMAGES












Dict.
8 × 8 × 96
12 × 12 × 96
16 × 16 × 96
8 × 8 × 16,
N/A






12 × 12 × 32,






16 × 16 × 48


Func.
9.02 × 102
8.86 × 102
8.88 × 102
8.79 × 102
N/A









FIG. 12 is a flowchart 1200 illustrating a process for solving the convolutional sparse coding problem in the Fourier domain, according to an embodiment of the present invention. In some embodiments, the process of FIG. 12 may be executed, for example, by computing system 1400 of FIG. 14. The process begins with receiving input data at 1205. The input data includes an image s, a filter dictionary {dm}, and parameters λ and ρ, as discussed above. The FFTs {{circumflex over (D)}m} of the dictionary {dm} and ŝ of the image s are precomputed at 1210. Auxiliary variables are initialized to 0 at 1215, such that {ym}={um}=0.
After initialization and precomputing of the FFTs, it is determined whether stopping criteria are met at 1220. These stopping criteria are described in more detail in S. Boyd, N. Parikh, E. Chu, B. Peleato, and J. Eckstein, “Distributed Optimization and Statistical Learning via the Alternating Direction Method of Multipliers,” Foundations and Trends in Machine Learning, vol. 3, no. 1, pp. 1-122 (2010). If the stopping criteria are met at 1220, the coefficient maps {ym} are output at 1255 and the process ends.
However, if the stopping criteria are not met at 1220, the FFTs {ŷm} of auxiliary variables {ym} and {ûm} of dual variables {um} are computed at 1825. The coefficient maps are computed in the frequency domain at 1230 using Eq. (21-29). The inverse FFTs {xm} of the frequency domain coefficient maps {{circumflex over (x)}m} are then computed at 1235.
{ym} is calculated at 1240 using Eq. (14) and {um} is calculated at 1245 using Eq. (13). ρ is updated at 1250 if appropriate depending on the selected standard update strategy. The process then returns to 1220 and repeats in this manner until the stopping criteria are met.
FIG. 13 is a flowchart 1300 illustrating a process for fast dictionary learning, according to an embodiment of the present invention. Per the above, since the constrained problem in this case requires an iterative solution, the normalization ∥dm∥2=1 or ∥dm∥2≦1 of the dictionary elements is included, rather than performing the normalization as a postprocessing step after the dictionary update.
A novel aspect of the dictionary learning of some embodiments is in using the iterated Sherman-Morrison algorithm for the dictionary update. For a relatively small number of training images K, this is considerably faster than previous methods for solving this update. For instance, if K=1, this approach may be 10 times faster than other methods, but this also depends on other factors, such as the size of the dictionary. As K becomes larger, the performance improvement decreases, and is eventually overtaken by standard methods of solving a linear system, such as Conjugate Gradient and Gaussian Elimination. More specifically, as K increases, the advantage is slowly reduced, with very limited advantage remaining by K=32. If the dictionary is smaller (i.e., M is smaller), this point will be reached at a smaller K, and conversely, if M is larger, at a larger K.
Another novel aspect of some embodiments is in the interleaving between sparse coding and dictionary updates in the dictionary learning algorithm above. Bristow et al. used dm as the dictionary in the sparse coding stage and xk,m as the sparse representation in the dictionary update stage. Such a combination turns out to be quite unstable in practice. However, the algorithm is much more stable if g and y, respectively, are used for these two stages.
The process begins with computing ĝm ∀m as in Eq. (46)-(50) using ŷk,m as the coefficient maps and using the iterated Sherman-Morrison algorithm for the dictionary update at 1310. Updates on sparse coding and dictionary learning are interleaved at 1320 such that gm represent the dictionary in the sparse coding steps, and yk,m represent the sparse code in the dictionary update steps. If stopping tolerances are met at 1330, the process proceeds to outputting the dictionary {gm} and coefficient maps {ym} at 1340. Otherwise, the process returns to 1310.
FIG. 14 is a block diagram of a computing system 1400 configured to perform fast dictionary learning and solve the convolutional sparse coding problem in the Fourier domain, according to an embodiment of the present invention. Computing system 1400 includes a bus 1405 or other communication mechanism for communicating information, and processor(s) 1410 coupled to bus 1405 for processing information. Processor(s) 1410 may be any type of general or specific purpose processor, including a central processing unit (“CPU”) or application specific integrated circuit (“ASIC”). Processor(s) 1410 may also have multiple processing cores, and at least some of the cores may be configured to perform specific functions. Multi-parallel processing may be used in some embodiments. Computing system 1400 further includes a memory 1415 for storing information and instructions to be executed by processor(s) 1410. Memory 1415 can be comprised of any combination of random access memory (RAM), read only memory (ROM), flash memory, cache, static storage such as a magnetic or optical disk, or any other types of non-transitory computer-readable media or combinations thereof. Additionally, computing system 1400 includes a communication device 1420, such as a transceiver and antenna, to wirelessly provide access to a communications network.
Non-transitory computer-readable media may be any available media that can be accessed by processor(s) 1410 and may include both volatile and non-volatile media, removable and non-removable media, and communication media. Communication media may include computer-readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media.
Processor(s) 1410 are further coupled via bus 1405 to a display 1425, such as a Liquid Crystal Display (LCD), for displaying information to a user. A keyboard 1430 and a cursor control device 1435, such as a computer mouse, are further coupled to bus 1405 to enable a user to interface with computing system. However, in certain embodiments such as those for mobile computing implementations, a physical keyboard and mouse may not be present, and the user may interact with the device solely through display 1425 and/or a touchpad (not shown). Any type and combination of input devices may be used as a matter of design choice.
Memory 1415 stores software modules that provide functionality when executed by processor(s) 1410. The modules include an operating system 1440 for computing system 1400. The modules further include a modified ADMM module 1445 that is configured to perform fast dictionary learning and solve the convolutional sparse coding problem in the Fourier domain. Computing system 1400 may include one or more additional functional modules 1450 that include additional functionality.
One skilled in the art will appreciate that a “system” could be embodied as an embedded computing system, a personal computer, a server, a console, a personal digital assistant (PDA), a cell phone, a tablet computing device, or any other suitable computing device, or combination of devices. Presenting the above-described functions as being performed by a “system” is not intended to limit the scope of the present invention in any way, but is intended to provide one example of many embodiments of the present invention. Indeed, methods, systems and apparatuses disclosed herein may be implemented in localized and distributed forms consistent with computing technology, including cloud computing systems.
It should be noted that some of the system features described in this specification have been presented as modules, in order to more particularly emphasize their implementation independence. For example, a module may be implemented as a hardware circuit comprising custom very large scale integration (“VLSI”) circuits or gate arrays, off-the-shelf semiconductors such as logic chips, transistors, or other discrete components. A module may also be implemented in programmable hardware devices such as field programmable gate arrays, programmable array logic, programmable logic devices, graphics processing units, or the like.
A module may also be at least partially implemented in software for execution by various types of processors. An identified unit of executable code may, for instance, comprise one or more physical or logical blocks of computer instructions that may, for instance, be organized as an object, procedure, or function. Nevertheless, the executables of an identified module need not be physically located together, but may comprise disparate instructions stored in different locations which, when joined logically together, comprise the module and achieve the stated purpose for the module. Further, modules may be stored on a computer-readable medium, which may be, for instance, a hard disk drive, flash device, RAM, tape, or any other such medium used to store data.
Indeed, a module of executable code could be a single instruction, or many instructions, and may even be distributed over several different code segments, among different programs, and across several memory devices. Similarly, operational data may be identified and illustrated herein within modules, and may be embodied in any suitable form and organized within any suitable type of data structure. The operational data may be collected as a single data set, or may be distributed over different locations including over different storage devices, and may exist, at least partially, merely as electronic signals on a system or network.
The process steps performed in FIGS. 12 and 13 may be performed by a computer program, encoding instructions for the nonlinear adaptive processor to perform at least the processes described in FIGS. 12 and 13, in accordance with embodiments of the present invention. The computer program may be embodied on a non-transitory computer-readable medium. The computer-readable medium may be, but is not limited to, a hard disk drive, a flash device, a random access memory, a tape, or any other such medium used to store data. The computer program may include encoded instructions for controlling the nonlinear adaptive processor to implement the processes described in FIGS. 12 and 13, which may also be stored on the computer-readable medium.
The computer program can be implemented in hardware, software, or a hybrid implementation. The computer program can be composed of modules that are in operative communication with one another, and which are designed to pass information or instructions to display. The computer program can be configured to operate on a general purpose computer, or an ASIC.
Some embodiments pertain to computationally efficient algorithms for fast dictionary learning and solving the convolutional sparse coding problem in the Fourier domain. Such algorithms may enable a significant reduction in computational cost over conventional approaches by implementing a linear solver for the most critical and computationally expensive component of the conventional iterative algorithm. At a high level, the derivation of ADMM algorithms for convolutional sparse coding and the dictionary update for dictionary learning is relatively straightforward, but correct choice of methods for solving the linear sub-problems is critical to the design of efficient algorithms, with vastly inferior computational performance resulting if these methods are not properly chosen. The results presented herein show that the proposed Sherman-Morrison solution of the main linear system is clearly the best choice for the Convolutional BPDN sparse coding problem, giving much better asymptotic performance of (M) instead of (M3), as obtained by a previous direct method. Also. The Sherman-Morrison solution is much faster in practical application. Furthermore, over-relaxation methods are shown to improve performance, and effective heuristic techniques for selection of the penalty parameter are presented. The resulting ADMM algorithm has been shown to be much faster than a previously proposed Fast Iterative Shrinkage-Thresholding Algorithm (FISTA) approach, and faster to varying degrees depending on the regularization parameter when the gradient required by FISTA is computed in the DFT domain.
In the case of Convolutional BPDN dictionary learning, an iterated Sherman-Morrison solution of the main linear system in the dictionary update stage is the best choice for a small number of training images K, but other methods become competitive for larger K. Overall, a CG solution with a moderate accuracy tolerance or with an adaptive tolerance appears to be the best choice when K is large. It is also demonstrated that the proposed dictionary learning algorithm can be used to construct convolutional multi-scale dictionaries that do not have any of the structural constraints or complications inherent in previous approaches to constructing multi-scale dictionaries within the standard patch-based framework.
It will be readily understood that the components of various embodiments of the present invention, as generally described and illustrated in the figures herein, may be arranged and designed in a wide variety of different configurations. Thus, the detailed description of the embodiments of the present invention, as represented in the attached figures, is not intended to limit the scope of the invention as claimed, but is merely representative of selected embodiments of the invention.
The features, structures, or characteristics of the invention described throughout this specification may be combined in any suitable manner in one or more embodiments. For example, reference throughout this specification to “certain embodiments,” “some embodiments,” or similar language means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the present invention. Thus, appearances of the phrases “in certain embodiments,” “in some embodiment,” “in other embodiments,” or similar language throughout this specification do not necessarily all refer to the same group of embodiments and the described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.
It should be noted that reference throughout this specification to features, advantages, or similar language does not imply that all of the features and advantages that may be realized with the present invention should be or are in any single embodiment of the invention. Rather, language referring to the features and advantages is understood to mean that a specific feature, advantage, or characteristic described in connection with an embodiment is included in at least one embodiment of the present invention. Thus, discussion of the features and advantages, and similar language, throughout this specification may, but do not necessarily, refer to the same embodiment.
Furthermore, the described features, advantages, and characteristics of the invention may be combined in any suitable manner in one or more embodiments. One skilled in the relevant art will recognize that the invention can be practiced without one or more of the specific features or advantages of a particular embodiment. In other instances, additional features and advantages may be recognized in certain embodiments that may not be present in all embodiments of the invention.
One having ordinary skill in the art will readily understand that the invention as discussed above may be practiced with steps in a different order, and/or with hardware elements in configurations which are different than those which are disclosed. Therefore, although the invention has been described based upon these preferred embodiments, it would be apparent to those of skill in the art that certain modifications, variations, and alternative constructions would be apparent, while remaining within the spirit and scope of the invention. In order to determine the metes and bounds of the invention, therefore, reference should be made to the appended claims.

## Claims

1. A computer-implemented method, comprising:
deriving efficient convolutional sparse coding in a frequency domain, by a computing system, within an alternating direction method of multipliers (ADMM) framework using fast Fourier transforms (FFTs);
determining, by the computing system, coefficient maps of a signal or image vector s using the derived efficient convolutional sparse coding; and
when stopping criteria are met, outputting the coefficient maps, by the computing system, as a sparse representation of s.

2. The computer-implemented method of claim 1, wherein the coefficient maps are determined with an efficiency of O(MN log N), where N is a dimensionality of the data and M is a number of elements in a dictionary.

3. The computer-implemented method of claim 1, wherein the coefficient maps are computed using only inner products, element-wise addition, and scalar multiplication as vector operations.

4. The computer-implemented method of claim 1, further comprising:
precomputing, by the computing system, FFTs of a dictionary D and the signal or image vector s.

5. The computer-implemented method of claim 1, further comprising:
initializing auxiliary variables, by the computing system, to zero.

6. The computer-implemented method of claim 1, wherein while the stopping criteria have not been met, the method further comprises:
computing, by the computing system, FFTs of auxiliary variables, frequency domain coefficient maps, inverse FFTs of the coefficient maps, and calculating the auxiliary variables; and
updating auxiliary parameter ρ when convergence to a desired accuracy has not occurred.

7. The computer-implemented method of claim 1, wherein the computing system determines a set of coefficient maps in the frequency domain by




  
    v
    n
  
  =
  
    
      
        ρ
        
          -
          1
        
      
      ⁡
      
        (
        
          
            b
            n
          
          -
          
            
              
                
                  a
                  n
                  H
                
                ⁢
                
                  b
                  n
                
              
              
                ρ
                +
                
                  
                    a
                    n
                    H
                  
                  ⁢
                  
                    a
                    n
                  
                
              
            
            ⁢
            
              a
              n
            
          
        
        )
      
    
    .

8. The computer-implemented method of claim 1, further comprising:
learning a dictionary D from a set of training data, wherein a FFT of D yields a dictionary in the frequency domain {circumflex over (D)} such that





  
    D
    ^
  
  =
  
    (
    
      
        
          
            
              d
              ^
            
            
              0
              ,
              0
            
          
        
        
          0
        
        
          0
        
        
          ⋯
        
        
          
            
              d
              ^
            
            
              1
              ,
              0
            
          
        
        
          0
        
        
          0
        
        
          ⋯
        
      
      
        
          0
        
        
          
            
              d
              ^
            
            
              0
              ,
              1
            
          
        
        
          0
        
        
          ⋯
        
        
          0
        
        
          
            
              d
              ^
            
            
              1
              ,
              1
            
          
        
        
          0
        
        
          ⋯
        
      
      
        
          0
        
        
          0
        
        
          
            
              d
              ^
            
            
              0
              ,
              2
            
          
        
        
          ⋯
        
        
          0
        
        
          0
        
        
          
            
              d
              ^
            
            
              1
              ,
              2
            
          
        
        
          ⋯
        
      
      
        
          ⋮
        
        
          ⋮
        
        
          ⋮
        
        
          ⋱
        
        
          ⋮
        
        
          ⋮
        
        
          ⋮
        
        
          ⋱
        
      
    
    )
  




where {circumflex over (D)} is concatenated as a set of block matrices and each block matrix is a diagonal.

9. The computer-implemented method of claim 8, wherein D is a multi-scale dictionary.

10. The computer-implemented method of claim 1, further comprising:
computing, by the computing system, a dictionary in a frequency domain ĝm ∀m using ŷk,m as coefficient maps and using an iterated Sherman-Morrison algorithm for a dictionary update; and
outputting, by the computing system, a dictionary {gm} when stopping tolerances are met.

11. The computer-implemented method of claim 10, further comprising:
interleaving, by the computing system, updates on sparse coding and dictionary learning such that gm represents the dictionary in sparse coding steps and yk,m represent sparse coding in dictionary steps; and
outputting, by the computing system, coefficient maps {ym} when the stopping tolerances are met.