).构造如下目的代价函数,前几天要享受的这篇杂谈是自家个人最欢腾的舆论之一

试验结果

图片 1

上图(e)是舆论的法门和其余图像平滑方法的比较,可以寓目,那种依照 \(L_0\)
平滑的方法不但平滑的功力好,而且大致是纹丝不动地保存了色块之间的边缘音讯。而其他办法在色块(越发是甲辰革命)上的平整力度不如
\(L_0\) 平滑,且边缘也搅乱了诸多。

其余,小说的平缓方法在边缘提取上效果也一定的好,下图中,左侧(e)是直接对原图用
Canny 提取边缘的结果,左侧是先用 \(L_0\) smoothing
进行平整,再领取边缘的结果,可以看出,平滑后领取的边缘中抹去了很多不重大的细节,而根本的边缘新闻都被提取出来。

图片 2

除去,另一个很重大的用处是图像失量化。图像失量化必要图像中的色块数量尽可能少,而那点正中
\(L_0\) smoothing
下怀。下图中的输入图像具有众多噪声细节,而这一个细节用一般的平缓方向是很难杜绝的,但
\(L_0\) smoothing
由于限制了梯度数量,因而得以生出很「光滑」的色块区域,相当方便失量化操作。

图片 3

代码完毕

本节施行实例中,主文件是
sparseCodingExercise.m ,对\(A,s\)的代价梯度总括模块分别是
sparseCodingWeightCost.m、sparseCodingFeatureCost.m.
根据上述矩阵推导分别填充其中的公式部分,全体代码见https://github.com/codgeek/deeplearning

独家固定\(A,s\)举行最优化的步子在sparseCodingExercise.m中,有几条需求留意的地点,否则将会很难陶冶出结果。

  • 老是交替起首前,不可以轻易设定特征值,而是设定为
    featureMatrix = weightMatrix'*batchPatches;
  • 加载原始图像的函数sampleIMAGES.m中无法调用归一化normalizeData。和疏散自编码差别。
  • 眼前推导的永恒\(s\)时最优化\(A\)表示中相对无法漏掉单位矩阵,是\(\gamma\)乘以单位矩阵,不可以平素加\(\gamma\)。公式为weightMatrix = (batchPatches*(featureMatrix'))/(featureMatrix*(featureMatrix')+gamma*batchNumPatches*eye(numFeatures));.

两个梯度公式代码如下。

function [cost, grad] = sparseCodingWeightCost(weightMatrix, featureMatrix, visibleSize, numFeatures,  patches, gamma, lambda, epsilon, groupMatrix)
%sparseCodingWeightCost - given the features in featureMatrix, 
%                         computes the cost and gradient with respect to
%                         the weights, given in weightMatrix
% parameters
%   weightMatrix  - the weight matrix. weightMatrix(:, c) is the cth basis
%                   vector.
%   featureMatrix - the feature matrix. featureMatrix(:, c) is the features
%                   for the cth example
%   visibleSize   - number of pixels in the patches
%   numFeatures   - number of features
%   patches       - patches
%   gamma         - weight decay parameter (on weightMatrix)
%   lambda        - L1 sparsity weight (on featureMatrix)
%   epsilon       - L1 sparsity epsilon
%   groupMatrix   - the grouping matrix. groupMatrix(r, :) indicates the
%                   features included in the rth group. groupMatrix(r, c)
%                   is 1 if the cth feature is in the rth group and 0
%                   otherwise.
    if exist('groupMatrix', 'var')
        assert(size(groupMatrix, 2) == numFeatures, 'groupMatrix has bad dimension');
    else
        groupMatrix = eye(numFeatures);
    end

    numExamples = size(patches, 2);

    weightMatrix = reshape(weightMatrix, visibleSize, numFeatures);
    featureMatrix = reshape(featureMatrix, numFeatures, numExamples);

    % -------------------- YOUR CODE HERE --------------------
    % Instructions:
    %   Write code to compute the cost and gradient with respect to the
    %   weights given in weightMatrix.     
    % -------------------- YOUR CODE HERE --------------------    
    linearError = weightMatrix * featureMatrix - patches;
    normError = sum(sum(linearError .* linearError))./numExamples;% 公式中代价项是二阶范数的平方,所以不用在开方
    normWeight = sum(sum(weightMatrix .* weightMatrix));

    topoFeature = groupMatrix*(featureMatrix.*featureMatrix);
    smoothFeature = sqrt(topoFeature + epsilon);
    costFeature = sum(sum(smoothFeature));% L1 范数为sum(|x|),对x加上平滑参数后,sum(sqrt(x2+epsilon)).容易错写为sqrt(sum(x2+epsilon))实际是L2范数

%     cost = normError + gamma.*normWeight;
    cost = normError + lambda.*costFeature + gamma.*normWeight;
    grad = 2./numExamples.*(linearError*featureMatrix') + (2*gamma) .* weightMatrix;
%     grad = 2.*(weightMatrix*featureMatrix - patches)*featureMatrix' + 2.*gamma*weightMatrix;
    grad = grad(:);

end

function [cost, grad] = sparseCodingFeatureCost(weightMatrix, featureMatrix, visibleSize, numFeatures, patches, gamma, lambda, epsilon, groupMatrix)
%sparseCodingFeatureCost - given the weights in weightMatrix,
%                          computes the cost and gradient with respect to
%                          the features, given in featureMatrix
% parameters
%   weightMatrix  - the weight matrix. weightMatrix(:, c) is the cth basis
%                   vector.
%   featureMatrix - the feature matrix. featureMatrix(:, c) is the features
%                   for the cth example
%   visibleSize   - number of pixels in the patches
%   numFeatures   - number of features
%   patches       - patches
%   gamma         - weight decay parameter (on weightMatrix)
%   lambda        - L1 sparsity weight (on featureMatrix)
%   epsilon       - L1 sparsity epsilon
%   groupMatrix   - the grouping matrix. groupMatrix(r, :) indicates the
%                   features included in the rth group. groupMatrix(r, c)
%                   is 1 if the cth feature is in the rth group and 0
%                   otherwise.

    if exist('groupMatrix', 'var')
        assert(size(groupMatrix, 2) == numFeatures, 'groupMatrix has bad dimension');
    else
        groupMatrix = eye(numFeatures);
    end

    numExamples = size(patches, 2);

    weightMatrix = reshape(weightMatrix, visibleSize, numFeatures);
    featureMatrix = reshape(featureMatrix, numFeatures, numExamples);

    linearError = weightMatrix * featureMatrix - patches;
    normError = sum(sum(linearError .* linearError))./numExamples;
    normWeight = sum(sum(weightMatrix .* weightMatrix));
    topoFeature = groupMatrix*(featureMatrix.*featureMatrix);
    smoothFeature = sqrt(topoFeature + epsilon);
    costFeature = sum(sum(smoothFeature));% L1 范数为sum(|x|),对x加上平滑参数后,sum(sqrt(x2+epsilon)).容易错写为sqrt(sum(x2+epsilon))实际是L2范数

    cost = normError + lambda.*costFeature + gamma.*normWeight;
    grad = 2./numExamples.*(weightMatrix' * linearError) + lambda.*featureMatrix.*( (groupMatrix')*(1 ./ smoothFeature) );% 不止(f,i)本项偏导非零,(f-1,i)……,groupMatrix第f列不为0的所有行对应项都有s(f,i)的偏导
    grad = grad(:);
end

矩阵化推导

上述符号都是相当抽象意义上的变量,矩阵化完成时就须求考虑清楚每行每列的操作是还是不是安份守己预设的每一项运算规则完结的,原文中向来不那部分情节,我也花费了一番功夫推导。

依照前文所说的更迭求\(A,s\)最优化策略,大家须求先推导代价函数对\(A,s\)的偏导。设定矩阵表示举行为\(A=[_{Wj,f}]_{visibleSize \times
featureSize}\). \(s=[S_{Wj,f}]_{featureSize\times
m}\). 令\(V=visibleSize,
F=featureSize\).

一维图像信号

在标准讲思想从前,我们先想起一下图像平滑的目的是什么。

图片 4

为了不难起见,大家先从一维出发,把图像当作一维的信号。那么,图像平滑就是要把那多少个相比较小的近乎「褶皱」的地方抹平,而把那一个大的「褶皱」,或者更确切地说,变化很大的梯度(边缘)保留下去。上面这幅图显示的是不一致算法的坦荡效果。可以发现,从前的算法在平坦掉那个坑坑洼洼的「褶皱」的还要,也把可能把属于真正边缘的大的梯度给模糊了(细节放大图如下)

图片 5

为了幸免那种问题,随想提出一种基于 \(L_0\) 范数的能量最小化方法。

所谓 \(L_0\) 范数,指的就是向量中国和欧洲0 元素的个数。杂谈中借用那么些定义,提出一个图像梯度数量的统计公式:
\[ c(f)=\#\{p\ \big |\
|f_p-f_{p+1}|\neq 0 \} \]
公式中,\(f\)
表示大家平滑后的图像,\(\#\)
表示集合中元素 \(p\) 的个数,而 \(p\) 则意味像素地方,因而 \(f_p\) 其实就意味着图像 \(f\) 在 \(p\) 那么些职位的像素值。

所以这么些公式其实就是在测算:满意 \(|f_p-f_{p+1}| \neq 0\)
的像素数量,那么些不等式正好就是 \(L_0\)
范数。它的现实意义就是统计图片信号中梯度的数目

有了这么些公式后,杂谈抛出它最主旨的对象函数:
\[ \underset{f} {\operatorname {min}}
\sum_{p}(f_p-g_p)^2 \ \ \ \ \operatorname{s.t.} \ c(f)=k
\]
公式中的 \(g\) 表示原图像,\(f\) 表示平滑后的图像,\(c(f)\)
就是地点提到的测算梯度数量的公式,它意味着 \(f\) 中的梯度数量应该为 \(k\) 个。

本条公式表示的是图像 \(f\) 中每个像素
\(f_p\) 和原图 \(g\) 中各样像素 \(g_p\) 之间的平方差之和。

最小化那些目的函数,其实就是要细小化 \(f\) 和 \(g\) 之间的像素差。如若没有 \(c(f)\) 那个限制,那么最后的优化结果就是
\(f=g\)。但加上 \(c(f)\)
限制后,这几个目的函数在尽可能减弱八个信号之间的能量差的同时,又要让 \(f\) 中的梯度数量满足 \(k\) 个。换句话说,它要尽量让 \(f\) 和 \(g\) 相似,同时又抹平 \(f\)
中的梯度。由此,最终的优化结果不得不是保存住 \(f\)
中那么些梯度对比大的边缘,而平整掉那一个梯度比较小的「褶皱」。

\(c(f)\) 那个限制最大的效果就是预防
\(f\)
出现对边缘的模糊。如果仔细考察地点这张边缘模糊的细节图,你就会发觉,造成模糊的案由是我们把本来很「抖」的梯度变「缓」了,而缓的梯度其实是由众多小梯度组成的。\(c(f)\)
的限量正是为了减小那种梯度的数目。由此,为了满意 \(c(f)\),目的函数会让 \(f\) 中的梯度倾向于更「抖」。

最小化能量差减去梯度数量那多少个约束的联手博弈下,最终得到了上边的那种很平整、同时边缘很深入的结果:

图片 6

那种相互制约的想法实在是简简单单而又可以!

可是,实际应用中设有一个问题,就是 \(k\)
的扭转范围很大,是很难采取的。为了控制 \(k\) 的选料范围,随笔把 \(c(f)=k\) 那一个约束也进入到目标函数中:
\[ \underset{f}{\operatorname{min}} \{
\sum_p{(f_p-g_p)^2+\lambda c(f)} \} \]
现在 \(\lambda\) 代替 \(k\) 作为可以调节的参数。\(\lambda\) 越大,目标函数对 \(c(f)\)
的平抑就越大,梯度数量就越少(即边缘越少),反之,梯度数量越大。

关键思路

  前边几篇所讲的都是围绕神经网络展开的,一个标明就是激活函数非线性;在前人的钻探中,也存在线性激活函数的稀疏编码,该情势试图直接攻读数据的特征集,利用与此特征集相应的基向量,将学习收获的风味集从特征空间更换来样本数量空间,这样可以用特色集重构样本数量。

​ 数据集、特征集、基向量分别代表为\(x、A、s\).构造如下目的代价函数,对算计误差的代价选拔二阶范数,对稀疏性因子的惩治代价接纳一阶范数。原文中尚未对误差项在多少集上做平均,真真实情形形下都会除以数据集个数\(m\).

\[J(A,s)= \frac
1m||As-x||_2^2+\lambda||s||\]

接下来,原文中分演说为了增强稀疏性约束,防止取\(A\)的缩放值也能取得同等的代价,稀疏性惩罚需求考虑特征集的数值,进一步革新代价函数为

\[J(A,s)= \frac
1m||As-x||_2^2+\lambda||s||+\gamma ||A||_2^2\]

代价函数如故存在L1范数的0点不可微问题,通过类似平滑解决,定义常量值平滑参数\(\epsilon\), 将代价函数变成

\[J(A,s)= \frac 1m||As-x||_2^2+\lambda
\sum_k \sqrt{s_k^2+\epsilon} +\gamma ||A||_2^2\]

出于本代价函数非凸,而定点任意一个变量之后,代价函数是凸函数,所以可以通过轮班固定\(A,s\)来求最优化代价的\(A,s\).
理论上对上式最优化取得的特色集与经过稀疏自编码学习取得的表征集差不离,人类视觉神经具有一种特性,大脑皮层
V1
区神经元可以按一定的方向对边缘举办检测,同时,那个神经元(在生理上)被协会成超柱(hypercolumns),在超柱中,相邻神经元以相似的来头对边缘进行检测,一个神经元检测水平边缘,其附近神经元检测到的边缘就稍微偏离水平方向。为了使算法达到那种
拓扑性
,也就是说相邻的表征激活具有一定延续性、平滑性,大家将惩治项也改造成考虑相邻特征值,在2X2分组景况下,把原先
\(\sqrt{s_{1,1}^2+\epsilon}\)这一项换成
\(\sqrt{s_{1,1}^2+s_{1,2}^2+s_{2,1}^2
+s_{2,2}^2+ \epsilon}\) 。得到拓扑稀疏编码的代价函数为

\[J(A,s)= \frac 1m||As-x||_2^2+\lambda
\sum_{all G} \sqrt{ \sum_{s \in G}s^2+\epsilon} +\gamma
||A||_2^2\]

尤为用分组矩阵G来表示邻域分组规则,\(G_{r,c}=1\)表示第r组包括第c个特性,目的函数重写为

\[J(A,s)= \frac 1m||As-x||_2^2+\lambda
\sum \sqrt{ Vss^T+\epsilon} +\gamma ||A||_2^2\]

固定\(A\)求解\(s\)的梯度

拓展代价函数并对\(s\)求解,

\[\begin{align} \frac {\nabla J(A,s)} {
S_{f,i}} &= \frac 1 m \sum _j^V
2[W_{j,1}S_{1,i}+W_{j,2}S_{2,i}+…W_{j,F}S_{F,i}
-x_{j,i}]W_{j,f}+ \frac {\nabla \lambda \sum_f^F \sum_i^m
\sqrt {Gss^T+\epsilon }} {\nabla S_{f,i}} \\ &= \frac 1 m \sum
_j^V 2[W_{j,1}S_{1,i}+W_{j,2}S_{2,i}+…W_{j,F}S_{F,i}
-x_{j,i}]W_{j,f} + \lambda S_{f,i}\sum_l^F{\frac {g_{l,f}}
{S\_smooth_{x,f}}} \end{align}\]

其中\(G=[g_{l,f}]_{F \times F}\)
,\(g_{l,f}=1\)表示第\(l\)组包罗第f个特色。
S_smooth代表依据拓扑编码必要,对特征值的邻域进行平整后的性状矩阵。

开展矩阵化改写,能够赢得,八个求和式可以分级写成矩阵乘法:

\[ \frac {\nabla J(A,s)} S = \frac 2 m
A^T(As-x) + \lambda S \cdot (G^T {(1./ S\_smooth)})\]

这一个矩阵表明式无法获得使代价函数最小的\(S\)解析式,那几个最优化进程须求选用迭代的措施获取,可以接纳梯度下落那类最优化措施。

从这之后我们得到了编辑代码需要的装有矩阵化表明。

杂文紧要考虑

矩阵化推导

上述符号都是那些抽象意义上的变量,矩阵化完结时就要求考虑清楚每行每列的操作是否按照预设的每一项运算规则完结的,原文中并未那有的情节,我也费用了一番功夫推导。

遵从前文所说的轮换求\(A,s\)最优化策略,我们须求先推导代价函数对\(A,s\)的偏导。设定矩阵表示举办为\(A=[_{Wj,f}]_{visibleSize \times
featureSize}\). \(s=[S_{Wj,f}]_{featureSize\times
m}\). 令\(V=visibleSize,
F=featureSize\).

固定\(s\)求解\(A\)的梯度与最优取值

代价的一阶范数项对\(A\)求偏导为0.

\[\frac {\nabla J(A,s)} {W_{j,f}}
=\frac 1 m \sum _i^m
2[W_{j,1}S_{1,i}+W_{j,2}S_{2,i}+…W_{j,F}S_{F,i}
-x_{j,i}]S_{f,i}+ 2\gamma W_{j,f}\]

单向统一成矩阵表示为

\[\frac {\nabla J(A,s)} {A} = \frac 2 m
(As-x)s^T +2\gamma A \]

同时大家发现此表明式为一阶方程,可以博得代价函数取极小值时的\(A\)。可得s固定时使代价函数最小的\(A\)为

即\[min J(A,s) \Leftrightarrow A = \frac
{xs^T} {ssT+m \gamma I}; \] .

优化措施

愿意有生之年看懂补上。。。

固定\(s\)求解\(A\)的梯度与最优取值

代价的一阶范数项对\(A\)求偏导为0.

\[\frac {\nabla J(A,s)} {W_{j,f}}
=\frac 1 m \sum _i^m
2[W_{j,1}S_{1,i}+W_{j,2}S_{2,i}+…W_{j,F}S_{F,i}
-x_{j,i}]S_{f,i}+ 2\gamma W_{j,f}\]

单向联合成矩阵表示为

\[\frac {\nabla J(A,s)} {A} = \frac 2 m
(As-x)s^T +2\gamma A \]

同时大家发现此表明式为一阶方程,可以博得代价函数取极小值时的\(A\)。可得s固定时使代价函数最小的\(A\)为

即\[min J(A,s) \Leftrightarrow A = \frac
{xs^T} {ssT+m \gamma I}; \] .

UFLDL深度学习笔记 (七)拓扑稀疏编码与矩阵化

散文的目标

所谓图像平滑,就是凸起图像中的低频成分,抑制高频成分,减小突变的梯度。半数以上景色下,这么做的目标是为了去除图像中的噪声,因为噪音一般就是一对孤立的像素点,是像素变化相比较大的区域。在观念的图像处理中,大多数操作都是用有些怀有平滑性质的卷积核查图像举办模糊处理,最常用的如:高斯模糊、均值滤波等等。那么些形式都有一个欠缺,就是在模糊噪声的同时,也搅乱了边缘。当然之后也有局地更上一层楼的方法,如:二者滤波等,那几个点子都在边缘保持上展开了很多更上一层楼,但稍事依然会损失边缘的新闻。本文的不二法门完全不一样于以往的那么些算法,它从图像梯度的角度出发,在平坦掉半数以上一线的噪音的还要,又能最大限度的涵养首要的边缘音信。

UFLDL深度学习笔记 (七)拓扑稀疏编码与矩阵化

教练结果

多少来自如故疏散自编码一节所用的图形,
设定特征层包括121个节点,输入层为8X8patch即64个节点,拓扑邻域为3X3的方阵,运行200次操练,

当输入值为对应特征值时,每个激活值会有最大响应,所以把A矩阵每一行的64个向量还原成8*8的图样patch,也就是特征值了,每个隐藏层对应一个,总共121个。结果如下图.
可见到在近期参数下,相同迭代次数,cg算法的图样特征越发清楚。

lbfgs cg

为了见到更小巧的教练结果,伸张特征层以及输入层节点数,特征层采纳256个节点,输入层分别考查了14X14以及15X15,相应需求扩展拓扑邻域的高低,接纳5X5的方阵。迭代算法选择cg。特征的明显程度以及拓扑结构的完整性已经和示范中的结果无差异。边缘特征平稳排列。而当把输入节点个数伸张到16X16,
陶冶效果出现恶变,边缘特征先导变得模糊,原因也可以精晓,特征层已经不复大于输入层,超完备基的规范不创立了,得到的练习效益也相对变差。

14X14输入节点,拓扑5X5 15X15输入节点,拓扑5X5

充实输入节点的结果:

16X16输入节点,拓扑3X3 16X16输入节点,拓扑5X5

此外那篇杂文的撰稿人徐立也是一个格外高产的商量员。

固定\(A\)求解\(s\)的梯度

展开代价函数并对\(s\)求解,

\[\begin{align} \frac {\nabla J(A,s)} {
S_{f,i}} &= \frac 1 m \sum _j^V
2[W_{j,1}S_{1,i}+W_{j,2}S_{2,i}+…W_{j,F}S_{F,i}
-x_{j,i}]W_{j,f}+ \frac {\nabla \lambda \sum_f^F \sum_i^m
\sqrt {Gss^T+\epsilon }} {\nabla S_{f,i}} \\ &= \frac 1 m \sum
_j^V 2[W_{j,1}S_{1,i}+W_{j,2}S_{2,i}+…W_{j,F}S_{F,i}
-x_{j,i}]W_{j,f} + \lambda S_{f,i}\sum_l^F{\frac {g_{l,f}}
{S\_smooth_{x,f}}} \end{align}\]

其中\(G=[g_{l,f}]_{F \times F}\)
,\(g_{l,f}=1\)表示第\(l\)组包罗第f个特点。
S_smooth表示按照拓扑编码要求,对特征值的邻域进行平整后的特色矩阵。

开展矩阵化改写,可以赢得,三个求和式可以分别写成矩阵乘法:

\[ \frac {\nabla J(A,s)} S = \frac 2 m
A^T(As-x) + \lambda S \cdot (G^T {(1./ S\_smooth)})\]

本条矩阵表明式无法收获使代价函数最小的\(S\)解析式,那些最优化进程须要运用迭代的方法获取,能够选取梯度下降那类最优化措施。

至此大家取得了编写代码须要的持有矩阵化表明。

代码完毕

本节实践实例中,主文件是
sparseCodingExercise.m ,对\(A,s\)的代价梯度计算模块分别是
sparseCodingWeightCost.m、sparseCodingFeatureCost.m.
根据上述矩阵推导分别填充其中的公式部分,全体代码见https://github.com/codgeek/deeplearning

独家固定\(A,s\)举行最优化的手续在sparseCodingExercise.m中,有几条须求专注的地方,否则将会很难陶冶出结果。

  • 每一回交替开端前,不可能随随便便设定特征值,而是设定为
    featureMatrix = weightMatrix'*batchPatches;
  • 加载原始图像的函数sampleIMAGES.m中不可能调用归一化normalizeData。和疏散自编码差距。
  • 面前推导的原则性\(s\)时最优化\(A\)表示中绝对不可以漏掉单位矩阵,是\(\gamma\)乘以单位矩阵,不可能一向加\(\gamma\)。公式为weightMatrix = (batchPatches*(featureMatrix'))/(featureMatrix*(featureMatrix')+gamma*batchNumPatches*eye(numFeatures));.

七个梯度公式代码如下。

function [cost, grad] = sparseCodingWeightCost(weightMatrix, featureMatrix, visibleSize, numFeatures,  patches, gamma, lambda, epsilon, groupMatrix)
%sparseCodingWeightCost - given the features in featureMatrix, 
%                         computes the cost and gradient with respect to
%                         the weights, given in weightMatrix
% parameters
%   weightMatrix  - the weight matrix. weightMatrix(:, c) is the cth basis
%                   vector.
%   featureMatrix - the feature matrix. featureMatrix(:, c) is the features
%                   for the cth example
%   visibleSize   - number of pixels in the patches
%   numFeatures   - number of features
%   patches       - patches
%   gamma         - weight decay parameter (on weightMatrix)
%   lambda        - L1 sparsity weight (on featureMatrix)
%   epsilon       - L1 sparsity epsilon
%   groupMatrix   - the grouping matrix. groupMatrix(r, :) indicates the
%                   features included in the rth group. groupMatrix(r, c)
%                   is 1 if the cth feature is in the rth group and 0
%                   otherwise.
    if exist('groupMatrix', 'var')
        assert(size(groupMatrix, 2) == numFeatures, 'groupMatrix has bad dimension');
    else
        groupMatrix = eye(numFeatures);
    end

    numExamples = size(patches, 2);

    weightMatrix = reshape(weightMatrix, visibleSize, numFeatures);
    featureMatrix = reshape(featureMatrix, numFeatures, numExamples);

    % -------------------- YOUR CODE HERE --------------------
    % Instructions:
    %   Write code to compute the cost and gradient with respect to the
    %   weights given in weightMatrix.     
    % -------------------- YOUR CODE HERE --------------------    
    linearError = weightMatrix * featureMatrix - patches;
    normError = sum(sum(linearError .* linearError))./numExamples;% 公式中代价项是二阶范数的平方,所以不用在开方
    normWeight = sum(sum(weightMatrix .* weightMatrix));

    topoFeature = groupMatrix*(featureMatrix.*featureMatrix);
    smoothFeature = sqrt(topoFeature + epsilon);
    costFeature = sum(sum(smoothFeature));% L1 范数为sum(|x|),对x加上平滑参数后,sum(sqrt(x2+epsilon)).容易错写为sqrt(sum(x2+epsilon))实际是L2范数

%     cost = normError + gamma.*normWeight;
    cost = normError + lambda.*costFeature + gamma.*normWeight;
    grad = 2./numExamples.*(linearError*featureMatrix') + (2*gamma) .* weightMatrix;
%     grad = 2.*(weightMatrix*featureMatrix - patches)*featureMatrix' + 2.*gamma*weightMatrix;
    grad = grad(:);

end

function [cost, grad] = sparseCodingFeatureCost(weightMatrix, featureMatrix, visibleSize, numFeatures, patches, gamma, lambda, epsilon, groupMatrix)
%sparseCodingFeatureCost - given the weights in weightMatrix,
%                          computes the cost and gradient with respect to
%                          the features, given in featureMatrix
% parameters
%   weightMatrix  - the weight matrix. weightMatrix(:, c) is the cth basis
%                   vector.
%   featureMatrix - the feature matrix. featureMatrix(:, c) is the features
%                   for the cth example
%   visibleSize   - number of pixels in the patches
%   numFeatures   - number of features
%   patches       - patches
%   gamma         - weight decay parameter (on weightMatrix)
%   lambda        - L1 sparsity weight (on featureMatrix)
%   epsilon       - L1 sparsity epsilon
%   groupMatrix   - the grouping matrix. groupMatrix(r, :) indicates the
%                   features included in the rth group. groupMatrix(r, c)
%                   is 1 if the cth feature is in the rth group and 0
%                   otherwise.

    if exist('groupMatrix', 'var')
        assert(size(groupMatrix, 2) == numFeatures, 'groupMatrix has bad dimension');
    else
        groupMatrix = eye(numFeatures);
    end

    numExamples = size(patches, 2);

    weightMatrix = reshape(weightMatrix, visibleSize, numFeatures);
    featureMatrix = reshape(featureMatrix, numFeatures, numExamples);

    linearError = weightMatrix * featureMatrix - patches;
    normError = sum(sum(linearError .* linearError))./numExamples;
    normWeight = sum(sum(weightMatrix .* weightMatrix));
    topoFeature = groupMatrix*(featureMatrix.*featureMatrix);
    smoothFeature = sqrt(topoFeature + epsilon);
    costFeature = sum(sum(smoothFeature));% L1 范数为sum(|x|),对x加上平滑参数后,sum(sqrt(x2+epsilon)).容易错写为sqrt(sum(x2+epsilon))实际是L2范数

    cost = normError + lambda.*costFeature + gamma.*normWeight;
    grad = 2./numExamples.*(weightMatrix' * linearError) + lambda.*featureMatrix.*( (groupMatrix')*(1 ./ smoothFeature) );% 不止(f,i)本项偏导非零,(f-1,i)……,groupMatrix第f列不为0的所有行对应项都有s(f,i)的偏导
    grad = grad(:);
end

二维图像信号

一维信号的羁绊可以很不难引申到二维信号:
\[ C(S)=\#\{p\ \big | \ |\partial_x
S_p|+|\partial_y S_p| \neq 0 \} \]
\(S\) 类似下面提到的 \(f\),在此地它象征处理后的二维图像,\(\partial_x S_p\) 和 \(\partial_y S_p\) 分别代表在 \(x\) 方向和 \(y\) 方向计算 \(L_0\) 范数。

下一场,大家得以用平等的点子赢得目的函数:
\[ \underset{S}{\operatorname{min}} \{
\sum_p{(S_p-I_p)^2+\lambda C(S)} \} \]
公式中 \(I\)
表示原图,其他的类比一维信号的公式。

磨练结果

多少来自如故疏散自编码一节所用的图形,
设定特征层包罗121个节点,输入层为8X8patch即64个节点,拓扑邻域为3X3的方阵,运行200次陶冶,

当输入值为对应特征值时,每个激活值会有最大响应,所以把A矩阵每一行的64个向量还原成8*8的图纸patch,也就是特征值了,每个隐藏层对应一个,总共121个。结果如下图.
可观察在现阶段参数下,相同迭代次数,cg算法的图形特征尤其清楚。

lbfgs cg

为了见到更精致的陶冶结果,扩充特征层以及输入层节点数,特征层选用256个节点,输入层分别考查了14X14以及15X15,相应须求充实拓扑邻域的大小,采取5X5的方阵。迭代算法选取cg。特征的显著程度以及拓扑结构的完整性已经和示范中的结果无差异。边缘特征平稳排列。而当把输入节点个数伸张到16X16,
磨练成效出现恶化,边缘特征初叶变得模糊,原因也足以知晓,特征层已经不再大于输入层,超完备基的尺度不树立了,得到的教练效果也相对变差。

14X14输入节点,拓扑5X5 15X15输入节点,拓扑5X5

充实输入节点的结果:

16X16输入节点,拓扑3X3 16X16输入节点,拓扑5X5

主要思路

  前边几篇所讲的都是环绕神经网络展开的,一个标志就是激活函数非线性;在前人的探究中,也设有线性激活函数的稀疏编码,该方法统计直接攻读数据的特征集,利用与此特征集相应的基向量,将学习取得的特色集从特征空间更换来样本数量空间,那样可以用特色集重构样本数量。

​ 数据集、特征集、基向量分别代表为\(x、A、s\).构造如下目的代价函数,对估算误差的代价选用二阶范数,对稀疏性因子的查办代价选用一阶范数。原文中尚未对误差项在数据集上做平均,真实景况下都会除以数据集个数\(m\).

\[J(A,s)= \frac
1m||As-x||_2^2+\lambda||s||\]

接下来,原文中讲演说为了增长稀疏性约束,避免取\(A\)的缩放值也能博得同等的代价,稀疏性惩罚要求考虑特征集的数值,进一步立异代价函数为

\[J(A,s)= \frac
1m||As-x||_2^2+\lambda||s||+\gamma ||A||_2^2\]

代价函数依然存在L1范数的0点不可微问题,通过类似平滑解决,定义常量值平滑参数\(\epsilon\), 将代价函数变成

\[J(A,s)= \frac 1m||As-x||_2^2+\lambda
\sum_k \sqrt{s_k^2+\epsilon} +\gamma ||A||_2^2\]

是因为本代价函数非凸,而固定任意一个变量之后,代价函数是凸函数,所以可以透过轮班固定\(A,s\)来求最优化代价的\(A,s\).
理论上对上式最优化取得的性状集与经过稀疏自编码学习取得的特征集大致,人类视觉神经具有一种特色,大脑皮层
V1
区神经元可以按一定的样子对边缘举行检测,同时,这么些神经元(在生理上)被集体成超柱(hypercolumns),在超柱中,相邻神经元以一般的矛头对边缘进行检测,一个神经元检测水平边缘,其相邻神经元检测到的边缘就稍微偏离水平方向。为了使算法达到那种
拓扑性
,也就是说相邻的特征激活具有自然一而再性、平滑性,大家将处以项也改造成考虑相邻特征值,在2X2分组景况下,把本来
\(\sqrt{s_{1,1}^2+\epsilon}\)这一项换成
\(\sqrt{s_{1,1}^2+s_{1,2}^2+s_{2,1}^2
+s_{2,2}^2+ \epsilon}\) 。获得拓扑稀疏编码的代价函数为

\[J(A,s)= \frac 1m||As-x||_2^2+\lambda
\sum_{all G} \sqrt{ \sum_{s \in G}s^2+\epsilon} +\gamma
||A||_2^2\]

越是用分组矩阵G来表示邻域分组规则,\(G_{r,c}=1\)表示第r组包涵第c个特点,目的函数重写为

\[J(A,s)= \frac 1m||As-x||_2^2+\lambda
\sum \sqrt{ Vss^T+\epsilon} +\gamma ||A||_2^2\]

前几天要享用的这篇杂谈是自家个人最欣赏的杂谈之一,它的思量简单、巧妙,而且效果还一定不错。那篇随想借助数学上的
\(L_0\)
范数工具对图像举行平整,同时保留紧要的边缘特征,可以兑现类似水彩画的成效(见下图)。

图片 7

参考

相关文章