YOLOv3反向传播原理 之 全流程源码分析
YOLOv3反向传播原理 之 全流程源码分析
- 1.YOLOv3网络训练中反向传播主体流程
-
- 1.1 初始化
- 1.2 batch内梯度累加
- 1.3 network和layer 中的关键变量
- 2.YOLO层反向传播源码分析
- 3.卷积层（CNN）反向传播源码分析
-
- 3.1反向传播主函数backward_convolutional_layer源码分析
- 3.2重排和矩阵相乘函数源码分析
- 4.标准化层（batch_normalize层）反向传播源码分析
- 5.残差层（shortcut层）反向传播源码分析
- 6.路由层（route层）反向传播源码分析
- 7.激活函数相关源码分析
在前两篇文章《YOLOv3反向传播原理 之 公式推导》和《Batch Normalization原理 与 反向传播公式推导》中，我们对反向传播原理进行了推导。
求导过程分两步：一是对第 l l l层网络输出结果求导；二是对权重（包括偏置）求导，两个过程交替进行。需要关注的是对第 l − 1 l-1 l−1层网络输出结果求导时，需要将 l l l层的误差加权累加逆向传递到 l − 1 l-1 l−1层。
对于YOLOv3，我们大致回顾一下前向传播过程，数据先通过若干卷积层（卷积层中包含卷积、标准化和ReLU激活三个过程），再通过若干两层卷积层构成的残差结构（将 l − 2 l-2 l−2层的输出结果和 l l l层输出结果累加），然后进入YOLO层（YOLO层中只针对位置偏差和分类使用sigmoid函数进行处理，针对边框宽度和高度直接采用前一层卷积层输出的值，然后形成最终结果输出；后两个YOLO层需要通过路由层将前面YOLO层之前的内容先累加过来，这个叫做FPN方法（特征图金字塔网络））。
因此对于反向传播源码分析，我们分别针对YOLO层、卷积层（CNN）、路由层（route层）、残差层（shortcut层）、标准化层（batch_normalize层）进行分析，最后我们再对激活层进行简单说明。
1.YOLOv3网络训练中反向传播主体流程
反向传播存在于训练过程中，入口函数为detector.c的loss = train_network(net, train);下面是传播流程：
| 步骤 | 函数 | 源码文件 | 功能 |
|---|---|---|---|
| 1 | train_detector(datacfg, cfg, weights, gpus, ngpus, clear); | detector.c | 训练数据集，参数有数据路径文件、网络配置文件、权重文件、gpu地址及个数、是否清除已训练图片数量标记 |
| 2 | loss = train_network(net, train); | network.c | 在train_detector函数中，参数有网络数据结构network *net和data train。train通过线程函数循环按batch读入。 |
| 3 | float err = train_network_datum(net); | network.c | 在train_network函数中，参数net中包含net->input, net->truth等数据信息，net->input为resize后的三通道数据。 |
| 4 | backward_network(net); | network.c | 在train_network_datum函数中，参数net中更新了net->seen信息，就是每个批次训练过的图片数量 |
| 5 | l.backward(l, net); | darknet.h | 在backward_network函数中，按照层进行倒序循环调用，这个函数功能在make_yolo_layer、make_convolutional_layer中进行定义 |
| 6 | 通过l.backward进行每个层具体的反向传播计算 | l为当前层的layer，net中的input和delta为前一层的input和delta；更新的l.weight | |
| 7 | update_network(net); | network.c | 次步骤在backward_network(net)执行之后，对weight和biases进行更新 |
| 8 | save_weights(net, buff); | parse.c | 在完成一个batch的训练之后，在network结构体中更新一次weight，每训练100个batch，保存一次weights到一个新的weight文件，这里保存的除了卷积核还有每个层的偏置吧biases，这时候就算完成更新了w和b |
1.1 初始化
在之前《YOLOv3反向传播原理 之 公式推导》中推导反向传播公式时，都是针对一张图片的数据处理，但是在实际的软件实现中，每一次训练都是按照一个batch的图片进行训练，在上表第3步的train_network_datum函数中（源码如下），通过紧邻的forward_network(net)和backward_network(net)实现前向传播和反向传播。
float train_network_datum(network *net)
{
*net->seen += net->batch;
net->train = 1;
forward_network(net);//前向传播
backward_network(net);//反向传播
float error = *net->cost;
/*利用update_network(net)-->l.update(在不同层定义不同，
如在convolutional_layer.c中就是update_convolutional_layer)更新weight
*/
//训练图片达到一个整批就可以更新一次网络参数
if(((*net->seen)/net->batch)%net->subdivisions == 0) update_network(net);
return error;
}
在forward_network(net)中，r如果l.delta!=0通过，对整个批次的l.delta赋值为0，源码如下,：
//前向网络操作的核心代码
void forward_network(network *netp)
{
......
//#pragma omp parallel for
for(i = 0; i < net.n; ++i){
//每一个网络层循环一次
net.index = i;
layer l = net.layers[i];//这一步隐藏玄机，在一开始解析网络的时候，就决定了l会对应那个前向函数
if(l.delta){
fill_cpu(l.outputs * l.batch, 0, l.delta, 1);//输出×批尺寸，统统填0
}
......
}
}
......
}
1.2 batch内梯度累加
反向传播计算梯度的第一步是计算LOSS函数，LOSS函数中，是将一个batch的图片所有处理结果的误差（delta）进行累加计算的，所以在计算每个权重（weight）的梯度时，也需要在一个批次内进行累加。
前向传播的过程中，l.delta变量中存储了每个yolo层对一个批次内每个图片计算的误差，但是这些信息在这个阶段并没有累加，而是存储于内存，再最终计算weight的时候进行累加。
1.3 network和layer 中的关键变量
重点需要关注的几个输入输出变量：
network *net;
typedef struct network{
int n; // 网络总层数（make_network()时赋值），但是直接下载的现成的weight文件有现成的
int batch; // parse_net_options()中赋值：一个batch含有的图片张数，批处理的图片个数，一般再训练中的batch=cfg文件中batch值/subdivision
size_t *seen; // 目前已经读入的图片张数（网络已经处理的图片张数）（在make_network()中动态分配内存）
layer *layers; //存储网络所有的层的信息，在make_network()中动态分配内存
int inputs; //在实际操作过程中，input作为network的一部分，在network和layer两个结构体中有inputs和outputs
//注意，都是int型，表示一张输入图片的元素个数
//如果网络配置文件中未指定，则默认等于net->h * net->w * net->c，在parse_net_options()中赋值
int outputs; //一张输入图片对应的输出元素个数，对于一些网络，可由输入图片的尺寸及相关参数计算出
//比如卷积层，可以通过输入尺寸以及跨度、核大小计算出；
//对于另一些尺寸，则需要通过网络配置文件指定，如未指定，取默认值1，比如全连接层
float *delta; //存储一个临时梯度，一般是当前层前一层输出结果的梯度
float *workspace; //用于存储临时计算结果
float *input; // 中间变量，用来暂存某层网络的输入（包含一个batch的输入，比如某层网络完成前向，
// 将其输出赋给该变量，作为下一层的输入，可以参看network.c中的forward_network()与backward_network()两个函数），
// 当然，也是网络接受最原始输入数据（即第一层网络接收的输入）的变量
//（比如在图像检测训练中，最早在train_detector()->train_network()->get_next_batch()函数中赋值）
} network;
layer l,prev;
struct layer{
float * delta; //存储针对当前层输出结果的梯度
float * output; //当前层的输出feature map的集合
int w,h,c; //当前层输出的feature map宽度，高度，每组卷积核（滤波器）的个数，c的个数为前一层输出中feature map的个数，有时候也说是输出的维度
float * biases; //更新的偏置
float * bias_updates; //偏置的梯度
float * weights; //权重的梯度
float * weight_updates; //更新的权重，不知道是什么原因，作者编程时把权重和梯度形式上反着写
float * scales; //标准化中的尺度变换系数
float * scale_updates; //标准化中的尺度变换系数的梯度
int out_h, out_w, out_c; //当前层输出结果的高，宽，通道数
int n; //卷积核的组数，决定了当前层输出的feature map的个数
float * mean; //feature map均值，用于标准化层
float * variance; //feature map均方值，用于标准化层
float * mean_delta; //梯度均值，用于标准化层
float * variance_delta; //梯度均方值，用于标准化层
float * rolling_mean; //weight文件中的初始均值，用于标准化层
float * rolling_variance; //weight文件中的初始均方值，用于标准化层
int batch_normalize; //该层中是否有标准化
int batch; //一个层包含的处理的一个批次图片数量，主要为input,output,delta,weight等保存空间和确定计算次数，一般具体为多少看batch是否除以subdivisions，当说完成一个batch图片训练时候，需要除，当更新权重时候又会乘回来
int inputs; //一个层输入值的尺寸
int outputs; //一个层输出值的尺寸
int nweights; //一个层权重值的尺寸
int nbiases; //一个层偏置值的尺寸
};
下面我们就分析前面表格中的第6步中的内容：
2.YOLO层反向传播源码分析
YOLO层反向传播只有一个直接传播的步骤。l.delta存储的就是LOSS针对YOLO层前一层输出l.output的梯度，这个梯度求解过程中，使用平方差LOSS函数和交叉熵LOSS函数的效果都是一样的，这个推导过程在前一篇文章《YOLO中LOSS函数的计算》中有说明。YOLO反向传播的主函数（yolo_layer.c）如下：
//const layer l, network net分别对应表格第5步l.backward(l, net)中的l和net。
void backward_yolo_layer(const layer l, network net)
{
//axpy_cpu在blas.c中，主要用于将l.delta传递到前一层的net.delta中。
//这里参考make_yolo_layer函数，可知l.inputs = l.outputs = h*w*n*(classes + 4 + 1);
axpy_cpu(l.batch*l.inputs, 1, l.delta, 1, net.delta, 1);
}
axpy_cpu函数可以完成将X中元素乘以权值ALPHA，和Y中对应位置元素相乘。那么不是说好的直接传递吗？根据1.1节初始化的分析，前一层的delta统统赋值为0，所以累加等于赋值。说实话，本人感觉直接使用blas.h中的copy_cpu函数也是一样的效果。
void axpy_cpu(int N, float ALPHA, float *X, int INCX, float *Y, int INCY)
{
int i;
for(i = 0; i < N; ++i) Y[i*INCY] += ALPHA*X[i*INCX];
}
好了，把YOLO层的梯度求完了，按照cfg文件，就该到卷积层了。
3.卷积层（CNN）反向传播源码分析
3.1反向传播主函数backward_convolutional_layer源码分析
convolutional_layer类型实际上就是layer，在convolutional_layer.h中有声明：
typedef layer convolutional_layer;
接着看convolutional_layer.c中源码和分析：
//反向传播，反向的关键，反向传播的各种数据通过两个参数传递，一个是当前层（l层）layer，一个是前一层(l-1层)network
//convolutional_layer 的类型还是layer
//所有的*input,*output,*delta,*truth都是在network中的，因为这些信息需要连贯性
//每一层feature map的宽、高、每组卷积核中卷积核的个数，滤波器组数等信息都是在layer中。
//反向传播的计算和前向传播一样也是要用到重排和矩阵乘法计算
// net.delta = l.delta×激活函数对权重的误差，卷积误差传递
void backward_convolutional_layer(convolutional_layer l, network net)
{
//*************尺寸参数定义和初始化*****************//
int i, j;
int m = l.n/l.groups;//滤波器核函数的个数×组个数，这里group都是1，在parse.c中设置
int n = l.size*l.size*l.c/l.groups;//当前层卷积核总尺寸，size是卷积核的边长，l.c为卷积核(即滤波器)个数，当前层的卷积核用于处理l-1层输出
int k = l.out_w*l.out_h;//当前层一个feature map的尺寸，l.delta的维度为[l.n, l.out_w*l.out_h]，l.delta参考l.output
//*************计算一个CNN模块中经过激活层后的梯度*****************//
//gradient_array在activation.c中，求当前层经过激活函数的梯度，根据配置文件这里都是ReLU函数，l.output>0,则求导为结果为1×l.output，否则为0×l.output，这里的功能是经过激活层进行梯度传递，也可认为是传递误差
//l.delta为激活层计算得到的梯度，后续和当前层权重累乘相加完成梯度（误差）传递，l.activation为激活函数类型
gradient_array(l.output, l.outputs*l.batch, l.activation, l.delta);
//*************计算一个CNN模块中经过batch_normalize层后的梯度*****************//
//如果有batch_normalize层，则计算batch_normalize层传递结果
//如果没有，直接通过backward_bias完成计算不同图片输出结果的梯度累加
if(l.batch_normalize){
backward_batchnorm_layer(l, net);
} else {
//k为feature map尺寸，l.n为输出维度或feature map个数k×l.n=一个图片output输出的尺寸
backward_bias(l.bias_updates, l.delta, l.batch, l.n, k);
}
//*************计算一个CNN模块中经过CNN层后的梯度*****************//
//按批次图像循环，在计算权重的梯度的时候将针对前一层(l-1层)不同图片处理结果误差计算结果进行累加
//注意，前面不是已经把不同批次的delta都计算了一遍了吗，这里怎么又搞了一遍？前面计算的是第l层的梯度，累加后用于针对前一层每张图输出结果梯度的计算。这里累加是针对每张图计算结果的累加。
//其实我们很容易想到还有一种方法，就是前面先不累加，从一开始就逐图计算权重梯度，再最终累加。这种计算方法首先要占用很大的内存，另外还可能存在梯度消失
for(i = 0; i < l.batch; ++i){
for(j = 0; j < l.groups; ++j){
//l.delta为指针传递参数
//a是delta的矩阵，表示一个批次中第i个图处理结果的位置
float *a = l.delta + (i*l.groups + j)*m*k;
//创建一个空的workspace指针，用于缓存信息
float *b = net.workspace;
//当前层中已经更新的权重指针，l.nweights为所有卷积核中每个组的总权重尺寸，这里l.groups==1用不到
//当前层权重的尺寸为l.nweights，make_convolutional_layer中初始化了l.nweights = c/groups*n*size*size
float *c = l.weight_updates + j*l.nweights/l.groups;//更新的权重
//net.input就是前一层的输出，在公式中就是y(l-1)
float *im = net.input + (i*l.groups + j)*l.c/l.groups*l.h*l.w;
//net.delta就是前一层的梯度，即LOSS对前一层输出的梯度
float *imd = net.delta + (i*l.groups + j)*l.c/l.groups*l.h*l.w;//图像误差
//如果当前层卷积核尺寸为1，b = im，前一层的输出不用重排
if(l.size == 1){
b = im;
//如果当前层卷积核尺寸＞1，前一层的输出需要重排，便于计算对前一层的梯度时候后一层的权重与之相乘累加
} else {
im2col_cpu(im, l.c/l.groups, l.h, l.w,
l.size, l.stride, l.pad, b);
}
//*************计算当前CNN层权重的的梯度*****************//
//*****a不转置，b转置，beta = 1,则c=ab+c，表示将针对不同图片权重的梯度计算结果累加*****//
//更新了l.weight_updates + j*l.nweights/l.groups
//注意，这里a不转置，重排的b转置了，每一个卷积核对应的输出（每个输出平面）的尺寸l.out_w*l.out_h=重排后的列数，转置后变成行数
//然后得到每个feature map，即每个卷积核的weight的调整梯度，就是每个batch中的几张图片的导数要合并计算
//c = delta×图像，当前层delta×前一层输出y(即net.input)，叠加更新，求出来的是weight的导数
gemm(0,1,m,n,k,1,a,k,b,k,1,c,n);
//这一层用于求LOSS对前一层（l-1层）输出的梯度，原理就是将当前层的delta乘以计算当前层的权重，累加后进行误差传递
//如果net.delta ≠ 0,则进行下一步计算
//注意delta有network的也有layer的，net.delta是前一层的，l.delta是这一层的
if (net.delta) {
//当前层的权重指针
a = l.weights + j*l.nweights/l.groups;
//当前层的梯度指针l.delta
b = l.delta + (i*l.groups + j)*m*k;
c = net.workspace;
//如果卷积核尺寸为1，c不变，仍旧为前一层的梯度，此时卷积核的作用只有一个变换维度
if (l.size == 1) {
c = imd;
}
//*************计算针对前一层输出的的梯度*****************//
//*****a转置，b不转置，beta = 0,计算c = a×b，LOSS针对前一层输出的梯度不累加，放到下一层计算时候累加*****//
//b每一行行数就是l.n/groups,列数为l.w*l.h
//a是当前层权重，也是给前一层计算当前层的权重，很小的一行，一个卷积核排起来构成矩阵，行数为卷积核数，转置后成为列数，b就是delta,列数就是l.outputs×卷积核数
//转置后：a和c的行数为n(l.size*l.size*l.c/l.groups),列数为l.n，b和c的列数为k(l.out_w*l.out_h)
//转置后：a的列数和b的行数为l.n，a的步长为n，b的步长为k.
//a每个卷积核的参数行和b每一列相乘并相加，将不同通道相同位置的值加权再加在一起，这个很清楚：因为一个前一层的输出对应到不同的通道
//c就是乘得结果，存入workspace，作为中间量，求完存起来用于下个批次求梯度时候使用
gemm(1,0,n,k,m,1,a,n,b,k,0,c,k);
if (l.size != 1) {
//最后，再将net.workspace中的值,也就是c中的值转换成imd，存入前一层(l-1层)delta中，这是个指针变量传递，所以能够保存到layer[l-1]中