DBN代码注释Word下载.docx
《DBN代码注释Word下载.docx》由会员分享，可在线阅读，更多相关《DBN代码注释Word下载.docx（24页珍藏版）》请在冰点文库上搜索。
//赋值隐藏层数目
this.sigmoid_layers=newHiddenLayer[n_layers];
//声明两个隐藏层
this.rbm_layers=newRBM[n_layers];
//声明两个RBM对应每个隐藏层
if（rng==null）this.rng=newRandom（1234）;
//获取一个随机数值
elsethis.rng=rng;
//constructmulti-layer初始化每个隐藏层
for（inti=0;
i<
this.n_layers;
i++）{
if（i==0）{
input_size=this.n_ins;
//第一层隐藏层的输入为样本的特征的个数
}else{
input_size=this.hidden_layer_sizes[i-1];
//后面的隐藏层的输入为上一层隐藏层的输出，也就是上一层的隐藏层节点的个数。
}
//sigmoid层是用来计算的，rbm是用来调整w,b,c的
//constructsigmoid_layer初始化每个隐藏层，初始化做的事情就是给W和b赋随机值
this.sigmoid_layers[i]=newHiddenLayer（this.N,input_size,this.hidden_layer_sizes[i],null,null,rng）;
//constructrbm_layer初始化玻尔兹曼机，其实也就是初始化，W，b,c其中，w,b用的是hiddenlayer的
this.rbm_layers[i]=newRBM（this.N,input_size,this.hidden_layer_sizes[i],this.sigmoid_layers[i].W,this.sigmoid_layers[i].b,null,rng）;
}
//在完成每一层的构建之后，构建一个输出的逻辑回归层
//layerforoutputusingLogisticRegression，参数为样本个数N，输入为网络结构最后一层的输出数，输出为DBM网络设置的输出维数
this.log_layer=newLogisticRegression（this.N,this.hidden_layer_sizes[this.n_layers-1],this.n_outs）;
//对DBN网络进行一个预训练，目的是为每一层先构造更好的W和b，先使得网络更好的拟合样本的分布，类似于先把点放在最后值的附近
publicvoidpretrain（int[][]train_X,doublelr,intk,intepochs）{
//输入训练样本，学习率lr，CD-k=1,epochs=1000
int[]layer_input=null;
intprev_layer_input_size;
int[]prev_layer_input;
n_layers;
i++）{//layer-wise迭代每一个层
for（intepoch=0;
epoch<
epochs;
epoch++）{//trainingepochs每个层都迭代优化epochs次
for（intn=0;
n<
N;
n++）{//inputx1...xN每一层都遍历每个训练样本，这种方式相当于是随机梯度下降
//layerinput
for（intl=0;
l<
=i;
l++）{//从前面训练好的每一层开始迭代，假设有3层，i=2，0，1，2迭代3次
if（l==0）{//l=0的时候只是获取数据的特征
layer_input=newint[n_ins];
//第一层的输入维度为样本的特征数
for（intj=0;
j<
n_ins;
j++）layer_input[j]=train_X[n][j];
//遍历第i个样本的第j个特征赋值给layer_input
//也就是第一层处理的数据是样本的原始的特征。
}else{//如果不是第一层的话，本层处理的数据是上一层的输出
if（l==1）prev_layer_input_size=n_ins;
//l=1的时候输入的维度为原始数据的特征数
elseprev_layer_input_size=hidden_layer_sizes[l-2];
prev_layer_input=newint[prev_layer_input_size];
//声明这一层的输入数据维度
prev_layer_input_size;
j++）prev_layer_input[j]=layer_input[j];
//这一层的输入数据是上一层的输出，l=0的时候pre_layer_input为traningdata
layer_input=newint[hidden_layer_sizes[l-1]];
//layer_input其实就是这一层的输出
//给定上一层的输出数据作为本层的输入数据，计算出本层的输出，就只是单纯的利用rb,修改后的w,b来作出计算
sigmoid_layers[l-1].sample_h_given_v（prev_layer_input,layer_input）;
}
}
//在rbm层上，根据输入layer_input和学习率lr，对 wbc进行调整,同时每一个数据都要进行调整
rbm_layers[i].contrastive_divergence（layer_input,lr,k）;
}//endforeverytrainingdata
}//endforepochs
}//endforlayer-wise
//使用finetune进行微调，这里是有监督学习
publicvoidfinetune（int[][]train_X,int[][]train_Y,doublelr,intepochs）{
int[]layer_input=newint[0];
//intprev_layer_input_size;
int[]prev_layer_input=null;
for（intepoch=0;
epoch++）{//迭代epochs次
for（intn=0;
n++）{//遍历所有的输入数据样本
//layerinput
for（inti=0;
if（i==0）{
prev_layer_input=newint[n_ins];
//如果是第一层的话，输入就是数据样本的维度
for（intj=0;
j++）prev_layer_input[j]=train_X[n][j];
//获取输入数据
}else{
prev_layer_input=newint[hidden_layer_sizes[i-1]];
hidden_layer_sizes[i-1];
layer_input=newint[hidden_layer_sizes[i]];
//第i层的sigmoid层计算出本层的输出，作为下一层的输入layer_input
sigmoid_layers[i].sample_h_given_v（prev_layer_input,layer_input）;
}//endforiterlayer
//一个样本从头扫到尾，遍历所有的层最后的输出保存在layer_input当中
log_layer.train（layer_input,train_Y[n],lr）;
//log_layer是逻辑回归的对象，用layer_input和label来做逻辑回归
}//endforiterdata
//lr*=0.95;
}//endforepochs
publicvoidpredict（int[]x,double[]y）{//这里一次只处理一个样本
double[]layer_input=newdouble[0];
double[]prev_layer_input=newdouble[n_ins];
for（intj=0;
j++）prev_layer_input[j]=x[j];
//最开始的输入是特征x
doublelinear_output;
//layeractivation迭代每一层
i++）{
layer_input=newdouble[sigmoid_layers[i].n_out];
//后面层的输入是该层的输出
for（intk=0;
k<
sigmoid_layers[i].n_out;
k++）{//遍历的是一个[n-out][n-in]的数组
linear_output=0.0;
for（intj=0;
sigmoid_layers[i].n_in;
j++）{
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）;
if（i<
n_layers-1）{//上层的输出是layer_input,做为下一层的输入
prev_layer_input=newdouble[sigmoid_layers[i].n_out];
sigmoid_layers[i].n_out;
}//endforiterlayer
log_layer.n_out;
i++）{//到最后一层的时候，做一个逻辑回归
y[i]=0;
for（intj=0;
log_layer.n_in;
y[i]+=log_layer.W[i][j]*layer_input[j];
y[i]+=log_layer.b[i];
log_layer.softmax（y）;
//然后softmax获得一个归一话的结果
privatestaticvoidtest_dbn（）{
Randomrng=newRandom（123）;
doublepretrain_lr=0.1;
//pre-training的学习率初始的时候设置为0.1
intpretraining_epochs=1000;
intk=1;
doublefinetune_lr=0.1;
//fine-tune的学习率为0。
1
intfinetune_epochs=500;
//fine-turne的迭代次数
inttrain_N=6;
//训练数据集的个数,实际使用的时候最好不要用硬编码
inttest_N=4;
//测试数据集的个数
intn_ins=6;
//特征的维数
intn_outs=2;
//输出的维数
int[]hidden_layer_sizes={10,9,8,7,6};
//隐藏层的节点个数
intn_layers=hidden_layer_sizes.length;
//设置了两个隐藏层
//trainingdata
int[][]train_X={
{1,1,1,0,0,0},
{1,0,1,0,0,0},
{0,0,1,1,1,0},
{0,0,1,1,0,0},
{0,0,1,1,1,0}
};
int[][]train_Y={//用这样的表示来做二分类，如果是多维的就是多分类，我他妈真是太聪明了
{1,0},
{0,1},
//constructDBN初始化DBN网络
DBNdbn=newDBN（train_N,n_ins,hidden_layer_sizes,n_outs,n_layers,rng）;
//pretrain初始化构造好网络进入pre-traning阶段，就是一层一层训练网络,k=1是CD抽样只做一次
dbn.pretrain（train_X,pretrain_lr,k,pretraining_epochs）;
//finetune在pre-training构造整个网络之后，用finetune进行一次微调
dbn.finetune（train_X,train_Y,finetune_lr,finetune_epochs）;
//testdata
int[][]test_X={
{1,1,0,0,0,0},
{1,1,1,1,0,0},
{0,0,0,1,1,0},
double[][]test_Y=newdouble[test_N][n_outs];
//test
test_N;
dbn.predict（test_X[i],test_Y[i]）;
//对每个输入数据test_x[i]和对应的label进行预测，值保存在test_Y数组中
n_outs;
System.out.print（test_Y[i][j]+"
"
）;
System.out.println（）;
publicstaticvoidmain（String[]args）{
test_dbn（）;
}
publicclassRBM{
publicintn_visible;
publicintn_hidden;
publicdouble[][]W;
publicdouble[]hbias;
publicdouble[]vbias;
publicdoubleuniform（doublemin,doublemax）{
returnrng.nextDouble（）*（max-min）+min;
publicintbinomial（intn,doublep）{
if（p<
0||p>
1）return0;
intc=0;
doubler;
n;
r=rng.nextDouble（）;
//取一个随机数
if（r<
p）c++;
//这里就是以概率p来至0或者至1
returnc;
//RBM的构造函数
publicRBM（intN,intn_visible,intn_hidden,
double[][]W,double[]hbias,double[]vbias,Randomrng）{
//样本的个数
this.n_visible=n_visible;
//可视节点的个数，可视节点的个数就是上一层的输出
this.n_hidden=n_hidden;
//隐藏节点的个数，隐藏节点的个数就是这一层的节点个数
//获取随机值
if（W==null）{//初始话RBM的W，因为在构建的时候，是把隐藏层的W传过来，所以W不是NULL而是sigmoid_layers[i].W
this.W=newdouble[this.n_hidden][this.n_visible];
doublea=1.0/this.n_visible;
for（inti=0;
this.n_hidden;
this.n_visible;
this.W[i][j]=uniform（-a,a）;
}
}else{
this.W=W;
if（hbias==null）{//初始化RBM的偏差b，同理在初始化RBM的时候，hbias是由sigmoid_layers输入的
this.hbias=newdouble[this.n_hidden];
i++）this.hbias[i]=0;
this.hbias=hbias;
if（vbias==null）{//这里初始化，可视层的偏差，反正都为0就对了
this.vbias=newdouble[this.n_visible];
i++）this.vbias[i]=0;
this.vbias=vbias;
//执行CD方法对wbc进行梯度下降的调整
publicvoidcontrastive_divergence（int[]input,doublelr,intk）{
double[]ph_mean=newdouble[n_hidden];
//n-hidden是这一层的节点个数
int[]ph_sample=newint[n_hidden];
//保存的是隐藏层的0-1值
double[]nv_means=newdouble[n_visible];
//采样中保存的是可视层的wx+b值
int[]nv_samples=newint[n_vis
升级会员 