DeepLearning（深度学习）原理与实现

DeepLearning（深度学习）原理与实现（一）

源自：http://blog.youkuaiyun.com/marvin521/article/details/8886971

 经过三年的狂刷理论，觉得是时候停下来做些有用的东西了，因此决定开博把他们写下来，一是为了整理学过的理论，二是监督自己并和大家分享。先从DeepLearning谈起吧，因为这个有一定的实用性（大家口头传的“和钱靠的很近”)，国内各个大牛也都谈了不少，我尽量从其他方面解释一下。

        DeepLearning算是多伦多大学Geoffery hinton教授第二春吧，第一春就是传统神经网络，由于传统的多层感知机很容易陷入局部最小，直接用反向传播算法（Back Propagation）求取的分类效果并不如意，原因一是特征是手工的，二就是局部最小问题。而DeepLearning引入了概率图模型里的生成模型，他可以直接自动的从训练集里提取所需要的特征，典型的模型为有限制玻尔兹曼机（Restricted Boltzmann Machines，简称RBM），自动提取的特征解决了手工特征考虑不周的因素，而且很好的初始化了神经网络权重，接着可以采用反向传播算法进行分类，实验得出了很好的效果。 因此DeepLearning被喻为下一代神经网络。今天的话题就来讨论下RBM：

       再说RBM之前，我们先提一下基于能量的模型(Engery based model),能量方法来源于热动力学，分子在高温中运动剧烈，能够克服局部约束（分子之间的一些物理约束，比如键值吸引力等），在逐步降到低温时，分子最终会排列出有规律的结构，此时也是低能量状态。受此启发，早期的模拟退火算法就是在高温中试图跳出局部最小。随机场作为物理模型之一，也引入了此方法。在马尔科夫随机场（MRF）中能量模型主要扮演着两个作用：一、全局解的度量（目标函数）；二、能量最小时的解（各种变量对应的配置）为目标解，能否把最优解嵌入到能量函数中至关重要，决定着我们具体问题求解的好坏。统计模式识别主要工作之一就是捕获变量之间的相关性，同样能量模型也要捕获变量之间的相关性，变量之间的相关程度决定了能量的高低。把变量的相关关系用图表示出来，并引入概率测度方式就够成了概率图模型的能量模型，其实实际中也可以不用概率表示，比如立体匹配中直接用两个像素点的像素差作为能量，所有像素对之间的能量和最小时的配置即为目标解。RBM作为一种概率图模型，引入概率就是为了方便采样，因为在CD（contrastive divergence）算法中采样部分扮演着模拟求解梯度的角色。


先来看一下RBM模型定义（图一）和能量的定义（公式一）：

      

（图一）      

              

（公式一）

        其中v表示实际样本节点，以下叫可视节点，h表示隐藏节点数据，theta=｛W,b,a｝,W表示网络权重，b表示可视节点偏移，a表示隐藏节点偏移。这些参数是需要我们求解的，一般开始时我们随机初始化这些参数，对于16*16的二值图像，可视节点有256个，每个节点可能的状态有两个（0，1）；隐藏节点的数目由自己制定，每个节点的状态也有两个（0，1）。当每个节点都有一个指定的状态时，此时的RBM有一个对应的能量。此时所有节点对应某个状态的组合成为一个配置。穷举所有配置对应的能量之和就构成了归一化常量Z（配分函数-partition function）。每个配置能量除以常量Z即为当前配置的概率。在一般计算时，为了避免数值计算问题，我们常常引入极家族函数(对数函数和指数函数)，那么模型概率定义为（公式二）：

  

（公式二）

        由于RBM是一种生成模型(generative model),我们的目标使得概率p(x)最大时对应的参数theta,常规思路应该使用最大似然法，在求最大似然函数的极值时，我们需要用到梯度法，梯度推导如（图二）所示（大家不要被公式吓倒，CD算法不用它，=、=，只是证明求梯度有点难度）：

（图二）

公式虽然这么写，但是实际中计算归一化分割函数Z时不可取的，因为组合状态是NP-complete的。但是这个公式给出了Contrastive divergence算法的原型（公式三）：

（公式三）

        alpha是学习率，括号中第一项是训练数据集期望分布，第二项是模型期望分布，CD算法的核心是计算（或逼近）出这两项的数值，下面分别说出下面计算上式中两个期望分布，需要用到采样方法（我先给出步骤，然后解释，步骤是大家最关心的）：

       第一项（数据相关期望项）：利用可视节点v1乘上权重，然后用sigmoid函数计算出隐藏节点h每个节点的概率，通过此概率对隐藏节点采样，得出隐藏节点状态h1，然后用能量公式计算出所有节点的期望能量(<v1*h1>)作为第一项。

       第二项（模型期望项）：根据第一项中隐藏节点h1乘上权重，然后用sigmoid函数计算出可视节点v2的概率，在此通过采样得出v2 状态，同样用v2计算出h2的状态，用能量公式计算出所有节点的期望能量(<v2*h2>)。套用上面公式，就可以求出deltaW,


      有了类梯度，那么就可以做权重更新咯，迭代就行了，b,a类似求解。
      这是用CD算法模拟梯度，关键在于使用什么采样方法，基于MCMC的各种采样方法(如Gibbs,MH,拒绝采样等)请酌情使用，深度理解采样方法有助于我们理解为什么CD可以模拟梯度，用hinton的话来说：这是个惊人的事实。我概括了这么一句话来给我们一个直观的理解：数据期望分布是我们整个数据的分布中心，可以看成最小点，模型期望是采样出来的，具有一定的随机性，分布在中心点周围，二者相减正好可以模拟梯度。其实求解参数theta的方法不止这一种，比如在Russlan的论文中也给出另外一种方法：用随机逼近过程来估计模型期望，用变分方法来估计数据相关期望等。碍于作者水平有限，就不讲了。 

     另外对DBN这个生成模型（generative model）对参数求导时，得出的结果也和CD公式相似，DBN的训练方法也可以用类似方法训练，具体可参考russlan的代码。

      DBM训练方法其实就是层层通过对RBM分别训练。对于russlan论文中提到的其他衍生应用和技巧大家可以根据自己所需详细阅读。比如估计分割函数（Z）是图模型里一个重要的基石部分；autoencoders的神奇作用其实是模拟了神经科学里神经分布式描述，相当于找到了低维流形；深度网络的微调部分(fine-tune),其实通过上述方法做了无监督预训练后，结合标签部分用BP等方法做了权重微更新，值得一提的识别可以用生成模型（generative model），也可以是判别模型(discriminative model),针对具体应用大家可以试着采用不同方法。
     我想我要说的基本说完了，整个深度学习除了需要概率图模型和神经网络基础支撑外，也用到了大量的trick。
     哦，对了，hinton也说过，神经网络几乎可以模拟现在绝大多数的机器学习方法，包括SVM,Adaboost,当然也包括概率图模型的那一套（其中有结构化学习），这有点把图模型收编的味道，作者视野有限，不敢不认同，也不敢认同。就讲到这里吧，作者写的轻浮一些，公式都是从别人paper上扣下来的，
而且作者水平有限，可能有些会说错,希望大家多多指正。

       最后附加一点：概率图模型的能量和概率之间的关系可以参阅gibbs measure和Hammersley–Clifford theorem，他们俩在能量模型到概率之间的转换上扮演着很重要的角色。还有为什么最大化P(x)或者p(v)可以使得能量最小？这个问题一开始我没搞明白，后来一个做事严谨网友（北流浪子）的花了好长时间找到答案，并且无私的与俺分享：对（图二）中的公式（5.7）两边同时取对数得到：lnp(v)=-FreeEnergy(v)-lnZ,这样当p(v)最大时，自由能FreeEnergy(v)最小，而自由能最小决定了系统达到统计平衡，详细可以参考：Gibbs free energy。

参考文献：

         [1]  Learning Deep Generative models.Ruslan Salakhutdinov

         [2]  Learning Deep Architectures for AI.Yoshua Bengio

         [3] A Tutorial on Energy-Based Models. yann lecun

DeepLearning（深度学习）原理与实现（二）

下面贴出RBM C++版本的代码，一些大牛写的，结合上篇博文来加深大家对RBM理论的理解。。。

RBM类定义声明：

[cpp]  view plain copy

1. class RBM {  
2.   
3. public:  
4.   int N;  
5.   int n_visible;  
6.   int n_hidden;  
7.   double **W;  
8.   double *hbias;  
9.   double *vbias;  
10.   RBM(int, int, int, double**, double*, double*);  
11.   ~RBM();  
12.   void contrastive_divergence(int*, double, int);  
13.   void sample_h_given_v(int*, double*, int*);  
14.   void sample_v_given_h(int*, double*, int*);  
15.   double propup(int*, double*, double);  
16.   double propdown(int*, int, double);  
17.   void gibbs_hvh(int*, double*, int*, double*, int*);  
18.   void reconstruct(int*, double*);  
19. };  

从上面声明中可以很直观的看出和上篇文章公式符号正好完美对应。下面是代码实现部分：

[cpp]  view plain copy

1.   

[cpp]  view plain copy

1. #include <iostream>  
2. #include <math.h>  
3. #include "RBM.h"  
4. using namespace std;  
5.   
6. double uniform(double min, double max) {  
7.   return rand() / (RAND_MAX + 1.0) * (max - min) + min;  
8. }  
9.   
10. int binomial(int n, double p) {  
11.   if(p < 0 || p > 1) return 0;  
12.     
13.   int c = 0;  
14.   double r;  
15.     
16.   for(int i=0; i<n; i++) {  
17.     r = rand() / (RAND_MAX + 1.0);  
18.     if (r < p) c++;  
19.   }  
20.   
21.   return c;  
22. }  
23.   
24. double sigmoid(double x) {  
25.   return 1.0 / (1.0 + exp(-x));  
26. }  
27.   
28.   
29. RBM::RBM(int size, int n_v, int n_h, double **w, double *hb, double *vb) {  
30.   N = size;  
31.   n_visible = n_v;  
32.   n_hidden = n_h;  
33.   
34.   if(w == NULL) {  
35.     W = new double*[n_hidden];  
36.     for(int i=0; i<n_hidden; i++) W[i] = new double[n_visible];  
37.     double a = 1.0 / n_visible;  
38.   
39.     for(int i=0; i<n_hidden; i++) {  
40.       for(int j=0; j<n_visible; j++) {  
41.         W[i][j] = uniform(-a, a);  
42.       }  
43.     }  
44.   } else {  
45.     W = w;  
46.   }  
47.   
48.   if(hb == NULL) {  
49.     hbias = new double[n_hidden];  
50.     for(int i=0; i<n_hidden; i++) hbias[i] = 0;  
51.   } else {  
52.     hbias = hb;  
53.   }  
54.   
55.   if(vb == NULL) {  
56.     vbias = new double[n_visible];  
57.     for(int i=0; i<n_visible; i++) vbias[i] = 0;  
58.   } else {  
59.     vbias = vb;  
60.   }  
61. }  
62.   
63. RBM::~RBM() {  
64.   for(int i=0; i<n_hidden; i++) delete[] W[i];  
65.   delete[] W;  
66.   delete[] hbias;  
67.   delete[] vbias;  
68. }  
69.   
70.   
71. void RBM::contrastive_divergence(int *input, double lr, int k) {  
72.   double *ph_mean = new double[n_hidden];  
73.   int *ph_sample = new int[n_hidden];  
74.   double *nv_means = new double[n_visible];  
75.   int *nv_samples = new int[n_visible];  
76.   double *nh_means = new double[n_hidden];  
77.   int *nh_samples = new int[n_hidden];  
78.   
79.   /* CD-k */  
80.   sample_h_given_v(input, ph_mean, ph_sample);  
81.   
82.   for(int step=0; step<k; step++) {  
83.     if(step == 0) {  
84.       gibbs_hvh(ph_sample, nv_means, nv_samples, nh_means, nh_samples);  
85.     } else {  
86.       gibbs_hvh(nh_samples, nv_means, nv_samples, nh_means, nh_samples);  
87.     }  
88.   }  
89.   
90.   for(int i=0; i<n_hidden; i++) {  
91.     for(int j=0; j<n_visible; j++) {  
92.       W[i][j] += lr * (ph_sample[i] * input[j] - nh_means[i] * nv_samples[j]) / N;  
93.     }  
94.     hbias[i] += lr * (ph_sample[i] - nh_means[i]) / N;  
95.   }  
96.   
97.   for(int i=0; i<n_visible; i++) {  
98.     vbias[i] += lr * (input[i] - nv_samples[i]) / N;  
99.   }  
100.   
101.   delete[] ph_mean;  
102.   delete[] ph_sample;  
103.   delete[] nv_means;  
104.   delete[] nv_samples;  
105.   delete[] nh_means;  
106.   delete[] nh_samples;  
107. }  
108.   
109. void RBM::sample_h_given_v(int *v0_sample, double *mean, int *sample) {  
110.   for(int i=0; i<n_hidden; i++) {  
111.     mean[i] = propup(v0_sample, W[i], hbias[i]);  
112.     sample[i] = binomial(1, mean[i]);  
113.   }  
114. }  
115.   
116. void RBM::sample_v_given_h(int *h0_sample, double *mean, int *sample) {  
117.   for(int i=0; i<n_visible; i++) {  
118.     mean[i] = propdown(h0_sample, i, vbias[i]);  
119.     sample[i] = binomial(1, mean[i]);  
120.   }  
121. }  
122.   
123. double RBM::propup(int *v, double *w, double b) {  
124.   double pre_sigmoid_activation = 0.0;  
125.   for(int j=0; j<n_visible; j++) {  
126.     pre_sigmoid_activation += w[j] * v[j];  
127.   }  
128.   pre_sigmoid_activation += b;  
129.   return sigmoid(pre_sigmoid_activation);  
130. }  
131.   
132. double RBM::propdown(int *h, int i, double b) {  
133.   double pre_sigmoid_activation = 0.0;  
134.   for(int j=0; j<n_hidden; j++) {  
135.     pre_sigmoid_activation += W[j][i] * h[j];  
136.   }  
137.   pre_sigmoid_activation += b;  
138.   return sigmoid(pre_sigmoid_activation);  
139. }  
140.   
141. void RBM::gibbs_hvh(int *h0_sample, double *nv_means, int *nv_samples, \  
142.                     double *nh_means, int *nh_samples) {  
143.   sample_v_given_h(h0_sample, nv_means, nv_samples);  
144.   sample_h_given_v(nv_samples, nh_means, nh_samples);  
145. }  
146.   
147. void RBM::reconstruct(int *v, double *reconstructed_v) {  
148.   double *h = new double[n_hidden];  
149.   double pre_sigmoid_activation;  
150.   
151.   for(int i=0; i<n_hidden; i++) {  
152.     h[i] = propup(v, W[i], hbias[i]);  
153.   }  
154.   
155.   for(int i=0; i<n_visible; i++) {  
156.     pre_sigmoid_activation = 0.0;  
157.     for(int j=0; j<n_hidden; j++) {  
158.       pre_sigmoid_activation += W[j][i] * h[j];  
159.     }  
160.     pre_sigmoid_activation += vbias[i];  
161.   
162.     reconstructed_v[i] = sigmoid(pre_sigmoid_activation);  
163.   }  
164.   
165.   delete[] h;  
166. }  
167.   
168.   
169. void test_rbm() {  
170.   srand(0);  
171.   
172.   double learning_rate = 0.1;  
173.   int training_epochs = 1000;  
174.   int k = 1;  
175.     
176.   int train_N = 6;  
177.   int test_N = 2;  
178.   int n_visible = 6;  
179.   int n_hidden = 3;  
180.   
181.   // training data  
182.   int train_X[6][6] = {  
183.     {1, 1, 1, 0, 0, 0},  
184.     {1, 0, 1, 0, 0, 0},  
185.     {1, 1, 1, 0, 0, 0},  
186.     {0, 0, 1, 1, 1, 0},  
187.     {0, 0, 1, 0, 1, 0},  
188.     {0, 0, 1, 1, 1, 0}  
189.   };  
190.   
191.   
192.   // construct RBM  
193.   RBM rbm(train_N, n_visible, n_hidden, NULL, NULL, NULL);  
194.   
195.   // train  
196.   for(int epoch=0; epoch<training_epochs; epoch++) {  
197.     for(int i=0; i<train_N; i++) {  
198.       rbm.contrastive_divergence(train_X[i], learning_rate, k);  
199.     }  
200.   }  
201.   
202.   // test data  
203.   int test_X[2][6] = {  
204.     {1, 1, 0, 0, 0, 0},  
205.     {0, 0, 0, 1, 1, 0}  
206.   };  
207.   double reconstructed_X[2][6];  
208.   
209.   
210.   // test  
211.   for(int i=0; i<test_N; i++) {  
212.     rbm.reconstruct(test_X[i], reconstructed_X[i]);  
213.     for(int j=0; j<n_visible; j++) {  
214.       printf("%.5f ", reconstructed_X[i][j]);  
215.     }  
216.     cout << endl;  
217.   }  
218.   
219. }  
220.   
221.   
222.   
223. int main() {  
224.   test_rbm();  
225.   return 0;  
226. }  

干脆把运行结果也贴出来，给那些终极极品思考者提供一些方便

0.98472  0.67248  0.99120  0.01000  0.01311  0.01020
0.01021  0.00720  0.99525  0.65553  0.98403  0.00497

DeepLearning（深度学习）原理与实现（三）

  考虑到大家有可能对深度学习的识别有点模糊，因此决定写一个短博客，简单介绍下如何识别，结合本系列的第一篇博文提到的深度学习之所以叫深度，其中之一的原因是多层RBM模仿了人脑多层神经元对输入数据进行层层预处理(值得一提的是并不是每层都是RBM，DBN就是个例外），即深层次的数据拟合，多个RBM连接起来构成DBM（deep boltzmann machines)，每层RBM的节点数自己指定，这需要一些经验,DBN和DBM在训练上没有区别，都是逐层使用CD算法训练，也叫贪心预训练算法，DBN和DBM的区别如（图一）所示。

图一

          对于二者都使用同一个算法来训练，看起来毫无区别，但是DBM有一个优势，由于RBM是无向的，这就决定了无论给定可视节点还是隐藏节点，各个节点都是独立的，可由图模型的马尔科夫性看出。作为无向图的DBM天生具有一些优秀的基因，比如当人看到一个外观性质，知道它是什么物体，同样你告诉他物体名字，他可以知道物体的外观应该是什么样子。这种互相推理的关系正好可以用无向图来表示。这种优势也顺理成章的延伸出了autoencoder（大家所谓的自编码神经网络）和栈式神经网络，最终输出的少量节点是可以推理（重建）出原来样本，也起到了降维的作用，无形中也找到了特征（编码），autoencoder的效果如图二所示。但是DBN中有些层是有向的，就不具有这种优势。

图二

           二者逐层预训练后，结合样本标签，使用BP算法进行权重微调，说白了就是在预训练后的权重基础上使用BP算法进行训练，这样得出的权重更好些。。。

下面贴出部分DBN代码，大家可以看出总体思路是按照构建DBN网络（刚构建后的每层的权重是随机生成的，从代码也能看出），贪心层层预训练，权重微调，预测（识别）这个步骤来的。另外代码中softmax其实是多变量的逻辑回归函数，注意我发的下面的代码中权重微调使用的是逻辑回归，不是BP：

[cpp]  view plain copy

1. #include <iostream>  
2. #include <math.h>  
3. #include "HiddenLayer.h"  
4. #include "RBM.h"  
5. #include "LogisticRegression.h"  
6. #include "DBN.h"  
7. using namespace std;  
8.   
9.   
10. double uniform(double min, double max) {  
11.   return rand() / (RAND_MAX + 1.0) * (max - min) + min;  
12. }  
13.   
14. int binomial(int n, double p) {  
15.   if(p < 0 || p > 1) return 0;  
16.     
17.   int c = 0;  
18.   double r;  
19.     
20.   for(int i=0; i<n; i++) {  
21.     r = rand() / (RAND_MAX + 1.0);  
22.     if (r < p) c++;  
23.   }  
24.   
25.   return c;  
26. }  
27.   
28. double sigmoid(double x) {  
29.   return 1.0 / (1.0 + exp(-x));  
30. }  
31.   
32.   
33. // DBN  
34. DBN::DBN(int size, int n_i, int *hls, int n_o, int n_l) {  
35.   int input_size;  
36.     
37.   N = size;  
38.   n_ins = n_i;  
39.   hidden_layer_sizes = hls;  
40.   n_outs = n_o;  
41.   n_layers = n_l;  
42.   
43.   sigmoid_layers = new HiddenLayer*[n_layers];  
44.   rbm_layers = new RBM*[n_layers];  
45.   
46.   // construct multi-layer  
47.   for(int i=0; i<n_layers; i++) {  
48.     if(i == 0) {  
49.       input_size = n_ins;  
50.     } else {  
51.       input_size = hidden_layer_sizes[i-1];  
52.     }  
53.   
54.     // construct sigmoid_layer  
55.     sigmoid_layers[i] = new HiddenLayer(N, input_size, hidden_layer_sizes[i], NULL, NULL);  
56.   
57.     // construct rbm_layer  
58.     rbm_layers[i] = new RBM(N, input_size, hidden_layer_sizes[i],\  
59.                             sigmoid_layers[i]->W, sigmoid_layers[i]->b, NULL);  
60.   }  
61.   
62.   // layer for output using LogisticRegression  
63.   log_layer = new LogisticRegression(N, hidden_layer_sizes[n_layers-1], n_outs);  
64. }  
65.   
66. DBN::~DBN() {  
67.   delete log_layer;  
68.   
69.   for(int i=0; i<n_layers; i++) {  
70.     delete sigmoid_layers[i];  
71.     delete rbm_layers[i];  
72.   }  
73.   delete[] sigmoid_layers;  
74.   delete[] rbm_layers;  
75. }  
76.   
77.   
78. void DBN::pretrain(int *input, double lr, int k, int epochs) {  
79.   int *layer_input;  
80.   int prev_layer_input_size;  
81.   int *prev_layer_input;  
82.   
83.   int *train_X = new int[n_ins];  
84.   
85.   for(int i=0; i<n_layers; i++) {  // layer-wise  
86.   
87.     for(int epoch=0; epoch<epochs; epoch++) {  // training epochs  
88.   
89.       for(int n=0; n<N; n++) { // input x1...xN  
90.         // initial input  
91.         for(int m=0; m<n_ins; m++) train_X[m] = input[n * n_ins + m];  
92.   
93.         // layer input  
94.         for(int l=0; l<=i; l++) {  
95.   
96.           if(l == 0) {  
97.             layer_input = new int[n_ins];  
98.             for(int j=0; j<n_ins; j++) layer_input[j] = train_X[j];  
99.           } else {  
100.             if(l == 1) prev_layer_input_size = n_ins;  
101.             else prev_layer_input_size = hidden_layer_sizes[l-2];  
102.   
103.             prev_layer_input = new int[prev_layer_input_size];  
104.             for(int j=0; j<prev_layer_input_size; j++) prev_layer_input[j] = layer_input[j];  
105.             delete[] layer_input;  
106.   
107.             layer_input = new int[hidden_layer_sizes[l-1]];  
108.   
109.             sigmoid_layers[l-1]->sample_h_given_v(prev_layer_input, layer_input);  
110.             delete[] prev_layer_input;  
111.           }  
112.         }  
113.   
114.         rbm_layers[i]->contrastive_divergence(layer_input, lr, k);  
115.       }  
116.   
117.     }  
118.   }  
119.   
120.   delete[] train_X;  
121.   delete[] layer_input;  
122. }  
123.   
124. void DBN::finetune(int *input, int *label, double lr, int epochs) {  
125.   int *layer_input;  
126.   // int prev_layer_input_size;  
127.   int *prev_layer_input;  
128.   
129.   int *train_X = new int[n_ins];  
130.   int *train_Y = new int[n_outs];  
131.   
132.   for(int epoch=0; epoch<epochs; epoch++) {  
133.     for(int n=0; n<N; n++) { // input x1...xN  
134.       // initial input  
135.       for(int m=0; m<n_ins; m++)  train_X[m] = input[n * n_ins + m];  
136.       for(int m=0; m<n_outs; m++) train_Y[m] = label[n * n_outs + m];  
137.   
138.       // layer input  
139.       for(int i=0; i<n_layers; i++) {  
140.         if(i == 0) {  
141.           prev_layer_input = new int[n_ins];  
142.           for(int j=0; j<n_ins; j++) prev_layer_input[j] = train_X[j];  
143.         } else {  
144.           prev_layer_input = new int[hidden_layer_sizes[i-1]];  
145.           for(int j=0; j<hidden_layer_sizes[i-1]; j++) prev_layer_input[j] = layer_input[j];  
146.           delete[] layer_input;  
147.         }  
148.   
149.   
150.         layer_input = new int[hidden_layer_sizes[i]];  
151.         sigmoid_layers[i]->sample_h_given_v(prev_layer_input, layer_input);  
152.         delete[] prev_layer_input;  
153.       }  
154.   
155.       log_layer->train(layer_input, train_Y, lr);  
156.     }  
157.     // lr *= 0.95;  
158.   }  
159.   
160.   delete[] layer_input;  
161.   delete[] train_X;  
162.   delete[] train_Y;  
163. }  
164.   
165. void DBN::predict(int *x, double *y) {  
166.   double *layer_input;  
167.   // int prev_layer_input_size;  
168.   double *prev_layer_input;  
169.   
170.   double linear_output;  
171.   
172.   prev_layer_input = new double[n_ins];  
173.   for(int j=0; j<n_ins; j++) prev_layer_input[j] = x[j];  
174.   
175.   // layer activation  
176.   for(int i=0; i<n_layers; i++) {  
177.     layer_input = new double[sigmoid_layers[i]->n_out];  
178.   
179.     for(int k=0; k<sigmoid_layers[i]->n_out; k++) {  
180.      // linear_output = 0.0;  //原代码中删除此句  
181.   
182.       for(int j=0; j<sigmoid_layers[i]->n_in; j++) {  
183.            linear_output = 0.0;   //原代码中添加此句  
184.         linear_output += sigmoid_layers[i]->W[k][j] * prev_layer_input[j];  
185.       }  
186.       linear_output += sigmoid_layers[i]->b[k];  
187.       layer_input[k] = sigmoid(linear_output);  
188.     }  
189.     delete[] prev_layer_input;  
190.   
191.     if(i < n_layers-1) {  
192.       prev_layer_input = new double[sigmoid_layers[i]->n_out];  
193.       for(int j=0; j<sigmoid_layers[i]->n_out; j++) prev_layer_input[j] = layer_input[j];  
194.       delete[] layer_input;  
195.     }  
196.   }  
197.     
198.   for(int i=0; i<log_layer->n_out; i++) {  
199.     y[i] = 0;  
200.     for(int j=0; j<log_layer->n_in; j++) {  
201.       y[i] += log_layer->W[i][j] * layer_input[j];  
202.     }  
203.     y[i] += log_layer->b[i];  
204.   }  
205.     
206.   log_layer->softmax(y);  
207.   
208.   
209.   delete[] layer_input;  
210. }  
211.   
212.   
213. // HiddenLayer  
214. HiddenLayer::HiddenLayer(int size, int in, int out, double **w, double *bp) {  
215.   N = size;  
216.   n_in = in;  
217.   n_out = out;  
218.   
219.   if(w == NULL) {  
220.     W = new double*[n_out];  
221.     for(int i=0; i<n_out; i++) W[i] = new double[n_in];  
222.     double a = 1.0 / n_in;  
223.   
224.     for(int i=0; i<n_out; i++) {  
225.       for(int j=0; j<n_in; j++) {  
226.         W[i][j] = uniform(-a, a);  
227.       }  
228.     }  
229.   } else {  
230.     W = w;  
231.   }  
232.   
233.   if(bp == NULL) {  
234.     b = new double[n_out];  
235.   } else {  
236.     b = bp;  
237.   }  
238. }  
239.   
240. HiddenLayer::~HiddenLayer() {  
241.   for(int i=0; i<n_out; i++) delete W[i];  
242.   delete[] W;  
243.   delete[] b;  
244. }  
245.   
246. double HiddenLayer::output(int *input, double *w, double b) {  
247.   double linear_output = 0.0;  
248.   for(int j=0; j<n_in; j++) {  
249.     linear_output += w[j] * input[j];  
250.   }  
251.   linear_output += b;  
252.   return sigmoid(linear_output);  
253. }  
254.   
255. void HiddenLayer::sample_h_given_v(int *input, int *sample) {  
256.   for(int i=0; i<n_out; i++) {  
257.     sample[i] = binomial(1, output(input, W[i], b[i]));  
258.   }  
259. }  
260.   
261.   
262. // RBM   
263. RBM::RBM(int size, int n_v, int n_h, double **w, double *hb, double *vb) {  
264.   N = size;  
265.   n_visible = n_v;  
266.   n_hidden = n_h;  
267.   
268.   if(w == NULL) {  
269.     W = new double*[n_hidden];  
270.     for(int i=0; i<n_hidden; i++) W[i] = new double[n_visible];  
271.     double a = 1.0 / n_visible;  
272.   
273.     for(int i=0; i<n_hidden; i++) {  
274.       for(int j=0; j<n_visible; j++) {  
275.         W[i][j] = uniform(-a, a);  
276.       }  
277.     }  
278.   } else {  
279.     W = w;  
280.   }  
281.   
282.   if(hb == NULL) {  
283.     hbias = new double[n_hidden];  
284.     for(int i=0; i<n_hidden; i++) hbias[i] = 0;  
285.   } else {  
286.     hbias = hb;  
287.   }  
288.   
289.   if(vb == NULL) {  
290.     vbias = new double[n_visible];  
291.     for(int i=0; i<n_visible; i++) vbias[i] = 0;  
292.   } else {  
293.     vbias = vb;  
294.   }  
295. }  
296.   
297. RBM::~RBM() {  
298.   // for(int i=0; i<n_hidden; i++) delete[] W[i];  
299.   // delete[] W;  
300.   // delete[] hbias;  
301.   delete[] vbias;  
302. }  
303.   
304.   
305. void RBM::contrastive_divergence(int *input, double lr, int k) {  
306.   double *ph_mean = new double[n_hidden];  
307.   int *ph_sample = new int[n_hidden];  
308.   double *nv_means = new double[n_visible];  
309.   int *nv_samples = new int[n_visible];  
310.   double *nh_means = new double[n_hidden];  
311.   int *nh_samples = new int[n_hidden];  
312.   
313.   /* CD-k */  
314.   sample_h_given_v(input, ph_mean, ph_sample);  
315.   
316.   for(int step=0; step<k; step++) {  
317.     if(step == 0) {  
318.       gibbs_hvh(ph_sample, nv_means, nv_samples, nh_means, nh_samples);  
319.     } else {  
320.       gibbs_hvh(nh_samples, nv_means, nv_samples, nh_means, nh_samples);  
321.     }  
322.   }  
323.   
324.   for(int i=0; i<n_hidden; i++) {  
325.     for(int j=0; j<n_visible; j++) {  
326.       W[i][j] += lr * (ph_sample[i] * input[j] - nh_means[i] * nv_samples[j]) / N;  
327.     }  
328.     hbias[i] += lr * (ph_sample[i] - nh_means[i]) / N;  
329.   }  
330.   
331.   for(int i=0; i<n_visible; i++) {  
332.     vbias[i] += lr * (input[i] - nv_samples[i]) / N;  
333.   }  
334.   
335.   delete[] ph_mean;  
336.   delete[] ph_sample;  
337.   delete[] nv_means;  
338.   delete[] nv_samples;  
339.   delete[] nh_means;  
340.   delete[] nh_samples;  
341. }  
342.   
343. void RBM::sample_h_given_v(int *v0_sample, double *mean, int *sample) {  
344.   for(int i=0; i<n_hidden; i++) {  
345.     mean[i] = propup(v0_sample, W[i], hbias[i]);  
346.     sample[i] = binomial(1, mean[i]);  
347.   }  
348. }  
349.   
350. void RBM::sample_v_given_h(int *h0_sample, double *mean, int *sample) {  
351.   for(int i=0; i<n_visible; i++) {  
352.     mean[i] = propdown(h0_sample, i, vbias[i]);  
353.     sample[i] = binomial(1, mean[i]);  
354.   }  
355. }  
356.   
357. double RBM::propup(int *v, double *w, double b) {  
358.   double pre_sigmoid_activation = 0.0;  
359.   for(int j=0; j<n_visible; j++) {  
360.     pre_sigmoid_activation += w[j] * v[j];  
361.   }  
362.   pre_sigmoid_activation += b;  
363.   return sigmoid(pre_sigmoid_activation);  
364. }  
365.   
366. double RBM::propdown(int *h, int i, double b) {  
367.   double pre_sigmoid_activation = 0.0;  
368.   for(int j=0; j<n_hidden; j++) {  
369.     pre_sigmoid_activation += W[j][i] * h[j];  
370.   }  
371.   pre_sigmoid_activation += b;  
372.   return sigmoid(pre_sigmoid_activation);  
373. }  
374.   
375. void RBM::gibbs_hvh(int *h0_sample, double *nv_means, int *nv_samples, \  
376.                     double *nh_means, int *nh_samples) {  
377.   sample_v_given_h(h0_sample, nv_means, nv_samples);  
378.   sample_h_given_v(nv_samples, nh_means, nh_samples);  
379. }  
380.   
381. void RBM::reconstruct(int *v, double *reconstructed_v) {  
382.   double *h = new double[n_hidden];  
383.   double pre_sigmoid_activation;  
384.   
385.   for(int i=0; i<n_hidden; i++) {  
386.     h[i] = propup(v, W[i], hbias[i]);  
387.   }  
388.   
389.   for(int i=0; i<n_visible; i++) {  
390.     pre_sigmoid_activation = 0.0;  
391.     for(int j=0; j<n_hidden; j++) {  
392.       pre_sigmoid_activation += W[j][i] * h[j];  
393.     }  
394.     pre_sigmoid_activation += vbias[i];  
395.   
396.     reconstructed_v[i] = sigmoid(pre_sigmoid_activation);  
397.   }  
398.   
399.   delete[] h;  
400. }  
401.   
402.   
403. // LogisticRegression  
404. LogisticRegression::LogisticRegression(int size, int in, int out) {  
405.   N = size;  
406.   n_in = in;  
407.   n_out = out;  
408.   
409.   W = new double*[n_out];  
410.   for(int i=0; i<n_out; i++) W[i] = new double[n_in];  
411.   b = new double[n_out];  
412.   
413.   for(int i=0; i<n_out; i++) {  
414.     for(int j=0; j<n_in; j++) {  
415.       W[i][j] = 0;  
416.     }  
417.     b[i] = 0;  
418.   }  
419. }  
420.   
421. LogisticRegression::~LogisticRegression() {  
422.   for(int i=0; i<n_out; i++) delete[] W[i];  
423.   delete[] W;  
424.   delete[] b;  
425. }  
426.   
427.   
428. void LogisticRegression::train(int *x, int *y, double lr) {  
429.   double *p_y_given_x = new double[n_out];  
430.   double *dy = new double[n_out];  
431.   
432.   for(int i=0; i<n_out; i++) {  
433.     p_y_given_x[i] = 0;  
434.     for(int j=0; j<n_in; j++) {  
435.       p_y_given_x[i] += W[i][j] * x[j];  
436.     }  
437.     p_y_given_x[i] += b[i];  
438.   }  
439.   softmax(p_y_given_x);  
440.   
441.   for(int i=0; i<n_out; i++) {  
442.     dy[i] = y[i] - p_y_given_x[i];  
443.   
444.     for(int j=0; j<n_in; j++) {  
445.       W[i][j] += lr * dy[i] * x[j] / N;  
446.     }  
447.   
448.     b[i] += lr * dy[i] / N;  
449.   }  
450.     
451.   delete[] p_y_given_x;  
452.   delete[] dy;  
453. }  
454.   
455. void LogisticRegression::softmax(double *x) {  
456.   double max = 0.0;  
457.   double sum = 0.0;  
458.     
459.   for(int i=0; i<n_out; i++) if(max < x[i]) max = x[i];  
460.   for(int i=0; i<n_out; i++) {  
461.     x[i] = exp(x[i] - max);  
462.     sum += x[i];  
463.   }   
464.   
465.   for(int i=0; i<n_out; i++) x[i] /= sum;  
466. }  
467.   
468. void LogisticRegression::predict(int *x, double *y) {  
469.   for(int i=0; i<n_out; i++) {  
470.     y[i] = 0;  
471.     for(int j=0; j<n_in; j++) {  
472.       y[i] += W[i][j] * x[j];  
473.     }  
474.     y[i] += b[i];  
475.   }  
476.   
477.   softmax(y);  
478. }  
479.   
480.   
481.   
482.   
483.   
484. void test_dbn() {  
485.   srand(0);  
486.   
487.   double pretrain_lr = 0.1;  
488.   int pretraining_epochs = 1000;  
489.   int k = 1;  
490.   double finetune_lr = 0.1;  
491.   int finetune_epochs = 500;  
492.   
493.   int train_N = 6;  
494.   int test_N = 3;  
495.   int n_ins = 6;  
496.   int n_outs = 2;  
497.   int hidden_layer_sizes[] = {3, 3};  
498.   int n_layers = sizeof(hidden_layer_sizes) / sizeof(hidden_layer_sizes[0]);  
499.   
500.   // training data  
501.   int train_X[6][6] = {  
502.     {1, 1, 1, 0, 0, 0},  
503.     {1, 0, 1, 0, 0, 0},  
504.     {1, 1, 1, 0, 0, 0},  
505.     {0, 0, 1, 1, 1, 0},  
506.     {0, 0, 1, 1, 0, 0},  
507.     {0, 0, 1, 1, 1, 0}  
508.   };  
509.   
510.   int train_Y[6][2] = {  
511.     {1, 0},  
512.     {1, 0},  
513.     {1, 0},  
514.     {0, 1},  
515.     {0, 1},  
516.     {0, 1}  
517.   };  
518.   
519.   
520.     
521.   // construct DBN  
522.   DBN dbn(train_N, n_ins, hidden_layer_sizes, n_outs, n_layers);  
523.   
524.   // pretrain  
525.   dbn.pretrain(*train_X, pretrain_lr, k, pretraining_epochs);  
526.   
527.   // finetune  
528.   dbn.finetune(*train_X, *train_Y, finetune_lr, finetune_epochs);  
529.     
530.   
531.   // test data  
532.   int test_X[3][6] = {  
533.     {1, 1, 0, 0, 0, 0},  
534.     {0, 0, 0, 1, 1, 0},  
535.     {1, 1, 1, 1, 1, 0}  
536.   };  
537.   
538.   double test_Y[3][2];  
539.   
540.   
541.   // test  
542.   for(int i=0; i<test_N; i++) {  
543.     dbn.predict(test_X[i], test_Y[i]);  
544.     for(int j=0; j<n_outs; j++) {  
545.       cout << test_Y[i][j] << " ";  
546.     }  
547.     cout << endl;  
548.   }  
549.   
550. }  
551.   
552.   
553.   
554.   
555.   
556. int main() {  
557.   test_dbn();  
558.   return 0;  
559. }  

[cpp]  view plain copy

1. <pre></pre>  
2. <p>程序运行结果，是个二维

DeepLearning（深度学习）原理与实现（四）

   今天就来讨论下deep learning怎么来处理real valued data。对于图像来说，二值图像毕竟是少数，更多的还是实值图像。对于这样的情况，RBM已经无法很好的处理它们，因此需要改进它，对于了解计算机视觉的人而言，想必高斯混合背景模型大家已不陌生，高斯混合模型可以很好的对实值图像建模，OpenCV中早就用高斯混合背景模型来分割物体。接下来要引出的高斯有限制玻尔兹曼机（Gaussian Restricted Boltzmann machine-GRBM）和高斯混合模型有一定的等价性。

      在上一节中，作者提到过对于RBM这个无向图模型而言，无论是给定隐藏节点还是可视节点，剩下的那层内节点之间互相独立。那么对于RBM这个图模型描述的联合分布可以分解成（公式一）的形式：

（公式一）

       其中P（h）可看成高斯混合系数，如果P(v|h)是高斯分布，那么这个条件下的RBM就和高斯混合分布具有等价性。因此GRBM合理登场 ,下面开始进入GRBM正题,首先当然要假定P(v|h)服从高斯分布，不然没法进展下去咯，先来看下GRBM的能量公式定义（公式二）：

（公式二）

       

        从能量公式中可以很明显的看出有高斯分布的影子，当然还有其他类型的能量公式，关键看你做什么假设，假设不一样，能量公式也不一样，假设的好就会产生一篇好文章哦。其中参数要求的为：。求取算法和此系列文章一方法类似，也是用CD算法，但是对于GRBM的CD算法，需要多啰嗦几句，首先我们把博文一中的求取数据期望项和模型期望项的过程改成官方称呼：分别对应为正阶段(positive phase)和负阶段(negative phase)。

     

         正阶段的目的就是找到给定数据的情况下，隐藏节点的配置（暂称它为"好配置"），并且使得能量降低。负阶段的目的当然就是抬升"好配置"周围的配置的能量，可能有点拗口，推荐看下博文一中的参考文献：Energy based model tutorial，可以把它总结成一句话：把和实际样本有关的配置能量降低，把fancy的样本的能量抬高，这样得到的权重是对样本的最佳描述，当然样本越多越好，所以大数据这么火。有些人会有疑问，样本多会不会导致过拟合？其实生成模型的魅力之一就在这，样本越多越好。正阶段中隐藏节点h的状态求取仍然用sigmoid函数得出概率，然后采样；但是负阶段中可视节点V的状态的概率就不是用sigmoid函数了，而是用高斯函数，二者的公式分别如（公式三）和（公式四）表示：

  

（公式三,f为sigmoid函数）

（公式四，高斯分布函数）

        对于参数的求取，过程只是多了sigma而已，如果你熟悉高斯混合模型，自然对sigma的实际作用也有些直观认识，庆幸的是sigma仍然也可以在CD算法中与其他参数一样同时求出来。下面给出GRBM中CD算法的部分代码(matlab)，其中invfstdInc为sigma，不要用用这段代码，而是用它解释自己对GRBM实现细节的疑问，这段代码中，CD算法引入了momentum(冲量）技巧，可以让算法收敛快些：

[plain]  view plain copy

1. %%%%%%%%% START POSITIVE PHASE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  
2.        data = batchdata(:,:,batch); %nxd       
3.        pos_hidprobs = 1./(1 + exp(-(data./Fstd)*vhW - Ones*hb)); %p(h_j =1|data)          
4.        pos_hidstates = pos_hidprobs > rand( size(pos_hidprobs) );  
5.                  
6.        pos_prods    = (data./Fstd)'* pos_hidprobs;  
7.        pos_hid_act  = sum(pos_hidprobs);  
8.        pos_vis_act  = sum(data)./(fstd.^2); %see notes on this derivation  
9.                 
10.        %%%%%%%%% END OF POSITIVE PHASE %%%%%%%%%  
11.        for iterCD = 1:params.nCD  
12.              
13.            %%%%%%%%% START NEGATIVE PHASE  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  
14.            negdataprobs = pos_hidstates*vhW'.*Fstd+Ones*vb;  
15.            negdata = negdataprobs + randn(n, d).*Fstd;  
16.            neg_hidprobs = 1./(1 + exp(-(negdata./Fstd)*vhW - Ones*hb ));     %updating hidden nodes again  
17.            pos_hidstates = neg_hidprobs > rand( size(neg_hidprobs) );  
18.              
19.        end %end CD iterations  
20.         
21.        neg_prods  = (negdata./Fstd)'*neg_hidprobs;  
22.        neg_hid_act = sum(neg_hidprobs);  
23.        neg_vis_act = sum(negdata)./(fstd.^2); %see notes for details  
24.          
25.        %%%%%%%%% END OF NEGATIVE PHASE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%          
26.                 
27.        errsum = errsum + sum(sum( (data-negdata).^2 ));  
28.          
29.        if epoch > params.init_final_momen_iter,  
30.            momentum=params.final_momen;  
31.        else  
32.            momentum=params.init_momen;  
33.        end  
34.          
35.        %%%%%%%%% UPDATE WEIGHTS AND BIASES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  
36.          
37.        vhWInc = momentum*vhWInc + r/n*(pos_prods-neg_prods) - r*params.wtcost*vhW;  
38.        vbInc = momentum*vbInc + (r/n)*(pos_vis_act-neg_vis_act);  
39.        hbInc = momentum*hbInc + (r/n)*(pos_hid_act-neg_hid_act);  
40.          
41.        invfstd_grad = sum(2*data.*(Ones*vb-data/2)./Fstd,1) + sum(data' .* (vhW*pos_hidprobs') ,2)';  
42.        invfstd_grad = invfstd_grad - ( sum(2*negdata.*(Ones*vb-negdata/2)./Fstd,1) + ...  
43.                                sum( negdata'.*(vhW*neg_hidprobs') ,2 )' );  
44.                              
45.        invfstdInc = momentum*invfstdInc + std_rate(epoch)/n*invfstd_grad;  
46.                 
47.        if params.SPARSE == 1 %nair's paper on 3D object recognition              
48.            %update q  
49.            if batch==1 && epoch == 1  
50.                q = mean(pos_hidprobs);  
51.            else  
52.                q_prev = q;  
53.                q = 0.9*q_prev+0.1*mean(pos_hidprobs);  
54.            end             
55.             
56.            p = params.sparse_p;  
57.            grad = 0.1*params.sparse_lambda/n*sum(pos_hidprobs.*(1-pos_hidprobs)).*(p-q)./(q.*(1-q));  
58.            gradW =0.1*params.sparse_lambda/n*(data'./Fstd'*(pos_hidprobs.*(1-pos_hidprobs))).*repmat((p-q)./(q.*(1-q)), d,1);  
59.              
60.            hbInc = hbInc + r*grad;  
61.            vhWInc = vhWInc + r*gradW;  
62.        end  
63.          
64.        ptot = ptot+mean(pos_hidprobs(:));  
65.          
66.        vhW = vhW + vhWInc;  
67.        vb = vb + vbInc;  
68.        hb = hb + hbInc;      
69.          
70.        invfstd = 1./fstd;  
71.        invfstd =  invfstd + invfstdInc;  
72.        fstd = 1./invfstd;  
73.   
74.        fstd = max(fstd, 0.005); %have a lower bound!     

    最后来一句：别忘了这是单层GRBM，深度学习需要多层的，GDBM，读者可以畅想其魅力，尽管如此，作者仍然要保持开拓的姿态，这个模型还不能处理大脑联想这样一个简单功能。

参考文献：
     Guassian-Bernoulli Deep Boltzmann Machine. KyungHyun Cho

DeepLearning（深度学习）原理与实现（五）

结构决定功能和协同处理：鲁棒有限制玻尔兹曼机(RoBM）

     上一篇博文中提到，GRBM训练样本越多越好，样本多蕴含的分布更具有一般性，这对其他模型也适用。但是实际样本数据中往往有大量的噪声，这或多或少的影响了GRBM的性能，工业界一般都设有清洗数据的岗位，用人脑去除噪声数据。试想：人脑为什么具有如此强大的抗噪和容错能力？其实生命科学中有一句经典的总结：结构决定功能。不同的结构的网络具有不同的功能，下面要引入的鲁棒玻尔兹曼机（Robust boltzmann machine-RoBM）就是一个很好的例证。RoBM由GRBM和RBM组成，确切的说还有一个成分：选择门。对于这个模型我不想说它怎么训练的咯，因为GRBM和RBM的训练方法前面都说过了，我只想强调下“结构决定功能”怎么体现在概率图模型上。RoBM的模型如（图一）所示：

（图一）

       在给定V-tilde(tilde就是V头上的波浪号哈，表示输入节点像素)时，S和V是独立的，同样G和H是独立的，对于GRBM和RBM的节点独立前面也已经讨论过。由于这些独立性再结合对于我们问题有利的假设（如高斯分布），能量函数定义就出来了,（对于能量函数的定义，也可以用概率图模型的clque(团)来解释，其实也是变量间的独立关系决定）。RoBM的能量函数如（公式一）所示：

（公式一）

         上面公式的第一行就是牵扯到变量S,V和V-tilde的选择门项，这项其实就决定选择门的功能，控制信号的输入，比如当S等于0时，随你V和V-tilde怎么变，这块能量不会太高；当S等于1时，gamma的平方控制着V和V-tilde的差异程度，如果二者差异太大，这块能量就会偏高。

         第二行就是关于噪声S的RBM能量项（和RBM的能量公式是一样的），它控制着模型和噪声的关系，S是一个指示变量，表示该样本是否“应该”有噪声（“是否应该”这是个配置，有系统来完成）。

         第三行当然就是干净数据V的GRBM能量项了（和GRBM的能量公式是一样的），他控制着模型和干净数据的关系。

        第四行就是噪声的分布，假设噪声成高斯分布。

 

        这个模型的高明之处就是它先分工了噪声去除和鉴别样本是否有噪声，然后在总体框架上协调完成他们，每行的能量项分别完成某个功能，而总体能量又协调他们做的最好，形成最佳搭档。至于训练，先是用干净数据训练GRBM，然后在训练总体模型，中间的采样还跟前面有点不一样，具体看参考文献的推理(Inference)部分。实验效果如（图二）所示

（图二）

        由（图二）可以看出这个模型对输入有噪声的数据不但分离出噪声，也重建出了干净数据，最近比较有意思的是剑桥大学发布的那几个有错误的句子和段落，人脑同样可以正确的阅读他们，大脑是否是类似这样一个过程呢？开放话题，尚无结论。本来不打算写这个deep learning的应用，但是国内最大的自然语言处理群内的成员们热情的讨论勾引了俺的兴趣，要感谢他们一下哈,另外这个模型的代码有点复杂，就不贴了，作者主页也挂出来了哈。

参考文献：

Robust Boltzmann Machines for Recognition and Denoising.Yi chuanTang,Ruslan,Geoffery Hinton