C++实现

C++实现深度信念网dbn.h#ifndef DBN_H#define DBN_H#include "hiddenlayer.h"#include "logisticregression.h"#include "rbm.h"typedef struct{int N; //训练样例数int n_ins; //输入单元数int *hidden_layer_sizes; //各隐层的单元数int n_outs; //输出单元数int n_layers; //隐层数HiddenLayer *sigmoid_layers; //隐层RBM *rbm_layers; //RBMLogisticRegression log_layer; //最上层，用来分类} DBN;void DBN__construct(DBN*, int, int, int*, int, int);void DBN__destruct(DBN*);void DBN_pretrain(DBN*, int*, double, int, int);void DBN_finetune(DBN*, int*, int*, double, int);void DBN_predict(DBN*, int*, double*);#endifdbn.cpp#include "dbn.h"//构建深度信念网DBNvoid DBN__construct(DBN* dbn, int N, \int n_ins, int *hidden_layer_sizes, int n_outs, int n_layers) {int i, input_size;dbn->N = N; //训练样例数目dbn->n_ins = n_ins; //输入单元数dbn->hidden_layer_sizes = hidden_layer_sizes; //各隐层的单元数dbn->n_outs = n_outs; //输出单元数dbn->n_layers = n_layers; //隐层数dbn->sigmoid_layers = new HiddenLayer[n_layers];dbn->rbm_layers = new RBM[n_layers];// 创建层for(i=0; i<n_layers; i++){if(i == 0) //如果是第一层{input_size = n_ins; //该层输入单元数= 实际输入单元数}else //否则，该层输入单元数= 上一层的输出单元数{input_size = hidden_layer_sizes[i-1];}// 构建sigmoid_layerHiddenLayer__construct(&(dbn->sigmoid_layers[i]), \N, input_size, hidden_layer_sizes[i], NULL, NULL);// 构建rbm_layerRBM__construct(&(dbn->rbm_layers[i]), N, input_size, hidden_layer_sizes[i], \ dbn->sigmoid_layers[i].W, dbn->sigmoid_layers[i].b, NULL);}// 输出层使用LogisticRegressionLogisticRegression__construct(&(dbn->log_layer), \N, hidden_layer_sizes[n_layers-1], n_outs);}//析构void DBN__destruct(DBN* dbn){/*for(int i=0; i<dbn->n_layers; i++){HiddenLayer__destruct(&(dbn->sigmoid_layers[i]));RBM__destruct(&(dbn->rbm_layers[i]));}*/delete dbn->sigmoid_layers;delete dbn->rbm_layers;}//预训练使用非监督贪婪逐层方法去预训练获得权值/*1. 首先充分训练第一个RBM；2. 固定第一个RBM 的权重和偏移量，然后使用其隐性神经元的状态，作为第二个RBM 的输入向量；3. 充分训练第二个RBM 后，将第二个RBM 堆叠在第一个RBM 的上方；4. 重复以上三个步骤任意多次；5. 如果训练集中的数据有标签，那么在顶层的RBM 训练时，这个RBM 的显层中除了显性神经元，还需要有代表分类标签的神经元，一起进行训练。

*/void DBN_pretrain(DBN* dbn, int *input, double lr, int k, int epochs){int i, j, l, m, n, epoch;int *layer_input;int prev_layer_input_size;int *prev_layer_input;int *train_X = new int[dbn->n_ins];for(i=0; i<dbn->n_layers; i++) // layer-wise{for(epoch=0; epoch<epochs; epoch++) // 训练周期{for(n=0; n<dbn->N; n++) // 训练样例{// 初始输入for(m=0; m<dbn->n_ins; m++)train_X[m] = input[n * dbn->n_ins + m];// 层输入for(l=0; l<=i; l++){if(l == 0){layer_input = new int[dbn->n_ins];for(j=0; j<dbn->n_ins; j++)layer_input[j] = train_X[j];}else{if(l == 1)prev_layer_input_size = dbn->n_ins;elseprev_layer_input_size = dbn->hidden_layer_sizes[l-2];prev_layer_input = new int[prev_layer_input_size];for(j=0; j<prev_layer_input_size; j++)prev_layer_input[j] = layer_input[j]; //前一层的输入delete layer_input;layer_input = new int[dbn->hidden_layer_sizes[l-1]]; //本层的输入//构建前一层的输出，layer_input，也就是本层的输入HiddenLayer_sample_h_given_v(&(dbn->sigmoid_layers[l-1]), \prev_layer_input, layer_input);delete prev_layer_input;}}//对比散度算法，更新当前玻尔兹曼机dbn->rbm_layers[i]的权重、偏置RBM_contrastive_divergence(&(dbn->rbm_layers[i]), layer_input, lr, k);}}}delete train_X;delete layer_input;}//调整/*生成模型使用Contrastive Wake-Sleep 算法进行调优，其算法过程是：1. 除了顶层RBM，其他层RBM 的权重被分成向上的认知权重和向下的生成权重；2. Wake 阶段：认知过程，通过外界的特征和向上的权重(认知权重) 产生每一层的抽象表示(结点状态) ，并且使用梯度下降修改层间的下行权重(生成权重) 。

3. Sleep 阶段：生成过程，通过顶层表示(醒时学得的概念) 和向下权重，生成底层的状态，同时修改层间向上的权重。

*/void DBN_finetune(DBN* dbn, int *input, int *label, double lr, int epochs){int i, j, m, n, epoch;int *layer_input;int *prev_layer_input;int *train_X = new int[dbn->n_ins];int *train_Y = new int[dbn->n_outs];for(epoch=0; epoch<epochs; epoch++) //训练次数{for(n=0; n<dbn->N; n++) // 输入样例x1...xN{// 初始输入for(m=0; m<dbn->n_ins; m++)train_X[m] = input[n * dbn->n_ins + m];for(m=0; m<dbn->n_outs; m++)train_Y[m] = label[n * dbn->n_outs + m];// 层输入for(i=0; i<dbn->n_layers; i++){if(i == 0){prev_layer_input = new int[dbn->n_ins];for(j=0; j<dbn->n_ins; j++)prev_layer_input[j] = train_X[j];}else{prev_layer_input = new int[dbn->hidden_layer_sizes[i-1]];for(j=0; j<dbn->hidden_layer_sizes[i-1]; j++)prev_layer_input[j] = layer_input[j];delete layer_input;}layer_input = new int[dbn->hidden_layer_sizes[i]];//由前一层的输入构建前一层的输出，也就是本层的输入HiddenLayer_sample_h_given_v(&(dbn->sigmoid_layers[i]), \prev_layer_input, layer_input);delete prev_layer_input;}//更新dbn->log_layer的权值，偏置参数LogisticRegression_train(&(dbn->log_layer), layer_input, train_Y, lr);}// lr *= 0.95;}delete layer_input;delete train_X;delete train_Y;}//预测void DBN_predict(DBN* dbn, int *x, double *y){int i, j, k;double *layer_input;// int prev_layer_input_size;double *prev_layer_input;double linear_output;prev_layer_input = new double[dbn->n_ins];for(j=0; j<dbn->n_ins; j++)prev_layer_input[j] = x[j];// 层激活// 用上一层的输出计算当前层每个单元被激活的概率// 然后当前层的输出再作为下层的输入for(i=0; i<dbn->n_layers; i++){layer_input = new double[dbn->sigmoid_layers[i].n_out];linear_output = 0.0;for(k=0; k<dbn->sigmoid_layers[i].n_out; k++){for(j=0; j<dbn->sigmoid_layers[i].n_in; j++){linear_output += dbn->sigmoid_layers[i].W[k][j] * prev_layer_input[j];}linear_output += dbn->sigmoid_layers[i].b[k];layer_input[k] = sigmoid(linear_output);}delete prev_layer_input;if(i < dbn->n_layers-1) //记录当前层每个单元被激活的概率，供计算下一层使用{prev_layer_input = new double[dbn->sigmoid_layers[i].n_out];for(j=0; j<dbn->sigmoid_layers[i].n_out; j++)prev_layer_input[j] = layer_input[j];delete layer_input;}}//分类，预测for(i=0; i<dbn->log_layer.n_out; i++){y[i] = 0;for(j=0; j<dbn->log_layer.n_in; j++){y[i] += dbn->log_layer.W[i][j] * layer_input[j];}y[i] += dbn->log_layer.b[i];}LogisticRegression_softmax(&(dbn->log_layer), y);delete layer_input;}受限玻尔兹曼机rbm.h#ifndef RBM_H#define RBM_H#include "utils.h"typedef struct{int N; //训练样例数目int n_visible; //可视层结点个数int n_hidden; //隐层结点个数double **W; //权重矩阵W[h_i][v_j]表示可视单元v_j连向隐藏单元h_i的权重double *hbias; //隐层偏置向量double *vbias; //可视层偏置向量} RBM;void RBM__construct(RBM*, int, int, int, double**, double*, double*);void RBM__destruct(RBM*);void RBM_contrastive_divergence(RBM*, int*, double, int);void RBM_sample_h_given_v(RBM*, int*, double*, int*);void RBM_sample_v_given_h(RBM*, int*, double*, int*);double RBM_propup(RBM*, int*, int, double);double RBM_down(RBM*, int*, int, double); void RBM_gibbs_hvh(RBM*, int*, double*, int*, double*, int*); void RBM_reconstruct(RBM*, int*, double*);#endifrbm.cpp#include "rbm.h"//构造受限玻尔兹曼机RBMvoid RBM__construct(RBM* rbm, int N, int n_visible, int n_hidden, \double **W, double *hbias, double *vbias) {int i, j;double a = 1.0 / n_visible;rbm->N = N; //样例个数rbm->n_visible = n_visible; //可视层结点个数rbm->n_hidden = n_hidden; //隐层结点个数if(W == NULL) //创建权重矩阵{rbm->W = new double*[n_hidden];for(i=0; i<n_visible; i++)rbm->W[i] = new double[n_visible];for(i=0; i<n_hidden; i++){for(j=0; j<n_visible; j++){rbm->W[i][j] = uniform(-a, a); //随机数}}}else{rbm->W = W;}if(hbias == NULL) //创建隐藏偏置向量{rbm->hbias = new double[n_hidden];for(i=0; i<n_hidden; i++)rbm->hbias[i] = 0;}else{rbm->hbias = hbias;}if(vbias == NULL) //创建可视层偏置向量{rbm->vbias = new double[n_visible];for(i=0; i<n_visible; i++)rbm->vbias[i] = 0;}else{rbm->vbias = vbias;}}//析构void RBM__destruct(RBM* rbm){for(int i=0; i<rbm->n_hidden; i++)delete rbm->W[i];delete rbm->W;delete rbm->hbias;delete rbm->vbias;}/*contrastive divergence（对比散度）算法，更新参数input：可视层结点状态lr：学习速率k：第k次采样，得到马尔科夫链中的一个采样(v, h)*/void RBM_contrastive_divergence(RBM* rbm, int *input, double lr, int k) {int i, j, step;double *ph_means = new double[rbm->n_hidden];int *ph_sample = new int[rbm->n_hidden];double *nv_means = new double[rbm->n_visible];int *nv_samples = new int[rbm->n_visible];double *nh_means = new double[rbm->n_hidden];int *nh_samples = new int[rbm->n_hidden];/* CD-k 对比散度contrastive divergence，CD算法*///由可见层得到隐藏层样本RBM_sample_h_given_v(rbm, input, ph_means, ph_sample);for(step=0; step<k; step++){if(step == 0){//初次Gibbs采样RBM_gibbs_hvh(rbm, ph_sample, nv_means, nv_samples, nh_means, nh_samples);}else{//第step次Gibbs采样，马尔可夫转移RBM_gibbs_hvh(rbm, nh_samples, nv_means, nv_samples, nh_means, nh_samples);}}//更新W, vbias, hbiasfor(i=0; i<rbm->n_hidden; i++){for(j=0; j<rbm->n_visible; j++){rbm->W[i][j] += lr * (input[j] * ph_means[i] - nv_samples[j] * nh_means[i]) / rbm->N;}rbm->hbias[i] += lr * (ph_means[i] - nh_means[i]) / rbm->N;}for(i=0; i<rbm->n_visible; i++){rbm->vbias[i] += lr * (input[i] - nv_samples[i]) / rbm->N;}delete ph_means;delete ph_sample;delete nv_means;delete nv_samples;delete nh_means;delete nh_samples;}/*由可见层得到隐藏层样本v0_sample：初始可视层结点状态h1_mean：隐层结点被激活的概率h1_sample：将h1_mean映射到0、1*/void RBM_sample_h_given_v(RBM* rbm, int *v0_sample, double *h1_mean, int *h1_sample) {int i;for(i=0; i<rbm->n_hidden; i++){//期望，第i个隐藏结点被激活的条件概率h1_mean[i] = RBM_propup(rbm, v0_sample, i, rbm->hbias[i]);//通过二项分布采样，将概率映射到0、1h1_sample[i] = binomial(1, h1_mean[i]);}}/*由隐藏层重构可见层样本即，给定隐层结点状态，对可视层结点采样v0_sample：初始隐层结点状态v1_mean：可视层结点被激活的概率v1_sample：将v1_mean映射到0、1*/void RBM_sample_v_given_h(RBM* rbm, int *h0_sample, double *v1_mean, int *v1_sample) {int i;for(i=0; i<rbm->n_visible; i++){//期望，第i个可视结点被激活的条件概率v1_mean[i] = RBM_propdown(rbm, h0_sample, i, rbm->vbias[i]);//通过二项分布采样，将概率映射到0、1v1_sample[i] = binomial(1, v1_mean[i]);}}/*给定可视层结点状态，求第i个隐藏结点被激活的条件概率p(h_i=1|v)v：随机二值向量b：第i个隐藏结点的偏置*/double RBM_propup(RBM* rbm, int *v, int i, double b){int j;double pre_sigmoid_activation = 0.0;for(j=0; j<rbm->n_visible; j++){pre_sigmoid_activation += rbm->W[i][j] * v[j];}pre_sigmoid_activation += b;return sigmoid(pre_sigmoid_activation);}/*给定隐藏层结点状态，求第i个可视结点被激活的条件概率p(h_i=1|v)v：随机二值向量b：第i个隐藏结点的偏置*/double RBM_propdown(RBM* rbm, int *h, int i, double b){int j;double pre_sigmoid_activation = 0.0;for(j=0; j<rbm->n_hidden; j++){pre_sigmoid_activation += rbm->W[j][i] * h[j];}pre_sigmoid_activation += b;return sigmoid(pre_sigmoid_activation);}//一次Gibbs采样//根据隐藏层来抽样最终得到隐藏层。