卷积神经网络原理及其C++/Opencv实现(6)—前向传播代码实现
首先列出本系列博文的链接：
4. 卷积神经网络原理及其C++/Opencv实现(4)—误反向传播法
5. 卷积神经网络原理及其C++/Opencv实现(5)—参数更新
在以上文章中，我们基本把5层网络的原理、公式推导讲过了，从本文开始，我们来讲一下基于C++和Opencv的5层卷积神经网络实现吧~
1. 结构体定义
(1) 卷积层的结构体
typedef struct convolutional_layer
{
int inputWidth; //输入图像的宽
int inputHeight; //输入图像的长
int mapSize; //卷积核的尺寸
int inChannels; //输入图像的数目
int outChannels; //输出图像的数目
vector<vector<Mat>> mapData; //四维float数组，卷积核本身是二维数据，m*n哥卷积核就是四维数组
Mat basicData; //偏置，个数为outChannels， 一维float数组
bool isFullConnect; //是否为全连接
vector<Mat> v; //进入激活函数的输入值,三维数组float型
vector<Mat> y; //激活函数后神经元的输出，三维数组float型
vector<Mat> d; // 网络的局部梯度,三维数组float型
}CovLayer;
(2) 池化层的结构体
typedef struct pooling_layer
{
int inputWidth; //输入图像的宽
int inputHeight; //输入图像的长
int mapSize; //卷积核的大小
int inChannels; //输入图像的数目
int outChannels; //输出图像的数目
int poolType; //池化的方法
Mat basicData; //偏置, 一维float数组
vector<Mat> y; //采样函数后神经元的输出,无激活函数，三维数组float型
vector<Mat> d; //网络的局部梯度,三维数组float型
vector<Mat> max_position; // 最大值模式下最大值的位置，三维数组float型
}PoolLayer;
(3) 输出层的结构
typedef struct nn_layer
{
int inputNum; //输入数据的数目
int outputNum; //输出数据的数目
Mat wData; // 权重数据，为一个inputNum*outputNum大小
Mat basicData; //偏置，大小为outputNum大小
Mat v; // 进入激活函数的输入值
Mat y; // 激活函数后神经元的输出
Mat d; // 网络的局部梯度
bool isFullConnect; //是否为全连接
}OutLayer;
(4) 5层网络的结构体
typedef struct cnn_network
{
int layerNum;
CovLayer C1;
PoolLayer S2;
CovLayer C3;
PoolLayer S4;
OutLayer O5;
Mat e; // 训练误差
Mat L; // 瞬时误差能量
}CNN;
(5) 训练参数的结构体
typedef struct train_opts
{
int numepochs; // 训练的迭代次数
float alpha; // 学习率
}CNNOpts;
2. 5层网络的初始化
(1) 卷积层结构体初始化
CovLayer initCovLayer(int inputWidth, int inputHeight, int mapSize, int inChannels, int outChannels)
{
CovLayer covL;
covL.inputHeight = inputHeight;
covL.inputWidth = inputWidth;
covL.mapSize = mapSize;
covL.inChannels = inChannels;
covL.outChannels = outChannels;
covL.isFullConnect = true; // 默认为全连接
// 权重空间的初始化，先行再列调用，[r][c]
srand((unsigned)time(NULL)); //设置随机数种子
for(int i = 0; i < inChannels; i++) //输入通道数
{
vector<Mat> tmp;
for(int j = 0; j < outChannels; j++) //输出通道数
{
Mat tmpmat(mapSize, mapSize, CV_32FC1); //初始化一个mapSize*mapSize的二维矩阵
for(int r = 0; r < mapSize; r++) //卷积核的高
{
for(int c = 0; c < mapSize; c++) //卷积核的宽
{
//使用随机数初始化卷积核
float randnum=(((float)rand()/(float)RAND_MAX)-0.5)*2; //生成-1~1的随机数
tmpmat.ptr<float>(r)[c] = randnum*sqrt(6.0/(mapSize*mapSize*(inChannels+outChannels)));
}
}
tmp.push_back(tmpmat.clone());
}
covL.mapData.push_back(tmp);
}
covL.basicData = Mat::zeros(1, outChannels, CV_32FC1); //初始化卷积层偏置的内存
int outW = inputWidth - mapSize + 1; //valid模式下卷积层输出的宽
int outH = inputHeight - mapSize + 1; //valid模式下卷积层输出的高
Mat tmpmat2 = Mat::zeros(outH, outW, CV_32FC1);
for(int i = 0; i < outChannels; i++)
{
covL.d.push_back(tmpmat2.clone()); //初始化局部梯度
covL.v.push_back(tmpmat2.clone()); //初始化输入激活函数之前的值
covL.y.push_back(tmpmat2.clone()); //初始化输入激活函数之后的值
}
return covL; //返回初始化之后的卷积层结构体
}
(2) 池化层结构体初始化
PoolLayer initPoolLayer(int inputWidth, int inputHeight, int mapSize, int inChannels, int outChannels, int poolType)
{
PoolLayer poolL;
poolL.inputHeight=inputHeight; //输入高度
poolL.inputWidth=inputWidth; //输入宽度
poolL.mapSize=mapSize; //卷积核尺寸，池化层相当于做一个特殊的卷积操作
poolL.inChannels=inChannels; //输入通道
poolL.outChannels=outChannels; //输出通道
poolL.poolType=poolType; //最大值模式1/平均值模式0
poolL.basicData = Mat::zeros(1, outChannels, CV_32FC1); //池化层无偏置，无激活，这里只是预留偏置内存
int outW = inputWidth/mapSize; //池化层的卷积核为2*2
int outH = inputHeight/mapSize;
Mat tmpmat = Mat::zeros(outH, outW, CV_32FC1);
Mat tmpmat1 = Mat::zeros(outH, outW, CV_32SC1);
for(int i = 0; i < outChannels; i++)
{
poolL.d.push_back(tmpmat.clone()); //局域梯度
poolL.y.push_back(tmpmat.clone()); //采样函数后神经元输出，无激活函数
poolL.max_position.push_back(tmpmat1.clone()); //最大值模式下最大值在原矩阵中的位置
}
return poolL;
}
(3) 输出层结构体初始化
OutLayer initOutLayer(int inputNum, int outputNum)
{
OutLayer outL;
outL.inputNum = inputNum;
outL.outputNum = outputNum;
outL.isFullConnect = true;
outL.basicData = Mat::zeros(1, outputNum, CV_32FC1); //偏置,分配内存的同时初始化为0
outL.d = Mat::zeros(1, outputNum, CV_32FC1);
outL.v = Mat::zeros(1, outputNum, CV_32FC1);
outL.y = Mat::zeros(1, outputNum, CV_32FC1);
// 权重的初始化
outL.wData = Mat::zeros(outputNum, inputNum, CV_32FC1); // 输出行，输入列,权重为10*192矩阵
srand((unsigned)time(NULL));
for(int i = 0; i < outputNum; i++)
{
float *p = outL.wData.ptr<float>(i);
for(int j = 0; j < inputNum; j++)
{
//使用随机数初始化权重
float randnum = (((float)rand()/(float)RAND_MAX)-0.5)*2; // 产生一个-1到1的随机数,rand()的取值范围为0~RAND_MAX
p[j] = randnum*sqrt(6.0/(inputNum+outputNum));
}
}
return outL;
}
(4) 5层网络结构体初始化
void cnnsetup(CNN &cnn, int inputSize_r, int inputSize_c, int outputSize) //cnn初始化
{
cnn.layerNum = 5;
//C1层
int mapSize = 5;
int inSize_c = inputSize_c; //28
int inSize_r = inputSize_r; //28
int C1_outChannels = 6;
cnn.C1 = initCovLayer(inSize_c, inSize_r, mapSize, 1, C1_outChannels); //卷积层1
//S2层
inSize_c = inSize_c - cnn.C1.mapSize + 1; //24
inSize_r = inSize_r - cnn.C1.mapSize + 1; //24
mapSize = 2;
cnn.S2 = initPoolLayer(inSize_c, inSize_r, mapSize, cnn.C1.outChannels, cnn.C1.outChannels, MaxPool); //池化层
//C3层
inSize_c = inSize_c / cnn.S2.mapSize; //12
inSize_r = inSize_r / cnn.S2.mapSize; //12
mapSize = 5;
int C3_outChannes = 12;
cnn.C3 = initCovLayer(inSize_c, inSize_r, mapSize, cnn.S2.outChannels, C3_outChannes); //卷积层
//S4层
inSize_c = inSize_c - cnn.C3.mapSize + 1; //8
inSize_r = inSize_r - cnn.C3.mapSize + 1; //8
mapSize = 2;
cnn.S4 = initPoolLayer(inSize_c, inSize_r, mapSize, cnn.C3.outChannels, cnn.C3.outChannels, MaxPool); //池化层
//O5层
inSize_c = inSize_c / cnn.S4.mapSize; //4
inSize_r = inSize_r / cnn.S4.mapSize; //4
cnn.O5 = initOutLayer(inSize_c*inSize_r*cnn.S4.outChannels, outputSize); //输出层
cnn.e = Mat::zeros(1, cnn.O5.outputNum, CV_32FC1); //输出层的输出值与标签值之差
}
3. 二维图像的卷积实现
调用Opencv的filter2D函数，可以很方便、很快速地实现二维卷积运算。我们首先实现full模式，valid和same模式地卷积结果可以直接从full模式的结果中截取。
需要注意的是，在卷积神经网络中，我们说的卷积运算其实是互相关运算，也即开始卷积运算之前卷积核不需要做顺时针180°的旋转。
Mat correlation(Mat map, Mat inputData, int type)
{
const int map_row = map.rows;
const int map_col = map.cols;
const int map_row_2 = map.rows/2;
const int map_col_2 = map.cols/2;
const int in_row = inputData.rows;
const int in_col = inputData.cols;
//先按full模式扩充图像边缘
Mat exInputData;
copyMakeBorder(inputData, exInputData, map_row_2, map_row_2, map_col_2, map_col_2, BORDER_CONSTANT, 0);
Mat OutputData;
filter2D(exInputData, OutputData, exInputData.depth(), map);
if(type == full) //full模式
{
return OutputData;
}
else if(type == valid) //valid模式
{
int out_row = in_row - (map_row - 1);
int out_col = in_col - (map_col - 1);
Mat outtmp;
OutputData(Rect(2*map_col_2, 2*map_row_2, out_col, out_row)).copyTo(outtmp);
return outtmp;
}
else //same模式
{
Mat outtmp;
OutputData(Rect(map_col_2, map_row_2, in_col, in_row)).copyTo(outtmp);
return outtmp;
}
}
4. 池化层的实现
(1) 均值池化
void avgPooling(Mat input, Mat &output, int mapSize)
{
const int outputW = input.cols/mapSize; //输出宽=输入宽/核宽
const int outputH = input.rows/mapSize; //输出高=输入高/核高
float len = (float)(mapSize*mapSize);
int i,j,m,n;
for(i = 0;i < outputH; i++)
{
for(j = 0; j < outputW; j++)
{
float sum=0.0;
for(m = i*mapSize; m < i*mapSize+mapSize; m++) //取卷积核大小的窗口求和平均
{
for(n = j*mapSize; n < j*mapSize+mapSize; n++)
{
sum += input.ptr<float>(m)[n];
}
}
output.ptr<float>(i)[j] = sum/len;
}
}
}
(2) 最大值池化
void maxPooling(Mat input, Mat &max_position, Mat &output, int mapSize)
{
int outputW = input.cols / mapSize; //输出宽=输入宽/核宽
int outputH = input.rows / mapSize; //输出高=输入高/核高
int i, j, m, n;
for (i = 0; i < outputH; i++)
{
for (j = 0; j < outputW; j++)
{
float max = -999999.0;
int max_index = 0;
for (m = i*mapSize; m<i*mapSize + mapSize; m++) //取卷积核大小的窗口的最大值
{
for (n = j*mapSize; n<j*mapSize + mapSize; n++)
{
if (max < input.ptr<float>(m)[n]) //求池化窗口中的最大值，并记录最大值位置
{
max = input.ptr<float>(m)[n];
max_index = m*input.cols + n;
}
}
}
output.ptr<float>(i)[j] = max; //求得最大值作为池化输出
max_position.ptr<int>(i)[j] = max_index; //记录最大值在原矩阵中的位置，用于反向传播
}
}
}
5. 激活函数与向量点乘函数的实现
(1) Relu函数
float activation_Sigma(float input, float bas)
{
float temp = input + bas;
return (temp > 0 ? temp: 0);
}
(2) Softmax函数
void softmax(OutLayer &O)
{
float sum = 0.0;
float *p_y = O.y.ptr<float>(0);
float *p_v = O.v.ptr<float>(0);
float *p_b = O.basicData.ptr<float>(0);
for (int i = 0; i < O.outputNum; i++)
{
float Yi = exp(p_v[i]+ p_b[i]);
sum += Yi;
p_y[i] = Yi;
}
for (int i = 0; i < O.outputNum; i++)
{
p_y[i] = p_y[i]/sum;
}
}
(3) 两个一维向量的点乘函数
以下函数中，vec1和vec2是两个长度相同的一维向量，点乘的结果就是它们对应位置的值相乘，然后把所有乘积相加的结果。
float vecMulti(Mat vec1, float *vec2)// 两向量相乘
{
float *p1 = vec1.ptr<float>(0);
float m = 0;
for (int i = 0; i < vec1.cols; i++)
m = m + p1[i] * vec2[i];
return m;
}
6. 5层网络前向传播的实现
(1) 卷积层前向传播
//输入的inputData有可能是一张图像，也有可能是多张图像，如果是多张图像，则把它们的卷积结果累加起来
void cov_layer_ff(vector<Mat> inputData, int cov_type, CovLayer &C)
{
for (int i = 0; i < (C.outChannels); i++)
{
for (int j = 0; j < (C.inChannels); j++)
{
//计算卷积，mapData为四维矩阵
Mat mapout = correlation(C.mapData[j][i], inputData[j], cov_type);
C.v[i] += mapout; //所有输入通道的卷积结果累加
}
int output_r = C.y[i].rows;
int output_c = C.y[i].cols;
for (int r = 0; r < output_r; r++)
{
for (int c = 0; c < output_c; c++)
{
C.y[i].ptr<float>(r)[c] = activation_Sigma(C.v[i].ptr<float>(r)[c], C.basicData.ptr<float>(0)[i]); //先加上偏置，再输入激活函数
}
}
}
}
(2) 池化层前向传播
#define AvePool 0
#define MaxPool 1
void pool_layer_ff(vector<Mat> inputData, int pool_type, PoolLayer &S)
{
if (pool_type == AvePool) //均值池化
{
for (int i = 0; i < S.outChannels; i++)
{
avgPooling(inputData[i], S.y[i], S.mapSize);
}
}
else if(pool_type == MaxPool) //最大值池化
{
for (int i = 0; i < S.outChannels; i++)
{
maxPooling(inputData[i], S.max_position[i], S.y[i], S.mapSize);
}
}
else
{
printf("pool type erroe!\n");
}
}
(3) 输出层前向传播
void nnff(Mat input, Mat wdata, Mat &output)
{
for (int i = 0; i < output.cols; i++) //分别计算多个向量相乘的乘积
output.ptr<float>(0)[i] = vecMulti(input, wdata.ptr<float>(i)); //由于输入激活函数之前就有加上偏置的操作，所以此处不再加偏置
}
void out_layer_ff(vector<Mat> inputData, OutLayer &O)
{
Mat OinData(1, O.inputNum, CV_32FC1); //输入192通道
float *OinData_p = OinData.ptr<float>(0);
int outsize_r = inputData[0].rows;
int outsize_c = inputData[0].cols;
int last_output_len = inputData.size();
for (int i = 0; i < last_output_len; i++) //上一层S4输出12通道的4*4矩阵
{
for (int r = 0; r < outsize_r; r++)
{
for (int c = 0; c < outsize_c; c++)
{
//将12通道4*4矩阵展开成长度为192的一维向量
OinData_p[i*outsize_r*outsize_c + r*outsize_c + c] = inputData[i].ptr<float>(r)[c];
}
}
}
//192*10个权重
nnff(OinData, O.wData, O.v); //10通道输出,1个通道的输出等于192个输入分别与192个权重相乘的和：∑in[i]*w[i], 0≤i<192
//Affine层的输出经过Softmax函数，转换成0~1的输出结果
softmax(O);
}
(4) 5层网络前向传播
void cnnff(CNN &cnn, Mat inputData)
{
//C1
//5*5卷积核
//输入28*28矩阵
//输出(28-25+1)*(28-25+1) = 24*24矩阵
vector<Mat> input_tmp;
input_tmp.push_back(inputData);
cov_layer_ff(input_tmp, valid, cnn.C1);
//S2
//24*24-->12*12
pool_layer_ff(cnn.C1.y, MaxPool, cnn.S2);
//C3
//12*12-->8*8
cov_layer_ff(cnn.S2.y, valid, cnn.C3);
//S4
//8*8-->4*4
pool_layer_ff(cnn.C3.y, MaxPool, cnn.S4);
//O5
//12*4*4-->192-->1*10
out_layer_ff(cnn.S4.y, cnn.O5);
}
好了，本文就讲到这里，接下来的文章我们来讲反向传播的实现和参数更新的实现，敬请期待~
欢迎扫码关注以下微信公众号，接下来会不定时更新更加精彩的内容噢～
