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：

#include 
#include 
#include "HiddenLayer.h"
#include "RBM.h"
#include "LogisticRegression.h"
#include "DBN.h"
using namespace std;


double uniform(double min, double max) {
  return rand() / (RAND_MAX + 1.0) * (max - min) + min;
}

int binomial(int n, double p) {
  if(p < 0 || p > 1) return 0;
  
  int c = 0;
  double r;
  
  for(int i=0; iW, sigmoid_layers[i]->b, NULL);
  }

  // layer for output using LogisticRegression
  log_layer = new LogisticRegression(N, hidden_layer_sizes[n_layers-1], n_outs);
}

DBN::~DBN() {
  delete log_layer;

  for(int i=0; isample_h_given_v(prev_layer_input, layer_input);
            delete[] prev_layer_input;
          }
        }

        rbm_layers[i]->contrastive_divergence(layer_input, lr, k);
      }

    }
  }

  delete[] train_X;
  delete[] layer_input;
}

void DBN::finetune(int *input, int *label, double lr, int epochs) {
  int *layer_input;
  // int prev_layer_input_size;
  int *prev_layer_input;

  int *train_X = new int[n_ins];
  int *train_Y = new int[n_outs];

  for(int epoch=0; epochsample_h_given_v(prev_layer_input, layer_input);
        delete[] prev_layer_input;
      }

      log_layer->train(layer_input, train_Y, lr);
    }
    // lr *= 0.95;
  }

  delete[] layer_input;
  delete[] train_X;
  delete[] train_Y;
}

void DBN::predict(int *x, double *y) {
  double *layer_input;
  // int prev_layer_input_size;
  double *prev_layer_input;

  double linear_output;

  prev_layer_input = new double[n_ins];
  for(int j=0; jn_out];

    for(int k=0; kn_out; k++) {
     // linear_output = 0.0;  //原代码中删除此句

      for(int j=0; jn_in; j++) {
		   linear_output = 0.0;   //原代码中添加此句
        linear_output += sigmoid_layers[i]->W[k][j] * prev_layer_input[j];
      }
      linear_output += sigmoid_layers[i]->b[k];
      layer_input[k] = sigmoid(linear_output);
    }
    delete[] prev_layer_input;

    if(i < n_layers-1) {
      prev_layer_input = new double[sigmoid_layers[i]->n_out];
      for(int j=0; jn_out; j++) prev_layer_input[j] = layer_input[j];
      delete[] layer_input;
    }
  }
  
  for(int i=0; in_out; i++) {
    y[i] = 0;
    for(int j=0; jn_in; j++) {
      y[i] += log_layer->W[i][j] * layer_input[j];
    }
    y[i] += log_layer->b[i];
  }
  
  log_layer->softmax(y);


  delete[] layer_input;
}


// HiddenLayer
HiddenLayer::HiddenLayer(int size, int in, int out, double **w, double *bp) {
  N = size;
  n_in = in;
  n_out = out;

  if(w == NULL) {
    W = new double*[n_out];
    for(int i=0; i

程序运行结果，是个二维的回归值：

0.493724  0.5062760.493724  0.5062760.493724  0.506276

转载请注明出处：http://blog.csdn.net/cuoqu/article/details/8896636