【deep learning学习笔记】注释yusugomori的SDA代码 -- Sda.cpp -- 模型训练与预测

模型的核心部分。代码并不多，基本思路就是层层训练，前一层的输出作为下一层的输入。hidde layer和dA共享的是相同的网络结构。有些需要注意的地方已经在代码中加入注释了。另外，还发现了原来代码实现中的一个bug，已经更正。

代码如下：

void SdA::pretrain (
			int *input, 
			double lr, 
			double corruption_level, 
			int epochs
				) 
{
  	int *layer_input;
  	int prev_layer_input_size;
  	int *prev_layer_input;

  	int *train_X = new int[n_ins];

  	for(int i=0; i<n_layers; i++) 	// layer-wise, i
	{  
    	for(int epoch=0; epoch<epochs; epoch++) 	// training epochs, epoch
		{  
      		for(int n=0; n<N; n++) 	// input x1...xN, iterate each sample, n
			{ 
        		// initial input
        		for(int m=0; m<n_ins; m++) 		// get the nth input sample
					train_X[m] = input[n * n_ins + m];

        		// set the layer input and train it
        		// the code here is a little complicated:
        		// it calcualtes the node value layer by layer, from bottom
        		// input layer to the current calculated layer -- i. Then it 
        		// train the network from the i-1 layer to the i layer by the 
        		// denosing auto-encoder
        		for(int l=0; l<=i; l++) // l 
				{

		          	if(l == 0) 	// in case the first layer
					{
		            	layer_input = new int[n_ins];
		            	for(int j=0; j<n_ins; j++) 
							layer_input[j] = train_X[j];
		          	} 
 					else 		// in case the rest layers
				 	{
				 		// set the value of previous layer from the last 'layer_input'
				 		// as the input for the current layer
		            	if(l == 1) 
							prev_layer_input_size = n_ins;
		            	else 
							prev_layer_input_size = hidden_layer_sizes[l-2];
		
		            	prev_layer_input = new int[prev_layer_input_size];
		            	for(int j=0; j<prev_layer_input_size; j++) 
							prev_layer_input[j] = layer_input[j];
		            	delete[] layer_input;
		
						// calcualte the value of current layer from prev_layer_input
						// and put the value into the current layer_input
		            	layer_input = new int[hidden_layer_sizes[l-1]];		
		            	sigmoid_layers[l-1]->sample_h_given_v(prev_layer_input, layer_input);
		            	
		            	delete[] prev_layer_input;
		          	}
        		} // for l

				// train the current layer as denosing auto-encoder
        		dA_layers[i]->train(layer_input, lr, corruption_level);
        		
      		}	// for N
    	}	// for epoches
  	} // for n_layers

  	delete[] train_X;
  	delete[] layer_input;
}

void SdA::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; epoch<epochs; epoch++) 
  	{
    	for(int n=0; n<N; n++) // input x1...xN
		{ 
      		// initial input
      		for(int m=0; m<n_ins; m++)  
			  train_X[m] = input[n * n_ins + m];
      		for(int m=0; m<n_outs; m++) 
			  train_Y[m] = label[n * n_outs + m];

      		// calculate the value of the last dA layer
      		// most different from the code block in pretrain is :
      		// here the network weights in hidden layers have been well trained,
      		// which can be used directly to calculating the output layer by layer.
      		// however, in the pretrain function, the weights have not been trained.
      		// it should train the weights based on whichi the value of next layer
      		// can be calculated. 
      		for(int i=0; i<n_layers; i++) 
			{
        		if(i == 0) 
				{
          			prev_layer_input = new int[n_ins];
          			for(int j=0; j<n_ins; j++) 
					  prev_layer_input[j] = train_X[j];
        		} 
				else 
				{
          			prev_layer_input = new int[hidden_layer_sizes[i-1]];
          			for(int j=0; j<hidden_layer_sizes[i-1]; j++) 
					  prev_layer_input[j] = layer_input[j];
          			delete[] layer_input;
        		}

				layer_input = new int[hidden_layer_sizes[i]];
        		sigmoid_layers[i]->sample_h_given_v(prev_layer_input, layer_input);
        		delete[] prev_layer_input;
        		
      		} // for n_layers

			// train the output (last) layer by logistic regression
      		log_layer->train(layer_input, train_Y, lr);
      		
    	} // for N
    	// lr *= 0.95;
  	} // for epoch

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

void SdA::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; j<n_ins; j++) 
	  prev_layer_input[j] = x[j];

  	// layer activation: calculate the output value layer by layer
  	for(int i=0; i<n_layers; i++) 
  	{
    	layer_input = new double[sigmoid_layers[i]->n_out];

    	// linear_output = 0.0;	// it is a bug, it should be in the 'for-loop' below!!
    	for(int k=0; k<sigmoid_layers[i]->n_out; k++) 
		{
			linear_output = 0.0;	// here is the right place!!
      		for(int j=0; j<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);
 		}
    	delete[] prev_layer_input;

    	if(i < n_layers-1) 
		{
      		prev_layer_input = new double[sigmoid_layers[i]->n_out];
      		for(int j=0; j<sigmoid_layers[i]->n_out; j++) 
			  prev_layer_input[j] = layer_input[j];
      		delete[] layer_input;
    	}
  	} // for n_layers
  
  	// the logestic regresssion layer
  	for(int i=0; i<log_layer->n_out; i++) 
  	{
    	y[i] = 0;
    	for(int j=0; j<log_layer->n_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;
}