深度学习实践（二）——多层神经网络

#一、准备
为了更深入的理解神经网络，笔者基本采用纯C++的手写方式实现，其中矩阵方面的运算则调用opencv，数据集则来自公开数据集a1a。
实验环境：

• Visual studio 2017
• opencv3.2.0
• a1a数据集

本文紧跟上篇文章深度学习实践（一）——logistic regression。
#二、神经网络基础
标准的神经网络结构如下图所示，其实就是上文logistic regression的增强版（即多加了几个隐层），基本思路还未变化。关于更详细的原理介绍，这里还是推荐吴恩达的深度学习系列课程。

下面以三层神经网络（即上图）并结合a1a数据集，介绍构建的一般步骤：

1. 初始化参数w1、w2、w3和b1、b2、b3，因为a1a数据集的维度是有123个特征，所以上图中input_layer维度为（123，m），m为样本数量，如训练集则为1065；而我们所构建的三层神经网络中间隐层神经元个数分别为（64,16,1），所以初始化参数矩阵w1（123,64）、w2（64,16）、w3（16,1）和偏置实数b1、b2、b3。
2. 将W和X相乘（矩阵相乘，X为上层的输出，一开始即为样本的输入），再加上偏置b（为实数），则得到Z。
3. 将Z进行激活，在隐层选择激活函数relu（可以更好的防止梯度爆炸，且结果很好），输出层选择sigmoid限制输出，它们的图像如下：
4. 将上面的正向传播完成后，定义损失函数，这里使用交叉熵代价函数。
5. 反向传播，并更新参数。

正向传播基本公式：
这里上标L代表第几层，上标i表示第几个样本（对应到a1a数据集即第几行），如$A^{[0]}$表示0层的输入（即样本输入）。

$$Z^{[1]}=W^{[1]}{A}^{[0]}+b^{[1]}\text{\hspace{1em}(1)}$$
$$A^{[1]}=Relu(Z^{[1]})\text{\hspace{1em}(2)}$$
$$Z^{[2]}=W^{[2]}{A}^{[1]}+b^{[2]}\text{\hspace{1em}(3)}$$
$$A^{[2]}=Relu(Z^{[2]})\text{\hspace{1em}(4)}$$
$$Z^{[3]}=W^{[3]}{A}^{[2]}+b^{[3]}\text{\hspace{1em}(5)}$$
$$A^{[3]}=Sigmoid(Z^{[3]})\text{\hspace{1em}(6)}$$
$$\mathcal{L}(A^{[3]},\hat{Y})=-A^{[3]}\log (A^{[3]})-(1-\hat{Y})\log (1-A^{[3]})\text{\hspace{1em}(7)}$$

The cost is then computed by summing over all training examples:
$$J=\frac{1}{m}\sum _{i=1}^m\mathcal{L}(A^{(i)[3]},Y^{(i)})\text{\hspace{1em}(8)}$$

反向传播基本公式：
$$d{A}^{[3]}=\frac{\partial \mathcal{L}}{\partial A^{[3]}}=\frac{1-\hat{Y}}{1-A^{[3]}}-\frac{\hat{Y}}{A^{[3]}}\text{\hspace{1em}(1)}$$
$$d{Z}^{[3]}=\frac{\partial \mathcal{L}}{\partial A^{[3]}}\ast \frac{\partial A^{[3]}}{\partial Z^{[3]}}=dA[3]\ast A^{[3]}\ast (1-A^{[3]})\text{\hspace{1em}(2)}$$
$$d{W}^{[3]}=\frac{\partial \mathcal{L}}{\partial Z^{[3]}}\ast \frac{\partial Z^{[3]}}{\partial W^{[3]}}=\frac{1}{m}d{Z}^{[3]}{A}^{[2]T}\text{\hspace{1em}(3)}$$
$$d{b}^{[3]}=\frac{\partial \mathcal{L}}{\partial Z^{[3]}}\ast \frac{\partial Z^{[3]}}{\partial b^{[3]}}=\frac{1}{m}\sum _{i=1}^{m}d{Z}^{[3](i)}\text{\hspace{1em}(4)}$$
$$d{A}^{[2]}=\frac{\partial \mathcal{L}}{\partial Z^{[3]}}\ast \frac{\partial Z^{[3]}}{\partial A^{[2]}}=W^{[3]T}d{Z}^{[3]}\text{\hspace{1em}(5)}$$
$$d{Z}^{[2]}=\frac{\partial \mathcal{L}}{\partial A^{[2]}}\ast \frac{\partial A^{[2]}}{\partial Z^{[2]}}=d{A}^{[2]}\ast (A^{[2]}>0)\text{\hspace{1em}(6)}$$
$$d{W}^{[2]}=\frac{\partial \mathcal{L}}{\partial Z^{[2]}}\ast \frac{\partial Z^{[2]}}{\partial W^{[2]}}=\frac{1}{m}d{Z}^{[2]}{A}^{[1]T}\text{\hspace{1em}(7)}$$
$$d{b}^{[2]}=\frac{\partial \mathcal{L}}{\partial Z^{[2]}}\ast \frac{\partial Z^{[2]}}{\partial b^{[2]}}=\frac{1}{m}\sum _{i=1}^{m}d{Z}^{[2](i)}\text{\hspace{1em}(8)}$$
$$d{A}^{[1]}=\frac{\partial \mathcal{L}}{\partial Z^{[2]}}\ast \frac{\partial Z^{[2]}}{\partial A^{[1]}}=W^{[2]T}d{Z}^{[2]}\text{\hspace{1em}(9)}$$
$$d{Z}^{[1]}=\frac{\partial \mathcal{L}}{\partial A^{[1]}}\ast \frac{\partial A^{[1]}}{\partial Z^{[1]}}=d{A}^{[1]}\ast (A^{[1]}>0)\text{\hspace{1em}(10)}$$
$$d{W}^{[1]}=\frac{\partial \mathcal{L}}{\partial Z^{[1]}}\ast \frac{\partial Z^{[1]}}{\partial W^{[1]}}=\frac{1}{m}d{Z}^{[1]}{A}^{[0]T}\text{\hspace{1em}(11)}$$
$$d{b}^{[1]}=\frac{\partial \mathcal{L}}{\partial Z^{[1]}}\ast \frac{\partial Z^{[1]}}{\partial b^{[1]}}=\frac{1}{m}\sum _{i=1}^{m}d{Z}^{[1](i)}\text{\hspace{1em}(12)}$$

#三、实践
数据集介绍、处理及一些公用的函数已在系列的上一篇文章，故在此不做赘述（只写出函数声明）。

从文件中创建矩阵：

void creatMat(Mat &x, Mat &y, String fileName)；

初始化参数（这里使用xavier初始化）：

void initial_parermaters(Mat &w, double &b, int n1, int n0) {
	w = Mat::zeros(n1, n0, CV_64FC1);
	b = 0.0;

	//double temp = 2 / (sqrt(n1));
	double temp = sqrt(6.0 / (double)(n1 + n0));
	RNG rng;
	for (int i = 0; i < w.rows; i++) {
		for (int j = 0; j < w.cols; j++) {
			w.at<double>(i, j) = rng.uniform(-temp, temp);//xavier初始化
														  //w.at<double>(i, j) = 0;
		}
	}
}

relu函数的编写：

void relu(const Mat &original, Mat &response) {
	response = original.clone();//防止维度不同
	for (int i = 0; i < original.rows; i++) {
		for (int j = 0; j < original.cols; j++) {
			if (original.at<double>(i, j) < 0) {
				response.at<double>(i, j) = 0.0;
			}
		}
	}
}

正向传播：

void linear_activation_forward(Mat &a_prev, Mat &a, Mat &w, double &b, string activation) {
	cv::Mat z;
	if (activation == "sigmoid") {
		z = (w*a_prev) + b;
		//cout << w.rows<<","<<w.cols<<" " << a_prev.rows<<","<<a_prev.cols<<endl;

		sigmoid(z, a);
	}
	else if (activation == "relu") {
		z = (w*a_prev) + b;
		//cout << w.rows << "," << w.cols << " " << a_prev.rows << "," << a_prev.cols << endl;

		relu(z, a);
	}
}

反向传播：

void activation_backward(const Mat &a, const Mat &da, Mat &dz, string activation) {
	if (activation == "sigmoid") {

		dz = da.mul(a.mul(1 - a));
	}
	else if (activation == "relu") {
		dz = da.clone();//保证维度相同
		for (int i = 0; i < a.rows; i++) {
			for (int j = 0; j < a.cols; j++) {
				if (a.at<double>(i, j) <= 0) {
					dz.at<double>(i, j) = 0.0;
				}
			}
		}
	}

}

void linear_backward(const Mat &da, const Mat &a, const Mat &a_prev, Mat &w, double &b, Mat &dw, double &db, Mat &da_prev, const int m, const double learning_rate, string activation) {
	cv::Mat dz;
	activation_backward(a, da, dz, activation);//激活函数的反向传播

	dw = (1.0 / m)*dz*a_prev.t();
	db = (1.0 / m)*sum(dz)[0];
	da_prev = w.t()*dz;
	w = w - (learning_rate * dw);
	b = b - (learning_rate * db);
}

#四、实验结果分析
迭代8000次cost分析：

我们容易发现更高的学习率可以获得较低的cost值，但是当其迭代到一定次数时，会有一定的起伏。

迭代8000次，准确率分析：

通过上图，易发现在一定迭代次数后，训练集和测试集准确率都会产生起伏，而且当训练集准确率不断上升时，测试集却未增长反而下降，最终产生了过拟合现象。

#五、结语

神经网络层数深，参数多，所以很难训练，一般训练8000次所需时间很长，下面的一篇文章主要讲一些优化方法（如adam），及如何处理过拟合（如dropout）等。

实验地址：码云