A S IMPLE S PARSE D ENOISING L AYER FOR R OBUST D EEP L EARNING
Anonymous authors
Paper under double-blind review
A BSTRACT
Deep models have achieved great success in many applications.
However, vanilla deep models are not well-designed against the input perturbation.
In this work, we take an initial step to design a simple robust layer as a lightweight plug-in for vanilla deep models.
To achieve this goal, we ﬁrst propose a fast sparse coding and dictionary learning algorithm for sparse coding problem with an exact k -sparse constraint or l 0 norm regularization.
Our method comes with a closedform approximation for the sparse coding phase by taking advantage of a novel structured dictionary.
With this handy approximation, we propose a simple sparse denoising layer (SDL) as a lightweight robust plug-in.
Extensive experiments on both classiﬁcation and reinforcement learning tasks manifest the effectiveness of our methods.
I NTRODUCTION
Deep neural networks have obtained a great success in many applications, including computer vision, reinforcement learning (RL) and natural language processing, etc.
However, vanilla deep models are not robust to noise perturbations of the input.
Even a small perturbation of input data would dramatically harm the prediction performance (Goodfellow et al., 2015).
To address this issue, there are three mainstreams of strategies: data argumentation based learning methods (Zheng et al., 2016;
Ratner et al., 2017; Madry et al., 2018; Cubuk et al., 2020), loss functions/regularization techniques (Elsayed et al., 2018; Zhang et al., 2019), and importance weighting of network architecture against noisy input perturbation.
Su et al.
(2018) empirically investigated 18 deep classiﬁcation models.
Their studies found that model architecture is a more critical factor to robustness than the model size.
Most recently, Guo et al.
(2020) employed a neural architecture search (NAS) method to investigate the robust architectures.
However, the NAS-based methods are still very computationally expensive.
Furthermore, their resultant model cannot be easily adopted as a plug-in for other vanilla deep models.
A handy robust plug-in for backbone models remains highly demanding.
In this work, we take an initial step to design a simple robust layer as a lightweight plug-in for the vanilla deep models.
To achieve this goal, we ﬁrst propose a novel fast sparse coding and dictionary learning algorithm.
Our algorithm has a closed-form approximation for the sparse coding phase, which is cheap to compute compared with iterative methods in the literature.
The closedform update is handy for the situation that needs fast computation, especially in the deep learning.
Based on this, we design a very simple sparse denoising layer for deep models.
Our SDL is very ﬂexible, and it enables an end-to-end training.
Our SDL can be used as a lightweight plug-in for many modern architecture of deep models (e.g., ResNet and DenseDet for classiﬁcation and deep
PPO models for RL).
Our contributions are summarized as follows:
• We propose simple sparse coding and dictionary learning algorithms for both k-sparse constrained sparse coding problem and l 0 -norm regularized problem.
Our algorithms have simple approximation form for the sparse coding phase.
• We introduce a simple sparse denoising layer (SDL) based on our handy update.
Our SDL involves simple operations only, which is a fast plug-in layer for end-to-end training.
• Extensive experiments on both classiﬁcation tasks and reinforcement learning tasks show the effectiveness of our SDL.
R ELATED W ORKS
Sparse Coding and Dictionary Learning: Sparse coding and dictionary learning are widely studied in computer vision and image processing.
One related popular method is K-SVD (Elad &
Aharon, 2006; Rubinstein et al., 2008), it jointly learns an over-complete dictionary and the sparse representations by minimizing a l 0 -norm regularized reconstruction problem.
Speciﬁcally, K-SVD alternatively iterates between the sparse coding phase and dictionary updating phase.
The both steps are based on heuristic greedy methods.
Despite its good performance, K-SVD is very computationally demanding.
Moreover, as pointed out by Bao et al.
(2013), both the sparse coding phase and dictonary updating of K-SVD use some greedy approaches that lack rigorous theoretical guarantee on its optimality and convergence.
Bao et al.
(2013) proposed to learn an orthogonal dictionary instead of the over-complete one.
The idea is to concatenate the free parameters with predeﬁned ﬁlters to form an orthogonal dictionary.
This trick reduces the time complexity compared with KSVD.
However, their algorithm relies on the predeﬁned ﬁlters.
Furthermore, the alternative descent method heavily relies on SVD, which is not easy to extend to deep models.
In contrast, our method learns a structured over-complete dictionary, which has a simple form as a layer for deep learning.
Recently, some works (Venkatakrishnan et al., 2013) employed deep neural networks to approximate alternating direction method of multipliers (ADMM) or other proximal algorithms for image denoising tasks.
In (Wei et al., 2020), reinforcement learning is used to learn the hyperparameters of these deep iterative models.
However, this kind of method itself needs to train a complex deep model.
Thus, they are computationally expensive, which is too heavy or inﬂexible as a plug-in layer for backbone models in other tasks instead of image denoising tasks, e.g., reinforcement learning and multi-class classiﬁcation, etc.
An illustration of number of parameters of SDL, DnCNN (Zhang et al., 2017) and PnP (Wei et al., 2020) are shown in Table 1.
SDL has much less parameters and simpler structure compared with DnCNN and PnP, and it can serve as a lightweight plug-in for other tasks, e.g., RL.
[Table]
Robust Deep Learning: In the literature of robust deep learning, several robust losses have been studied.
To achieve better generalization ability, Elsayed et al.
(2018) proposed a loss function to impose a large margin of any chosen layers of a deep network.
Barron (2019) proposed a general loss with a shape parameter to cover several robust losses as special cases.
For the problems with noisy input perturbation, several data argumentation-based algorithms and regularization techniques are proposed (Zheng et al., 2016; Ratner et al., 2017; Cubuk et al., 2020; Elsayed et al., 2018; Zhang et al., 2019).
However, the network architecture remains less explored to address the robustness of the input perturbation.
Guo et al.
(2020) employed NAS methods to search the robust architectures.
However, the searching-based method is very computationally expensive.
The resultant architectures cannot be easily used as a plug-in for other popular networks.
In contrast, our SDL is based on a closed-form of sparse coding, which can be used as a handy plug-in for many backbone models.
F AST S PARSE C ODING AND DICTIONARY LEARNING
In this section, we present our fast sparse coding and dictionary learning algorithm for the k -sparse problem and the l 0 -norm regularized problem in Section 3.1 and Section 3.2, respectively.
Both algorithms belong to the alternative descent optimization framework.
3. K -S PARSE C ODING
We ﬁrst introduce the optimization problem for sparse coding with a k -sparse constraint.
Mathematically, we aim at optimizing the following objective [Equation]
subject to (cid:107) y
[Equation]
where D ∈ R d × M is the dictionary, and d i denotes the i th column of matrix D .
y i denotes the i th column of the matrix Y ∈ R M × N , and µ ( · ) denotes the mutual coherence that is deﬁned as
[Equation]
The optimization problem (1) is discrete and non-convex, which is very difﬁcult to optimize.
To alleviate this problem, we employ a structured dictionary as
[Equation]
We require that R (cid:62) R = RR (cid:62) =
I d and BB (cid:62) =
I d , and each column vector of matrix B has a constant l 2 -norm, i.e., (cid:107) b i (cid:107) 2 = c .
The beneﬁt of the structured dictionary is that it enables a fast update algorithm with a closed-form approximation for the sparse coding phase.
3.1. C ONSTRUCTION OF S TRUCTURED M ATRIX B
Now, we show how to design a structured matrix B that satisﬁes the requirements.
First, we construct B by concatenating the real and imaginary parts of rows of a discrete Fourier matrix.
The proof of the following theorems regarding the properties of B can be found in Appendix.
Without loss of generality, we assume that d = 2 m, M = 2 n .
Let F ∈ C n × n be an n × n discrete Fourier matrix.
F k,j = e 2 π i kjn is the ( k, j ) th entry of F , where i = √− 1 .
Let Λ = { k 1 , k 2 , ..., k m } ⊂ { 1 , ..., n − 1 } be a subset of indexes.
The structured matrix B can be constructed as Eq.(4).
[Equation]
where Re and Im denote the real and imaginary parts of a complex number, and F Λ in Eq.
(5) is the matrix constructed by m rows of F
[Equation]
Proposition 1.
Suppose d = 2 m, M = 2 n .
Construct matrix B as in Eq.(4).
Then BB (cid:62) =
I d and {+(cid:107) b j (cid:107) 
+}
= (cid:112) mn , ∀ j ∈ { 1 , · · · , M } .
Theorem 1 shows that the structured construction B satisﬁes the orthogonal constraint and constant norm constraint.
One thing remaining is how to construct B to achieve a small mutual coherence.
To achieve this goal, we can leverage the coordinate descent method in (Lyu, 2017) to construct the index set Λ .
For a prime number n such that m divides n − 1 , i.e., m | ( n − 1) , we can employ a closed-form construction.
Let g denote a primitive root modulo n .
We construct the index Λ = { k 1 , k 2 , ..., k m } as
[Equation]
The resulted structured matrix B has a bounded mutual coherence, which is shown in Theorem 1.
Theorem 1.
Suppose d = 2 m, M = 2 n , and n is a prime such that m | ( n − 1) .
Construct matrix B as in Eq.(4) with index set Λ as Eq.(6).
Let mutual coherence µ ( B ) :
= max i (cid:54) =
j
[Equation]
[Table]
Then
[Equation]
Remark:
The bound of mutual coherence in Theorem 1 is non-trivial when n < m 2 .
For the case n ≥ m 2 , we can use the coordinate descent method in (Lyu, 2017) to minimize the mutual coherence.
Now, we show that the structured dictionary D = R (cid:62) B satisﬁes the constant norm constraint and has a bounded mutual coherence.
The results are summarized in Theorem 1.
Corollary 1.
Let D
= R (cid:62) B with R (cid:62) R = RR (cid:62) =
I d .
Construct matrix B as in Eq.(4) with index set Λ as Eq.(6).
Then µ ( D ) = µ ( B ) ≤ √ nm and (cid:107) d j (cid:107)
= (cid:107) b j (cid:107) 2 = (cid:112) mn , ∀ j ∈ { 1 , · · · , M } .
Corollary 1 shows that, for any orthogonal matrix R , each column vector of the structured dictionary
D has a constant l 2 -norm.
Moreover, it remains a constant mutual coherence µ ( D ) = µ ( B ) .
Thus, given a ﬁxed matrix B , we only need to learn matrix R for the dictionary learning without undermining the low mutual coherence property.
3.1. J OINT O PTIMIZATION FOR D ICTIONARY L EARNING AND S PARSE C ODING
With the structured matrix B , we can jointly optimize R and Y for the optimization problem (7).
[Equation]
subject to (cid:107) y i (cid:107) [Equation] ≤ k, ∀ i ∈ { 1 , · · · , N } (7)
[Equation]
This problem can be solved by the alternative descent method.
For a ﬁxed R , we show the sparse representation Y has a closed-form approximation thanks to the structured dictionary.
For the ﬁxed sparse codes Y , dictionary parameter R has a closed-form solution.
Fix R , optimize Y : Since the constraints of Y is column separable, i.e., (cid:107)
y i (cid:107) 0 ≤ k , and the objective (8) is also decomposable,
[Equation]
It is sufﬁcient to optimize the sparse code y i ∈ R M for each point x
i ∈ R d separately.
Without loss of generality, for any input x ∈ R d , we aim at ﬁnding the optimal sparse code y ∈ R M such that (cid:107) y (cid:107) 0 ≤ k .
Since R (cid:62) R = RR (cid:62) = I d and BB (cid:62) =
I d , we have
[Equation]
where h = B (cid:62) Rx is a dense code.
Case 1: When m = n (the columns of B are orthogonal), we can rewrite Eq.(9) into a summation form as [Equation] [Equation] Case 2: When m < n , we have an error-bounded approximation using R.H.S. in Eq.(10).
Let z
= h − y , we have
[Equation]
It is worth to note that the error bound is small when the mutual coherence µ ( B ) is small.
When we employ the structural matrix in Theorem 1.
It follows that
[Equation]
where C = min ( 1 √ n , mn ) .
In Eq.(14), we use µ ( B ) ≤ √ nm from Theorem 1.
Considering the sparse constraint (cid:107) y (cid:107) 0 ≤ k , the error bound is minimized when all the non-zero term y j =
h
j to get | y j − h
j | = 0 .
Let S denote the set of index of non-zero element y j of y .
Now the problem is to ﬁnd the index set S to minimize
[Equation]
[Equation]
where S c denotes the complement set of S .
We can see that Eq.(17) is minimized when S consists of the index of the k largest (in absolute value) elements of h .
Now, we consider (cid:80)
Mj
=1 z 2 j (cid:107) b j (cid:107) 22 .
Note that (cid:107) b j (cid:107)
=
mn , it follows that
[Equation]
Because each term ( h j − y j ) 2 ≥ 0 is minimized when y j = h j , we know that Eq.(18) under sparse constraints is minimized when all the non-zero term setting as y j = h j .
Otherwise we can set a non-zero term y j to y j = h j to further reduce term ( h j − y j ) 2 to zero.
Now, the problem is to ﬁnd the index set of the non-zero term to minimize Eq.(19).
[Equation]
where S :=
{ j | y j (cid:54) = 0 } .
We can see that Eq.(19) is minimized when S consists of the index of the k largest (in absolute value ) elements of h .
Remark: Both the approximation (cid:80) M {+j =1 z 2 j (cid:107) b j (cid:107) 
 and the error bound is minimized by the same solution.+}
Fix Y , Optimize R :
For a ﬁxed Y , we know that
[Equation]
[Equation] This is the nearest orthogonal matrix problem, which has a closed-form solution as shown in (Sch¨onemann, 1966;
Gong et al., 2012).
Let BY X (cid:62) =
U Γ V (cid:62) obtained by singular value decomposition (SVD), where U , V are orthgonal matrix.
Then, Eq.(20) is minimized by
[Equation]
3. l 0 - NORM R EGULARIZATION
We employ the structured dictionary D = R (cid:62) B
same as in Section 3.1.
The optimization problem with l 0 -norm regularization is deﬁned as
[Equation]
subject to
[Equation]
This problem can be solved by the alternative descent method.
For a ﬁxed R , we show Y has a closed-form approximation thanks to the structured dictionary.
For ﬁxed the sparse codes Y , dictionary parameter R also has a closed-form solution.
Fix R , optimize Y : Since the objective can be rewritten as Eq.(23)
[Equation]
It is sufﬁcient to optimize Y i for each point X i separately.
Without loss of generality, for any input x ∈ R d , we aim at ﬁnding an optimal sparse code y ∈ R M .
Since R (cid:62) R = RR (cid:62) =
I d and
BB (cid:62) =
I d , when m = n , following the derivation in Section 3.1.2, we have
[Equation]
where h = B (cid:62) Rx is a dense code.
Note that (cid:107) b j (cid:107)
=
mn , together with Eq.(24), it follows that
[Equation]
where 1 [ · ] is an indicator function which is 1 if its argument is true and 0 otherwise.
This problem is separable for each variable y j , and each term is minimized by setting
[Equation]
Fix Y , update R : For a ﬁxed Y , minimizing the objective leads to the same nearest orthogonal matrix problem as shown in Section 3.1.2.
Let BY X (cid:62) =
U Γ V (cid:62) obtained by SVD, where U , V are orthogonal matrix.
Then, the reconstruction problem is minimized by R = UV (cid:62) .
Remark: Problems with other separable regularization terms can be solved in a similar way.
The key difference is how to achieve sparse codes y .
For example, for l 1 -norm regularized problems, y can be obtained by a soft thresholding function, i.e., y = sign ( y ) (cid:12) max (cid:0) 0 , | y | − nλ/ (2 m ) (cid:1) .
S PARSE D ENOISING L AYER
One beneﬁt of our fast sparse coding algorithm is that it enables a simple closed-form reconstruction, which can be used as a plug-in layer for deep neural networks.
Speciﬁcally, given an orthogonal matrix R and input vector x , the optimal reconstruction of our method can be expressed as [Equation]
[Equation]
where f ( · ) is a non-linear mapping function.
For the k-sparse constrained problem, f ( · ) is a k-max pooling function (w.r.t the absolute value) as Eq.(28)
f ( h j ) =
(cid:26) h j if | h j | is one of the k-highest values of | h | ∈ R M otherwise .
For the l 0 -norm regularization problem, f ( · ) is a hard thresholding function as Eq.(29)
[Equation]
For the l 1 -norm regularization problem, f ( · ) is a soft thresholding function as Eq.(30)
[Equation]
where sign ( · ) denotes the Sign function.
The reconstruction in Eq.(27) can be used as a simple plug-in layer for deep networks, we named it as sparse denoising layer (SDL).
It is worth noting that only the orthogonal matrix R is needed to learn.
The structured matrix B is constructed as in Section 3.1.1 and ﬁxed.
The orthogonal matrix R can be parameterized by exponential mapping or Cayley mapping (Helfrich et al., 2018) of a skew-symmetric matrix.
In this work, we employ the Cayley mapping to enable gradient update using deep learning tools.
Speciﬁcally, the orthogonal matrix R can be obtained by the Cayley mapping of a skew-symmetric matrix as
[Equation]
[Equation] where W is a skew-symmetric matrix, i.e., W = − W (cid:62)
∈ R d × d .
For a skew-symmetric matrix
W , only the upper triangular matrix (without main diagonal) are free parameters.
Thus, the number of free parameters of SDL is d ( d − 1) / 2 , which is much smaller compared with the number of parameters of backbone deep networks.
For training a network with a SDL, we add a reconstruction loss term as a regularization.
The optimization problem is deﬁned as
[Equation]
(32) where W is a skew-symmetric matrix parameter of SDL.
Θ is the parameter of the backbone network.
(cid:101)
Z is the reconstruction of the latent representation Z via SDL (Eq.(27)).
An illustration of the
SDL plug-in is shown in Figure 1.
When SDL is used as the ﬁrst layer, then Z = X , and (cid:101) Z = (cid:102) X .
In this case, (cid:101) Z is the reconstruction of the input data X .
It is worth noting that the shape of the input and output of SDL are same.
Thus, SDL can be used as plug-in for any backbone models without changing the input/output shape of different layers in the backbone network.
With the simple SDL plug-in, backbone models can be trained from scratches.
[Figure]
E XPERIMENTS
We evaluate the performance of our SDL on both classiﬁcation tasks and RL tasks.
For classiﬁcation, we employ both DenseNet-100 (Huang et al., 2017) and ResNet-34 (He et al., 2016) as backbone.
For RL tasks, we employ deep PPO models 1 (Schulman et al., 2017) as backbone.
For all the tasks, we test the performance of backbone models with and without our SDL when adding Gaussian noise or Laplace noise.
In all the experiments, we plug SDL as the ﬁrst layer of deep models.
We set the [Figure] [Figure] standard deviation of input noise as { 0 , 0 . 1 , 0 . 2 , 0 . 3 } , respectively.
(The input noise is added after input normalization) .
We keep all the hyperparameters of the backbone models same, the only difference is whether plugging SDL.
The parameter β for the reconstruction loss is ﬁxed as β =
in all the experiments.
Classiﬁcation Tasks:
We test SDL on CIFAR10 and CIFAR100 dataset.
We construct the structured matrix B ∈ R 12 × 14 by Eq.(4).
In this setting, the orthogonal matrix R corresponds to the convolution parameter of Conv 2 d ( · ) with kernelsize= 2 × 2 .
We set the sparse parameter of our k -sparse SDL as k = 3 in all the classiﬁcation experiments.
The average test accuracy over ﬁve independent runs on CIFAR10 and CIFAR100 with Gaussian noise are shown in Fig.
3 and Fig. 4, respectively.
We can observe that models with SDL obtain a similar performance compared with vanilla model on the clean input case.
With an increasing variance of input noise, models with SDL outperform the vanilla models more and more signiﬁcantly.
The experimental results with Laplace noise are presented in Fig.
9 and Fig. 10 in the supplementary.
The results on Laplace noise cases show the similar trends with Gaussian noise cases.
We further test the performance of SDL under the fast gradient sign method (FGSM) attack (Goodfellow et al., 2015). The perturbation parameter epsilon is set to 8/256.
Experimental results are shown in Fig. We can observe that adding SDL plug-in can improve the adversarial robustness of the backbone models. More experiments on tiny-Imagenet dataset can be found in Appendix G.
RL Tasks:
We test deep PPO model with SDL on Atari games: KungFuMaster , Tennis and
Seaquest .
The deep PPO model concatenates four frames as the input state.
The size of input [Figure] [Figure] state is 84 × 84 × 4 .
We construct the structured matrix B ∈ R 36 × 38 by Eq.(4).
In this setting, the orthogonal matrix R corresponds to the convolution parameter of Conv 2 d ( · ) with kernelsize= 3 × 3 .
The number of free parameters is 630 .
We set the sparse parameter of our k -sparse SDL as k = 4 in all the RL experiments.
The return of one episode is the sum of rewards over all steps during the whole episode.
We present the average return over ﬁve independent runs on KungFuMaster and Tennis game with Gaussian noise and Laplace noise in Fig.
5 and Fig. 6, respectively.
Results on Seaquest game are shown in
Fig.
16 in the supplement due to the space limitation.
We can see that models with SDL achieve a competitive average return on the clean cases.
Moreover, models with SDL obtain higher average return than vanilla models when the input state is perturbed with noise.
C ONCLUSION
We proposed fast sparse coding algorithms for both k -sparse problem and l 0 -norm regularization problems.
Our algorithms have a simple closed-form update.
We proposed a sparse denoising layer as a lightweight plug-in for backbone models against noisy input perturbation based on this handy closed-form.
Experiments on both ResNet/DenseNet classiﬁcation model and deep PPO RL model showed the effeteness of our SDL against noisy input perturbation and adversarial perturbation. A P ROOF OF P ROPOSITION Proof. Let c i ∈
C 1 × n be the i th row of matrix F Λ ∈ C m × n in Eq.(5).
Let v i ∈ R 1 × 2 n be the i th row of matrix B ∈ R 2 m × 2 n in Eq.(4).
For 1 ≤ i, j ≤ m , i (cid:54) =
j , we know that
[Equation]
where ∗ denotes the complex conjugate, Re ( · ) and Im ( · ) denote the real and imaginary parts of the input complex number.
For a discrete Fourier matrix F , we know that
[Equation]
, if
[Equation]
=
j
[Equation]
otherwise
[Equation]
When i (cid:54) =
j , from Eq.(36), we know c i c ∗ j = 0 .
Thus, we have
[Equation]
[Equation]
When i =
j , we know that v i
+ m v (cid:62)
i + m =
v i v
[Equation]
=
c i c ∗ i = 1 .
Put two cases together, also note that d = 2 m , we have BB (cid:62)
=
I d .
The l 2 -norm of the column vector of B is given as
[Equation]
Thus, we have (cid:107) b j (cid:107) 2 = (cid:112) mn for j ∈ { 1 , · · · , M }
B P ROOF OF T HEOREM
Proof.
Let c i ∈
C m × 1 be the i th column of matrix F Λ ∈ C m × n in Eq.(5).
Let b i ∈ R 2 m × 1 be the i th column of matrix B ∈ R 2 m × 2 n in Eq.(4).
For 1 ≤ i, j ≤ n , i (cid:54) =
j , we know that
[Equation]
where ∗ denotes the complex conjugate, Re ( · ) and Im ( · ) denote the real and imaginary parts of the input complex number.
It follows that
[Equation]
[Equation]
From the deﬁnition of F Λ in Eq.(5), we know that
[Equation]
Because Λ = { g 0 , g n − 1 m , g 2( n − 1) m , · · · , g ( m − 1)( n − 1) m } mod n , we know that Λ is a subgroup of the multiplicative group { g 0 , g 1 , · · · , g n − 2 } mod n .
From Bourgain et al.
(2006), we know that
[Equation]
Finally, we know that
[Equation]
C P ROOF OF C OROLLARY
Proof.
Since R (cid:62) R = RR (cid:62) = I d and D =
R (cid:62) B , we know that (cid:107) d j (cid:107)
=
(cid:107) b j (cid:107) 2 .
{+From Theorem 1, we know that (cid:107) b j (cid:107) 
+}
=
(cid:112) mn , ∀ j ∈ { 1 , · · · , M } .
{+It follows that (cid:107) d j (cid:107) 
+}
= (cid:107) b j (cid:107) 2 = (cid:112) mn for ∀ j ∈ { 1 , · · · , M } .
From the deﬁnition of mutual coherence µ ( · ) , we know it is rotation invariant.
Since D = R (cid:62) B with R (cid:62) R = RR (cid:62) =
I d , we know µ ( D ) = µ ( B ) .
From Theorem 1, we have µ ( B ) ≤ √ nm .
Thus, we obtain µ ( D ) = µ ( B ) ≤ √ nm .
D E MPIRICAL CONVERGENCE OF OBJECTIVE FUNCTIONS
We test our fast dictionary learning algorithms on Lena with image patches (size 12 × 12 ).
We present the empirical convergence result of our fast algorithms in Figure 7.
It shows that the objective tends to converge less than ﬁfty iterations.
[Figure]
E D EMO OF D ENOISED I MAGES
We show the denoised results of our fast sparse coding algorithm on some widely used testing images.
The input images are perturbed by Gaussian noise with std σ = 100 .
The denoised results are presented in Figure 8.
It shows that our algorithms can reduce the inﬂuence of the noisy perturbation of the images
[Figure]
F E XPERIMENTAL RESULTS ON C LASSIFICATION WITH L APLACE N OISE
[Figure]
[Figure]
G E XPERIMENTAL RESULTS ON T INY -I MAGENET DATASET
[Figure]
[Figure]
[Figure]
[Figure]
[Figure]
H R ESULTS OF RL ON S EAQUEST G AME
[Figure]
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
[Table]
# reconstruction of the input