back_topology.cpp

预测神经网络

// Back_Topology.cpp: implementation of the Back_Topology class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Back_Topology.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
Back_Topology::Back_Topology()
{ 
	//简便起见，固定两个激发函数类型
	activation_function_for_hidden_layer=2;
    activation_function_for_output_layer=1;
	realtesting=false;
}
void Back_Topology::construct_and_initialize_backprop_network(void)
{
  
  int inputs_to_output_node;
 


     //建立第一隐层
    hidden_layer_number[0].node_in_hidden_layer = new Hidden_units[hidenode[0]];
   //建立第二隐层
    hidden_layer_number[1].node_in_hidden_layer = new Hidden_units[hidenode[1]];
    //建立输出层
	node_in_output_layer = new Output_units[nodes_in_output_layer];
	

 //建立输入层   
      // establish input connection between signal and hidden layer
      for(int k= 0; k < hidenode[0]; k++)
      {//确定隐层节点输入维数
	hidden_layer_number[0].node_in_hidden_layer[k].number_of_input_units = signal_dimensions;
	
	hidden_layer_number[0].node_in_hidden_layer[k].establish_array_of_processing_unit_inputs();
	hidden_layer_number[0].node_in_hidden_layer[k].establish_weight_vector_for_processing_units();
	hidden_layer_number[0].node_in_hidden_layer[k].bias =(float)(1.0 - (2.0 * bedlam((long)(gaset)))) ;
      }
	  //有两层隐层   //确定两个隐层的输入信号维数
       for(k = 0; k <hidenode[1]; k++)
	   {
	hidden_layer_number[1].node_in_hidden_layer[k].number_of_input_units = hidenode[0];
	hidden_layer_number[1].node_in_hidden_layer[k].establish_array_of_processing_unit_inputs();
	//下面这条语句之后，权值应被随机初始化
	hidden_layer_number[1].node_in_hidden_layer[k].establish_weight_vector_for_processing_units();
	hidden_layer_number[1].node_in_hidden_layer[k].bias =(float) (1.0 - (2.0 * bedlam((long)(gaset))));
	   }

     // determine number of inputs to the output layer
     inputs_to_output_node = hidenode[1];
	//建立输出层的数据处理空间
    // establish input connections to output layer
    for(k = 0; k < nodes_in_output_layer; k++)
    {
     node_in_output_layer[k].number_of_input_units = inputs_to_output_node;
	 //分配输入，权重，误差向量的存储空间
     node_in_output_layer[k].establish_array_of_processing_unit_inputs();
	// 随机初始化权重向量
     node_in_output_layer[k].establish_weight_vector_for_processing_units();
	 //随机初试化偏置值
     node_in_output_layer[k].bias =(float)( 1.0 - (2.0 * bedlam((long)(gaset))));
    }
    
  }
 // end construct and initialize neural network function

void Back_Topology::upload_network(void)
{
	
	ifstream get_ptr;
	int nodes, dim, inputs_to_output_node, hid, inputs;
	int dolock = 0;
	

		get_ptr.open(bpfilename, ios::in);
	
	get_ptr >> signal_dimensions;
	get_ptr >> activation_function_for_output_layer;
	get_ptr >> nodes_in_output_layer;
	get_ptr >> inputs_to_output_node;
	
	// establish output layer
	node_in_output_layer = new Output_units[nodes_in_output_layer];
	for(nodes = 0; nodes < nodes_in_output_layer; nodes++)
	{
		node_in_output_layer[nodes].number_of_input_units = inputs_to_output_node;
		node_in_output_layer[nodes].establish_array_of_processing_unit_inputs();
		node_in_output_layer[nodes].establish_weight_vector_for_processing_units();
		get_ptr >> node_in_output_layer[nodes].bias;
	}
	for(nodes = 0; nodes < nodes_in_output_layer; nodes++)
	{
		for(dim = 0; dim < inputs_to_output_node; dim++)
		{get_ptr >> node_in_output_layer[nodes].weight_of_inputs[dim];}
	}
	
	// establish hidden layer(s)
	
	get_ptr >> activation_function_for_hidden_layer;
		for(hid = 0; hid < 2; hid++)
		{
			get_ptr >> hidenode[hid];
			nodes = hidenode[hid];
			hidden_layer_number[hid].node_in_hidden_layer = new Hidden_units[nodes];
			
			if(hid == 0) {inputs = signal_dimensions;}
			else
			{inputs = hidenode[0];}
			
			for(nodes = 0; nodes < hidenode[hid]; nodes++)
			{
				hidden_layer_number[hid].node_in_hidden_layer[nodes].number_of_input_units = inputs;
				hidden_layer_number[hid].node_in_hidden_layer[nodes].establish_array_of_processing_unit_inputs();
				get_ptr >> hidden_layer_number[hid].node_in_hidden_layer[nodes].bias;
			}
			for(nodes = 0; nodes < hidenode[hid]; nodes++)
			{
				for(dim = 0; dim < inputs; dim++)
				{get_ptr >> hidden_layer_number[hid].node_in_hidden_layer[nodes].weight_of_inputs[dim];}
			}
		}
		if (realtesting) 
		{
			pNormalizeInfo=new CNormalizeInfo(signal_dimensions,nodes_in_output_layer);
		for(dim=0;dim<(signal_dimensions+nodes_in_output_layer);dim++)
		{
			get_ptr >>pNormalizeInfo->pCoAnti[dim].Max_min;
		    get_ptr >>pNormalizeInfo->pCoAnti[dim].min;
		}
		}

	
	get_ptr.close();
}

void Back_Topology::savenet(void)
{
  
  ofstream save_ptr;
  
  int nodes, dim, inputs;

  save_ptr.open(bpfilename, ios::out);
 
  //输入维数
  save_ptr << signal_dimensions << "\n";
 
  //输出层激发函数（1 或2）
  save_ptr << activation_function_for_output_layer << "\n";
  
  
  //输出层节点数
  save_ptr << nodes_in_output_layer << "\n";
  


//输出节点的输入维数
  save_ptr << hidenode[1] << "\n";

  //每个输出节点的偏置值


  for(nodes = 0; nodes < nodes_in_output_layer; nodes++)
  {save_ptr << node_in_output_layer[nodes].bias << " ";
  save_ptr << "\n";
  }
 //每个输出节点的权重矢量
  
  for(nodes = 0; nodes < nodes_in_output_layer; nodes++)
  {
    for(dim = 0; dim < hidenode[1]; dim++)
    {save_ptr << node_in_output_layer[nodes].weight_of_inputs[dim] << " ";
	
	}
    save_ptr << "\n";

  }



  //隐层激发函数
    save_ptr << activation_function_for_hidden_layer << "\n";
	
    //第一隐层节点数
      save_ptr <<hidenode[0] << "\n";
      
//第一隐层输入维数
      inputs = signal_dimensions;
      
//第一隐层偏置矢量
	  
      for(nodes = 0; nodes < hidenode[0]; nodes++)
      {save_ptr << hidden_layer_number[0].node_in_hidden_layer[nodes].bias << " ";
	  
	  }
      
	  save_ptr << "\n";

//第一隐层每个节点的权重矢量
       
       for(nodes = 0; nodes < hidenode[0]; nodes++)
	   {
	     for(dim = 0; dim < inputs; dim++)
		 {
		float a=hidden_layer_number[0].node_in_hidden_layer[nodes].weight_of_inputs[dim];
	    save_ptr <<a<< " ";
	    
		 }
	 
	  save_ptr << "\n";
	 
	   }
	 
	  
 //第二隐层节点数  
save_ptr <<hidenode[1] << "\n";  

//第二隐层输入维数等于第一隐层节点数
inputs =hidenode[0];  

//第二隐层偏置矢量
for(nodes = 0; nodes < hidenode[1]; nodes++)
{save_ptr << hidden_layer_number[1].node_in_hidden_layer[nodes].bias << " ";

}

save_ptr << "\n";

//第二隐层每个节点的权重矢量

for(nodes = 0; nodes < hidenode[1]; nodes++)
{
	for(dim = 0; dim < inputs; dim++)
	{
	float a=hidden_layer_number[1].node_in_hidden_layer[nodes].weight_of_inputs[dim];
	save_ptr <<a<< " ";

	}
		
        
	
	save_ptr << "\n";

}
for(dim=0;dim<(signal_dimensions+nodes_in_output_layer);dim++)
{save_ptr <<(pNormalizeInfo->pCoAnti[dim].Max_min)<<" ";
save_ptr <<(pNormalizeInfo->pCoAnti[dim].min)<<" ";
}

save_ptr << "\n";

save_ptr.close();



if (savebptoSee) 
{ofstream look_ptr;
 look_ptr.open(bpforlookfilename, ios::out);
  look_ptr<<"输入维数    "<<signal_dimensions<<endl;
  look_ptr<<"输出层激发函数      "<<activation_function_for_output_layer<<endl;
  look_ptr<<"输出层节点数       "<<nodes_in_output_layer<<endl;
  look_ptr<<"输出节点的输入维数        "<<hidenode[1]<<endl<<endl;
  look_ptr<<"每个输出节点的偏置值        "<<endl;

  for(nodes = 0; nodes < nodes_in_output_layer; nodes++)
  {
  look_ptr << node_in_output_layer[nodes].bias << " ";
  look_ptr<<"\n";
  }

  look_ptr<<"每个输出节点的权重矢量       "<<endl;

  for(nodes = 0; nodes < nodes_in_output_layer; nodes++)
  {
	  for(dim = 0; dim < hidenode[1]; dim++)
	  {
	  look_ptr << node_in_output_layer[nodes].weight_of_inputs[dim] << " ";
	  }
	  
	  look_ptr<< "\n";
  }
   look_ptr<< "\n";

   look_ptr<<"隐层激发函数         ";
   look_ptr<<activation_function_for_hidden_layer << "\n"<<endl;

   look_ptr<<"第一隐层节点数     ";
   look_ptr<<hidenode[0] << "\n"<<endl;

   look_ptr<<"第一隐层偏置矢量      "<<endl;
   for(nodes = 0; nodes < hidenode[0]; nodes++)
   {
	  look_ptr << hidden_layer_number[0].node_in_hidden_layer[nodes].bias << " ";
   }
   look_ptr<<endl<<endl;
   
   inputs=signal_dimensions;
	look_ptr<<"第一隐层每个节点的权重矢量      "<<endl;
	  for(nodes = 0; nodes < hidenode[0]; nodes++)
	  {
		  for(dim = 0; dim < inputs; dim++)
		  {
			  
			  look_ptr << hidden_layer_number[0].node_in_hidden_layer[nodes].weight_of_inputs[dim] << " ";
		  }
		  
		  
		  look_ptr << "\n";
	  }
	 
	  look_ptr << "\n";

	  look_ptr <<"第二隐层节点数      ";
	  look_ptr <<hidenode[1]<<endl<<endl;

	  look_ptr <<"第二隐层偏置矢量      "<<endl;
	  for(nodes = 0; nodes < hidenode[1]; nodes++)
	  {
	  look_ptr << hidden_layer_number[1].node_in_hidden_layer[nodes].bias << " ";
	  }
	  look_ptr<<endl<<endl;
inputs=hidenode[0];

	  look_ptr<<"第二隐层每个节点的权重矢量"<<endl;

	  for(nodes = 0; nodes < hidenode[1]; nodes++)
	  {
		  for(dim = 0; dim < inputs; dim++)
		  {
			 
			  look_ptr << hidden_layer_number[1].node_in_hidden_layer[nodes].weight_of_inputs[dim] << " ";
		  }
		  
		  look_ptr << "\n";
	  }
	  look_ptr<<"样本归一化参数:样本每一维的(Max-mim)和min"<<endl;
	  
	  for(int dim=0;dim<(signal_dimensions+nodes_in_output_layer);dim++)
	  {look_ptr <<(pNormalizeInfo->pCoAnti[dim].Max_min)<<" ";
	  look_ptr<<(pNormalizeInfo->pCoAnti[dim].min)<<" ";
	  }

	 look_ptr << "\n";
	 look_ptr.close();
	 
	  
}
}

Back_Topology::~Back_Topology()
{  
 delete [] node_in_output_layer;
 if (realtesting) 
 {
	 delete pNormalizeInfo;
 }

}





Back_Topology::Back_Topology(const Back_Topology & bp)
 {//信号维数
	realtesting=bp.realtesting;
	signal_dimensions=bp.signal_dimensions;

 activation_function_for_output_layer=bp.activation_function_for_output_layer;
 //输出维数
 nodes_in_output_layer=bp.nodes_in_output_layer;
 //隐层节点数
 hidenode[1]=bp.hidenode[1];
  hidenode[0]=bp.hidenode[0];
 
  //分配存储空间
construct_and_initialize_backprop_network();
 //输出层偏置矢量
 for(int nodes = 0; nodes < nodes_in_output_layer; nodes++)
 {node_in_output_layer[nodes].bias=bp.node_in_output_layer[nodes].bias;}

//输出层权重
 for(nodes = 0; nodes < nodes_in_output_layer; nodes++)
 {
	 for(int dim = 0; dim < hidenode[1]; dim++)
	 {
		 node_in_output_layer[nodes].weight_of_inputs[dim]=bp.node_in_output_layer[nodes].weight_of_inputs[dim];
	 }
	
	 
 }


activation_function_for_hidden_layer=bp.activation_function_for_hidden_layer;
//第一隐层偏置矢量
for(nodes = 0; nodes < hidenode[0]; nodes++)
{
	hidden_layer_number[0].node_in_hidden_layer[nodes].bias=bp.hidden_layer_number[0].node_in_hidden_layer[nodes].bias;

}


//第一隐层权重
for(nodes = 0; nodes < hidenode[0]; nodes++)
{
	for(int dim = 0; dim <signal_dimensions; dim++)
	{
	hidden_layer_number[0].node_in_hidden_layer[nodes].weight_of_inputs[dim]=bp.hidden_layer_number[0].node_in_hidden_layer[nodes].weight_of_inputs[dim];
	}
	
}

//第二隐层偏置矢量
for(nodes = 0; nodes < hidenode[1]; nodes++)
{hidden_layer_number[1].node_in_hidden_layer[nodes].bias=bp.hidden_layer_number[1].node_in_hidden_layer[nodes].bias;

}

//第二隐层权重
for(nodes = 0; nodes < hidenode[1]; nodes++)
{
	for(int dim = 0; dim < hidenode[0]; dim++)
	{
		hidden_layer_number[1].node_in_hidden_layer[nodes].weight_of_inputs[dim]=bp.hidden_layer_number[1].node_in_hidden_layer[nodes].weight_of_inputs[dim];

		
	}
 }


strcpy(bpfilename,bp.bpfilename);
strcpy(bpforlookfilename,bp.bpforlookfilename);
savebptoSee=bp.savebptoSee;
}

void Back_Topology::coverme(const Back_Topology &bp)
{
	for(int nodes = 0; nodes < nodes_in_output_layer; nodes++)
	{node_in_output_layer[nodes].bias=bp.node_in_output_layer[nodes].bias;}
	//输出层权重
	for(nodes = 0; nodes < nodes_in_output_layer; nodes++)
	{
		for(int dim = 0; dim < hidenode[1]; dim++)
		{node_in_output_layer[nodes].weight_of_inputs[dim]=bp.node_in_output_layer[nodes].weight_of_inputs[dim];
		}
		
		
	}
	
	
	activation_function_for_hidden_layer=bp.activation_function_for_hidden_layer;
	//第一隐层偏置矢量
	for(nodes = 0; nodes < hidenode[0]; nodes++)
	{
		hidden_layer_number[0].node_in_hidden_layer[nodes].bias=bp.hidden_layer_number[0].node_in_hidden_layer[nodes].bias;
		
	}
	
	
	//第一隐层权重
	for(nodes = 0; nodes < hidenode[0]; nodes++)
	{
		for(int dim = 0; dim <signal_dimensions; dim++)
		{
			hidden_layer_number[0].node_in_hidden_layer[nodes].weight_of_inputs[dim]=bp.hidden_layer_number[0].node_in_hidden_layer[nodes].weight_of_inputs[dim];
		}
		
	}
	
	//第二隐层偏置矢量
	for(nodes = 0; nodes < hidenode[1]; nodes++)
	{hidden_layer_number[1].node_in_hidden_layer[nodes].bias=bp.hidden_layer_number[1].node_in_hidden_layer[nodes].bias;
	
	}
	
	//第二隐层权重
	for(nodes = 0; nodes < hidenode[1]; nodes++)
	{
		for(int dim = 0; dim < hidenode[0]; dim++)
		{
			hidden_layer_number[1].node_in_hidden_layer[nodes].weight_of_inputs[dim]=bp.hidden_layer_number[1].node_in_hidden_layer[nodes].weight_of_inputs[dim];
			
			
		}
	}
}



//DEL void Back_Topology::gainNetinfo()
//DEL {
//DEL 	upload_network();
//DEL 	construct_and_initialize_backprop_network();
//DEL }