📄 neural_network.cpp
字号:
// Neural_NetWork.cpp: implementation of the CNeural_NetWork class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "CBA_SYSTEM.h"
#include "Neural_NetWork.h"
#include "math.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CNeural_NetWork::CNeural_NetWork() //默认构造函数定义一个三层结构的网络结构
{
Num_h = 1;
Num_i = 1;
Num_o = 1;
h_layers = new CH_Layer[Num_h];
o_layers = new CO_Layer[Num_o];
i_layers = new CI_Layer[Num_i];
l=0.9;
}
CNeural_NetWork::CNeural_NetWork(short num_h)//按需构造网络层数
{
Num_h = num_h;
Num_i = 1;
Num_o = 1;
h_layers = new CH_Layer[Num_h];
o_layers = new CO_Layer[Num_o];
i_layers = new CI_Layer[Num_i];
l=0.9;
}
void CNeural_NetWork::InitNeural_NetWorkLayers(short num_h)
{
delete [] h_layers;
delete [] o_layers;
delete [] i_layers;
Num_h = num_h;
Num_i = 1;
Num_o = 1;
h_layers = new CH_Layer[Num_h];
o_layers = new CO_Layer[Num_o];
i_layers = new CI_Layer[Num_i];
l=0.9;
}
CH_Layer& CNeural_NetWork::GetH_layer(short n)
{
return h_layers[n];
}
CI_Layer& CNeural_NetWork::GetI_layer()
{
return i_layers[0];
}
CO_Layer& CNeural_NetWork::GetO_layer()
{
return o_layers[0];
}
short CNeural_NetWork::GetNum_h()
{
return Num_h;
}
short CNeural_NetWork::GetNum_i()
{
return Num_i;
}
short CNeural_NetWork::GetNum_o()
{
return Num_o;
}
void CNeural_NetWork::SetNum_h(int n)
{
Num_h = n;
}
void CNeural_NetWork::InitNeural_NetWork(int m_i_n,int m_o_n,int *p_o_h,float *p_hbasvalue,float *p_obasvalue,CWeight *m_wp)
{
short index_nodes = 0;
count_of_hbas = 0;
for(int ii_h=0;ii_h<GetNum_h();ii_h++)
{
h_layers[ii_h].SetNode_Num(p_o_h[ii_h]);
count_of_hbas = count_of_hbas +p_o_h[ii_h];
}
i_layers[0].SetNode_Num(m_i_n);
o_layers[0].SetNode_Num(m_o_n);
/*设置各层节点标识*/
/*输入层*/
for(int ii=0;ii<i_layers[0].GetNode_Num();ii++)
{
i_layers[0].GetNode(ii).SetId(ii+1);
}
/*隐藏层*/
for(ii_h=0;ii_h<GetNum_h();ii_h++)
{
for(int hh=0;hh<h_layers[ii_h].GetNode_Num();hh++)
{
h_layers[ii_h].GetNode(hh).SetId(ii+1);
ii++;
}
}
/*输出层*/
for(int oo=0;oo<o_layers[0].GetNode_Num();oo++)
{
o_layers[0].GetNode(oo).SetId(ii+1);
}
/*初始化隐藏层各节点的偏倚*/
for(ii_h=0;ii_h<GetNum_h();ii_h++)
{
for(int hin=0;hin<h_layers[ii_h].GetNode_Num();hin++)
{
h_layers[ii_h].GetNode(hin).SetBias(p_hbasvalue[index_nodes]);
index_nodes++;
}
}
index_nodes = 0;
/*初始化输出层各节点的偏倚*/
for(int oin=0;oin<o_layers[0].GetNode_Num();oin++)
{
o_layers[0].GetNode(oin).SetBias(p_obasvalue[index_nodes]);
}
/*设置权重*/
wp = m_wp;
}
void CNeural_NetWork::Train(float *p_data,double num_data,double m_train_t_num)
{
int i,j,k,m,n,t; //循环计数变量
float i_value,o_value; //临时变量用于存储节点净输入和净输出
float err; //临时变量存储节点误差
float t_value; //临时变量存储输出节点期望
short h_n_num,o_n_num,i_n_num,h_ln_num,h_an_num=0; //分别存储隐藏层第一层节点数和输出层节点数,输入层节点数,
//隐藏层最后一层节点数,隐藏层总的节点数
short ih_w_num =0,hh_w_num = 0; //ih_w_num,输入层到隐藏层第一层的权重总数,hh_w_num隐藏层之间的权重总数
short m_w_id; //权重主标识
float m_w; //临时变量存储权重
float m_bas; //临时变量存储偏倚
int idx = 0; //数据数组的行索引
double train_t_num=1;
isStop = false;
h_n_num = h_layers[0].GetNode_Num();
o_n_num = o_layers[0].GetNode_Num();
i_n_num = i_layers[0].GetNode_Num();
h_ln_num = h_layers[GetNum_h()-1].GetNode_Num();
for(j=0;j<GetNum_h();j++)
{
h_an_num = h_an_num + h_layers[j].GetNode_Num();
}
ih_w_num = i_layers[0].GetNode_Num()*h_layers[0].GetNode_Num();
for(int ii_h=0;ii_h<GetNum_h()-1;ii_h++)
{
hh_w_num = hh_w_num+h_layers[ii_h].GetNode_Num()*h_layers[ii_h+1].GetNode_Num();
}
float w_sum = 0; //w_sum存储节点加权和
float *temp;
temp = p_data;
/*算法开始*/
while(!isStop)
{
for(t=0;t<num_data;t++) //周期开始
{
m_w_id = 0; //权重主标识清零
for(i=0;i<i_n_num;i++)
{
i_layers[0].GetNode(i).SetI_value(*p_data); //设置元组输入层单元的输入值
p_data++;
}
for(i=0;i<o_n_num;i++)
{
o_layers[0].GetNode(i).SetT(*p_data); //设置元组输出层单元对应期望
p_data++;
}
/*向前传播输入*/
for(i=0;i<h_n_num;i++)
{
for(j=0;j<i_n_num;j++)
{
k = j*h_n_num;
w_sum = w_sum+(wp[k+i].GetW_w())*(i_layers[0].GetNode(j).GetI_value());
}
i_value = w_sum+h_layers[0].GetNode(i).GetBias(); //计算出隐藏层第一层各个节点的净输入
o_value = 1/(1+exp(-i_value)); //计算出隐藏层第一层各个节点的净输出
h_layers[0].GetNode(i).SetI_value(i_value);
h_layers[0].GetNode(i).SetO_value(o_value);
w_sum = 0;
}
/////////////////////////////////////////////////////
n = h_n_num*i_n_num;
for(i=0;i<GetNum_h()-1;i++)
{
for(j=0;j<h_layers[i+1].GetNode_Num();j++)
{
for(k=0;k<h_layers[i].GetNode_Num();k++)
{
m = k*h_layers[i+1].GetNode_Num();
w_sum = w_sum + (wp[m+j+n].GetW_w())*(h_layers[i].GetNode(k).GetO_value());
}
i_value = w_sum+h_layers[i+1].GetNode(j).GetBias(); //隐藏层其它层净输入
o_value = 1/(1+exp(-i_value)); //隐藏层其它层净输出
h_layers[i+1].GetNode(j).SetI_value(i_value);
h_layers[i+1].GetNode(j).SetO_value(o_value);
w_sum = 0;
}
n = n + h_layers[i].GetNode_Num()*h_layers[i+1].GetNode_Num();
}
/////////////////////////////////////////////////////
for(i=0;i<o_n_num;i++)
{
for(j=0;j<h_ln_num;j++)
{
k = j*o_n_num;
w_sum = w_sum+(wp[(k+i)+(ih_w_num+hh_w_num)].GetW_w())*(h_layers[GetNum_h()-1].GetNode(j).GetO_value());
}
i_value = w_sum+o_layers[0].GetNode(i).GetBias(); //计算出输出层各个节点的净输入
o_value = 1/(1+exp(-i_value)); //计算出输出层各个节点的净输出
o_layers[0].GetNode(i).SetI_value(i_value);
o_layers[0].GetNode(i).SetO_value(o_value);
w_sum = 0;
}
/*后向传播误差*/
/*输出层的每个节点误差计算*/
for(j=0;j<o_n_num;j++)
{
o_value = o_layers[0].GetNode(j).GetO_value();
t_value = o_layers[0].GetNode(j).GetT();
err = o_value*(1-o_value)*(t_value-o_value); //输出层相应节点误差
o_layers[0].GetNode(j).SetErr(err);
}
/*隐藏层每个节点误差计算*/
/*倒数第一层*/
for(j=0;j<h_ln_num;j++)
{
o_value = h_layers[GetNum_h()-1].GetNode(j).GetO_value();
for(i=0;i<o_n_num;i++)
{
w_sum = w_sum+(wp[ih_w_num+hh_w_num+i+j*o_n_num].GetW_w())*(o_layers[0].GetNode(i).GetErr());
}
err = o_value*(1-o_value)*w_sum;
h_layers[GetNum_h()-1].GetNode(j).SetErr(err);
w_sum = 0;
}
/*其它层*/
//n = ih_w_num+hh_w_num;
m = 0;
for(i=GetNum_h()-1;i>0;i--)
{
m = m+h_layers[i].GetNode_Num()*h_layers[i-1].GetNode_Num();
for(j=0;j<h_layers[i-1].GetNode_Num();j++)
{
o_value = h_layers[i-1].GetNode(j).GetO_value();
for(k=0;k<h_layers[i].GetNode_Num();k++)
{
w_sum = w_sum + (wp[n-m+j*h_layers[i].GetNode_Num()+k].GetW_w())*(h_layers[i].GetNode(k).GetErr());
}
err = o_value*(1-o_value)*w_sum;
h_layers[i-1].GetNode(j).SetErr(err);
w_sum = 0;
}
}
/*更新整个网络的权重和偏倚值*/
/*隐藏层和输入层之间的权重更新*/
for(j=0;j<i_n_num;j++)
{
for(i=0;i<h_n_num;i++)
{
m_w = wp [m_w_id].GetW_w() + l*(h_layers[0].GetNode(i).GetErr())*(i_layers[0].GetNode(j).GetI_value());
wp[m_w_id].SetW_w(m_w);
m_w_id++;
}
}
/*隐藏层和隐藏层之间的权重更新*/
for(i=0;i<GetNum_h()-1;i++)
{
for(j=0;j<h_layers[i].GetNode_Num();j++)
{
for(k=0;k<h_layers[i+1].GetNode_Num();k++)
{
m_w = wp[m_w_id].GetW_w() + l*(h_layers[i+1].GetNode(k).GetErr())*(h_layers[i].GetNode(j).GetO_value());
wp[m_w_id].SetW_w(m_w);
m_w_id++;
}
}
}
/*隐藏层和输出层之间的权重更新*/
for(j=0;j<h_ln_num;j++)
{
for(i=0;i<o_n_num;i++)
{
m_w = wp [m_w_id].GetW_w() + l*(o_layers[0].GetNode(i).GetErr())*(h_layers[GetNum_h()-1].GetNode(j).GetO_value()); //按公式计算
wp[m_w_id].SetW_w(m_w);
m_w_id++;
}
}
/*隐藏层和输出层节点的偏倚更新*/
/*隐藏层*/
for(i=0;i<GetNum_h();i++)
{
for(j=0;j<h_layers[i].GetNode_Num();j++)
{
m_bas = h_layers[i].GetNode(j).GetBias() + l*(h_layers[i].GetNode(j).GetErr());
h_layers[i].GetNode(j).SetBias(m_bas);
}
}
/*输出层*/
for(j=0;j<o_n_num;j++)
{
m_bas = o_layers[0].GetNode(j).GetBias() + l*(o_layers[0].GetNode(j).GetErr()); //按公式计算
o_layers[0].GetNode(j).SetBias(m_bas);
}
//idx++;
} //周期结束
//idx = 0;
p_data = temp;
train_t_num++;
if(train_t_num>m_train_t_num)
{
isStop = true;
}
}
}
void CNeural_NetWork::SK_Train(float *p_data,double num_data,double m_min_w)
{
int i,j,k,m,n,t; //循环计数变量
float i_value,o_value; //临时变量用于存储节点净输入和净输出
float err; //临时变量存储节点误差
float t_value; //临时变量存储输出节点期望
short h_n_num,o_n_num,i_n_num,h_ln_num,h_an_num=0; //分别存储隐藏层第一层节点数和输出层节点数,输入层节点数,
//隐藏层最后一层节点数,隐藏层总的节点数
short ih_w_num =0,hh_w_num = 0; //ih_w_num,输入层到隐藏层第一层的权重总数,hh_w_num隐藏层之间的权重总数
short m_w_id; //权重主标识
float m_w; //临时变量存储权重
float m_bas; //临时变量存储偏倚
int idx = 0; //数据数组的行索引
double max_w=0; //最大权重增量
float change_w=0;//每次权重增量
isStop = false;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -