游戏编程中的人工智能技术-神经网络入门（一）

     有一段时间没有更新了，原本是准备更新TSP-旅行商问题，不过感觉在TSP问题的章节中，Buckland大神写的过于理论化，不是几篇博客可以解释的通的，我自己还有很多问题没有搞清楚。因此先跳到第七章-神经网络入门。

    神经网络近段时间可以算是大热了，自从阿尔法狗击败李世石后，深度学习和卷积神经网络成了热门话题，不搞点cnn、caffe都不好意思跟别人说话。不过再怎么吹好歹先打好基础是不是，否则大厦不是说倒就倒？所以，咱先学习点神经网络的基本知识。

    虽然神经网络现在挺火，不过它的发明倒是蛮早的，当时可是和SVM并驾齐驱的两大法宝。不过自从被一个大神喷了之后，神经网络算是衰败了好长时间（大神的意思是你这个神经网络不能解决“异或”问题，啥是“异或”问题咋也别管，反正就是不能解决非线性分类这样的问题）。所幸是现在这些问题都解决了，神经网络又焕发了第二春了。

    大体历史就是这样，具体我也记不太清楚，反正这篇文章也不是介绍历史的。所以到此为止。

    在说说神经网络的分类，与机器学习一样，神经网络分为两类：有监督神经网络和无监督神经网络。有监督神经网络表示首先你要有个训练集给神经网络进行训练，然后神经网络就能举一反三了，这个和感知机差不多。另一种称之为无监督神经网络，也就是我们这次介绍的神经网络，其权值优化全靠自己所定义的适应度函数，以及靠遗传算法来优化这些适应度函数。

    接下来到了神经网络的结构了，神经网络是一个金字塔式，一层一层的结构。最底下一层是“输入”，n个输入进到一个神经元细胞中去，第二层是神经元细胞，其结构如下图所示：

神经元细胞具有多个输入，一般只有一个输出;1或者0，想要得到多个输出，不好意思啦，多用几个神经元细胞组合起来。

第三层是“层”：是由多个神经细胞组合在一起，一般会平行的排列成一个层。

第四层：就是整个网络了。

结构如上所示：一个网络里分为输入层，输出层和隐藏层。必须注意的是：输入层只有输入，没有神经元。

通过以上神经网络结构的介绍，可以看出，神经网络结构还是比较复杂的，尤其体现在代码上，又是神经元又是层又是网络的。所以代码的层次性一定要好。

神经网络的具体原理就不介绍了，同学们可以参考神经网络入门。如果真要推荐参考书的话，推荐《神经网络设计》，浅显易懂，比那些显摆的书好多了。接下来开始介绍代码。

1：CNeuralNet：神经网络部分

（1）神经元类：SNeuron

struct SNeuron
{
	//the number of inputs into the neuron
	int				      m_NumInputs;//神经元的输入，也可以算是输入层

	//the weights for each input
	vector<double>	m_vecWeight;//神经元的权重


	//ctor
	SNeuron(int NumInputs);//构造函数
};

构造函数如下：

SNeuron::SNeuron(int NumInputs): m_NumInputs(NumInputs+1)//因为要加上偏移量，所以输入要加1
											
{
	//we need an additional weight for the bias hence the +1
	for (int i=0; i<NumInputs+1; ++i)
	{
		//set up the weights with an initial random value
		m_vecWeight.push_back(RandomClamped());//向量m_vecWeight存储了神经元的权重值，初始的时候，权重为任意值。别担心，以后这些值会慢慢优化。
	}
}

（2）神经网络“层”类：SNeuronLayer：

struct SNeuronLayer
{
	//the number of neurons in this layer
	int					      m_NumNeurons;//一个层里含有的神经元的数目

	//the layer of neurons
	vector<SNeuron>		m_vecNeurons;//向量m_vecNeurons存放了一系列的神经元SNeuron，这些神经元构成了一个层



	SNeuronLayer(int NumNeurons, 
				       int NumInputsPerNeuron);//构造函数，NumNeurons为层里含有的神经元数，NumInputsPerNeuron为一个神经元所含的输入数,

//即：第一个参数为神经层的输出个数（每一个神经元便有一个输出），第二个参数为神经层的输入个数（每一个神经元的输入是一致的，也是整个层的输入个数）


};

构造函数：

SNeuronLayer::SNeuronLayer(int NumNeurons, 
                           int NumInputsPerNeuron):	m_NumNeurons(NumNeurons)
{
	for (int i=0; i<NumNeurons; ++i)

m_vecNeurons.push_back(SNeuron(NumInputsPerNeuron));//向量m_vecNeurons存放了一系列的神经元SNeuron，每一个SNeuron含有NumInputsPerNeuron个输入

}

（3）神经网络的结构类：CNeuralNet

class CNeuralNet
{
	
private:
	
	int					m_NumInputs;//输入个数

	int					m_NumOutputs;//输出个数

	int					m_NumHiddenLayers;//隐藏层个数，注：除了输出层都是隐藏层

	int					m_NeuronsPerHiddenLyr;//每个隐藏层包含的神经元个数

	//storage for each layer of neurons including the output layer
	vector<SNeuronLayer>	m_vecLayers;//向量m_vecLayers存储了一系列的神经层，即构成了整个神经网络


public:

	CNeuralNet();//构造函数

	void			      CreateNet();//创建整个网络

	//gets the weights from the NN
	vector<double>	GetWeights()const;//获得每个层的每个神经元的每个权重（注意有三个“每个”，因此详细程序中是三重循环）

	//returns total number of weights in net
	int				      GetNumberOfWeights()const;//所有权重数量总和

	//replaces the weights with new ones
	void			      PutWeights(vector<double> &weights);//更新每个层的每个神经元的每个权重，新权重存放在double向量weights里。

//注：为何是取址&weights？不是直接取值weights？


	//calculates the outputs from a set of inputs
	vector<double>	Update(vector<double> &inputs);//由输入，神经网络来计算输出的程序

	//sigmoid response curve
	inline double	  Sigmoid(double activation, double response);//神经网络的原始再经过sigmoid函数。类似于经过一个阈值

};

这个是重点，接下来介绍每一个子程序，第一个：构造函数CNeuralNet() 

CNeuralNet::CNeuralNet() 
{
	m_NumInputs	          =	CParams::iNumInputs;
	m_NumOutputs		      =	CParams::iNumOutputs;
	m_NumHiddenLayers	    =	CParams::iNumHidden;
	m_NeuronsPerHiddenLyr =	CParams::iNeuronsPerHiddenLayer;

	CreateNet();//构造函数主要用来引出CreateNet()函数

}

接下来：CreateNet()函数

void CNeuralNet::CreateNet()
{
	//create the layers of the network
	if (m_NumHiddenLayers > 0)
	{
		//create first hidden layer
	  m_vecLayers.push_back(SNeuronLayer(m_NeuronsPerHiddenLyr, m_NumInputs));//创建第一隐藏层，注意第一隐藏层和输出层
	  //要单独创建，为何呢？因为第一层的输入、输出层的输出比较特殊，而其他隐藏层的输入和输出就都一样了
    
    for (int i=0; i<m_NumHiddenLayers-1; ++i)//这个除了第一层和输出层以外的其他隐藏层
    {

			m_vecLayers.push_back(SNeuronLayer(m_NeuronsPerHiddenLyr,
                                         m_NeuronsPerHiddenLyr));
    }

    //create output layer
	  m_vecLayers.push_back(SNeuronLayer(m_NumOutputs, m_NeuronsPerHiddenLyr));//这是输出层
	}

  else
  {
	  //create output layer
	  m_vecLayers.push_back(SNeuronLayer(m_NumOutputs, m_NumInputs));//如果没有隐藏层则直接创建输出层
  }
}

获得所有神经元的权重GetWeights() const：

vector<double> CNeuralNet::GetWeights() const
{
	//this will hold the weights
	vector<double> weights;
	
	//for each layer
	for (int i=0; i<m_NumHiddenLayers + 1; ++i)//第一重循环，每一层
	{


		//for each neuron
		for (int j=0; j<m_vecLayers[i].m_NumNeurons; ++j)//第二重循环，每一层的每一个神经元
		{
			//for each weight
			for (int k=0; k<m_vecLayers[i].m_vecNeurons[j].m_NumInputs; ++k)//第三重循环，每一层的每一个神经元的每一个权重
			{
				weights.push_back(m_vecLayers[i].m_vecNeurons[j].m_vecWeight[k]);//将每一层的每一个神经元的每一个权重
																				//取出来放到向量weights里
			}
		}
	}


	return weights;//返回的是一个向量
}

返回权重数目：

int CNeuralNet::GetNumberOfWeights() const
{

	int weights = 0;
	
	//for each layer
	for (int i=0; i<m_NumHiddenLayers + 1; ++i)//同上，三重循环
	{

		//for each neuron
		for (int j=0; j<m_vecLayers[i].m_NumNeurons; ++j)
		{
			//for each weight
			for (int k=0; k<m_vecLayers[i].m_vecNeurons[j].m_NumInputs; ++k)
			
				weights++;
			
		}
	}

	return weights;//返回的是个int值
}

将更新后的权重放入神经网络

void CNeuralNet::PutWeights(vector<double> &weights)
{
	int cWeight = 0;
	
	//for each layer
	for (int i=0; i<m_NumHiddenLayers + 1; ++i)
	{

		//for each neuron
		for (int j=0; j<m_vecLayers[i].m_NumNeurons; ++j)
		{
			//for each weight
			for (int k=0; k<m_vecLayers[i].m_vecNeurons[j].m_NumInputs; ++k)
			{
				m_vecLayers[i].m_vecNeurons[j].m_vecWeight[k] = weights[cWeight++];
			}
		}
	}

	return;//参数为权重的更新集，没有返回值
}

神经网络计算程序：

vector<double> CNeuralNet::Update(vector<double> &inputs)
{
	//stores the resultant outputs from each layer
	vector<double> outputs;

	int cWeight = 0;
	
	//first check that we have the correct amount of inputs
	if (inputs.size() != m_NumInputs)
  {
		//just return an empty vector if incorrect.
		return outputs;
  }
	
	//For each layer....
	for (int i=0; i<m_NumHiddenLayers + 1; ++i)//对每一层
	{		
		if ( i > 0 )
    {
			inputs = outputs;//输出赋值到输入，这个类似于把旧的值存储下来的功能，因为下一层的输入便是上一层的输出
    }

		outputs.clear();//输出再清零，用于存储下一层的输出
		
		cWeight = 0;//权重向量序号清零

		//for each neuron sum the (inputs * corresponding weights).Throw 
		//the total at our sigmoid function to get the output.
		for (int j=0; j<m_vecLayers[i].m_NumNeurons; ++j)//对每一层的每一个神经元
		{
			double netinput = 0;

			int	NumInputs = m_vecLayers[i].m_vecNeurons[j].m_NumInputs;//每一个神经元的输入数目
			
			//for each weight
			for (int k=0; k<NumInputs - 1; ++k)//每一个权重，因为神经元的输入数目就等于权重数目
			{
				//sum the weights x inputs
				netinput += m_vecLayers[i].m_vecNeurons[j].m_vecWeight[k] * 
                    inputs[cWeight++];//这个就是神经元的输出模型了
			}

			//add in the bias
			netinput += m_vecLayers[i].m_vecNeurons[j].m_vecWeight[NumInputs-1] * 
                  CParams::dBias;//输出模型再加上偏移量就是完整神经元输出了

			//we can store the outputs from each layer as we generate them. 
      //The combined activation is first filtered through the sigmoid 
      //function
			outputs.push_back(Sigmoid(netinput,
                                CParams::dActivationResponse));//再加上sigmoid函数就完整了

			cWeight = 0;
		}
	}

	return outputs;//这边是真正的神经网络输出
}