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?1$層網絡輸出結果求導時，需要將 $l$層的誤差加權累加逆向傳遞到 $l?1$層。
對于YOLOv3，我們大致回顧一下前向傳播過程，數據先通過若干卷積層（卷積層中包含卷積、標準化和ReLU激活三個過程），再通過若干兩層卷積層構成的殘差結構（將 $l?2$層的輸出結果和 $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 forfor(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值/subdivisionsize_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*sizefloat *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.deltab = 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]中//計算net.delta。imd和net.delta + (i*l.groups + j)*l.c/l.groups*l.h*l.w指向相同的內存col2im_cpu(net.workspace, l.c/l.groups, l.h, l.w, l.size, l.stride, l.pad, imd);}}}} }

3.2重排和矩陣相乘函數源碼分析

這里涉及到輸出結果重排和矩陣相乘，先說說原理。
大家都知道卷積計算是使用一個卷積核在一個矩陣上滑動計算一個結果，放在新的輸出矩陣相應的位置，我們可以通過循環在被卷積的矩陣上截取出滑窗位置和卷積核相同大小的一個子矩陣，把卷積核與這個子矩陣拉直求內積，得到輸出矩陣相應位置的一個元素；得到一個輸出矩陣后，我們再計算第二個、第三個…第l.c個卷積核，完后再將這些矩陣累加。這個反復截取，計算內積，再在輸出矩陣對應位置賦值，再將不同通道矩陣（不同的feature map）的方法首先需要占用大量的內存，另外也不適宜在編譯過程中進行優化，同時還支持使用GPU并行優化計算的一些通用庫。
怎么辦呢？我們發現把卷積核與子矩陣拉直求內積的過程只不過是矩陣運算過程中卷積核拉直的行向量和截取的這一子矩陣拉直構成的列向量相乘的過程。另外，不同矩陣疊加的時候，相當于不同卷積核拼接的一個加長的行向量，和這些不同通道矩陣中截取的子矩陣拼接的一個加長的列向量求內積的過程。
這樣求得的一個內積就是什么呢？就是一個滑動窗口位置計算的結果。但是有一個問題，就是計算后一個濾波器（卷積核）組和被卷積矩陣的結果全都拉直放在一行了，這是因為被卷積矩陣中截取的子矩陣構成的列向量被不斷的橫向排列。
此時，細心的朋友會發現，咦，我們的所有卷積核也不過是排了一行呀。為了計算不同的濾波器（卷積核）組和被卷積的矩陣的卷積。我們只需要把第二個、第三個…濾波器拉直的行向量豎著拍排起來，不就可以構成一個矩陣了嗎，這些計算結果的行數之和濾波器組的個數有關，而且每一行結果都互不影響。這樣，就通過重排和一次大型的矩陣運算一網打盡。
這個工作完成之后，我們將不同行還原回矩陣，就構成了一個一個輸出feature map輸出。完美！
這個過程對于矩陣運算熟悉的同學就是一次完美的思維體操，你get到了嗎？
為了方便大家理解，我這里就直接借鑒caicaiatnbu博主https://blog.csdn.net/caicaiatnbu/article/details/102816291中的一幅圖，大家可以對照思考一下是不是這樣。
第一幅圖是正常的卷積過程
第二幅圖是重排后的卷積過程(還是引用caicaiatnbu博主)：

下面我們說說都使用了什么函數，關于重排一個是im2col.c中的：

//From Berkeley Vision's Caffe! //https://github.com/BVLC/caffe/blob/master/LICENSE void im2col_cpu(float* data_im,int channels, int height, int width,int ksize, int stride, int pad, float* data_col) {int c,h,w;//height_col = （高度 + 2倍的填充 - 滑窗尺寸）/步幅 +1//即滑動次數，也是輸出矩陣的高度int height_col = (height + 2*pad - ksize) / stride + 1;//width_col = （寬度 + 2倍的填充 - 滑窗尺寸）/步幅 +1int width_col = (width + 2*pad - ksize) / stride + 1;//channels_col = 通道數 × 卷積核滑窗元素個數int channels_col = channels * ksize * ksize;for (c = 0; c < channels_col; ++c) {int w_offset = c % ksize;//寬度上偏置調整 = channels_col 對 劃窗尺寸 取模int h_offset = (c / ksize) % ksize;//高度偏置調整 = （channels_col / 劃窗尺寸） 再取模int c_im = c / ksize / ksize;//c_im = 第幾個通道數通道數for (h = 0; h < height_col; ++h) {for (w = 0; w < width_col; ++w) {int im_row = h_offset + h * stride;int im_col = w_offset + w * stride;//col_index一行一行刷完一幅圖（輸出圖），再換個通道，關鍵是im_row和im_col//先按橫向步幅隔位取值，取完一行，再按縱向步幅隔位取值，所以第一個取值塊每次×的值都是一樣的，//所有的取值分為channels_col個塊int col_index = (c * height_col + h) * width_col + w;data_col[col_index] = im2col_get_pixel(data_im, height, width, channels,im_row, im_col, c_im, pad);}}} }

一個是col2im.c中的col2im_cpu，和上一個函數相反，不再進行注釋，大家自己看：

void col2im_cpu(float* data_col,int channels, int height, int width,int ksize, int stride, int pad, float* data_im) {int c,h,w;int height_col = (height + 2*pad - ksize) / stride + 1;int width_col = (width + 2*pad - ksize) / stride + 1;int channels_col = channels * ksize * ksize;for (c = 0; c < channels_col; ++c) {int w_offset = c % ksize;int h_offset = (c / ksize) % ksize;int c_im = c / ksize / ksize;for (h = 0; h < height_col; ++h) {for (w = 0; w < width_col; ++w) {int im_row = h_offset + h * stride;int im_col = w_offset + w * stride;int col_index = (c * height_col + h) * width_col + w;double val = data_col[col_index];col2im_add_pixel(data_im, height, width, channels,im_row, im_col, c_im, pad, val);}}} }

關于矩陣運算，使用了gemm.c中的gemm函數，這里只對主函數參數進行注釋：

/* transa -- 數據類型: char； 功能：設定矩陣A是否轉置, ‘N'或 'n' 為不轉置, ‘T'或 't' 或'C'或 'c' 表示矩陣A需轉置. transb -- 數據類型: char； 功能：設定矩陣B是否轉置, ‘N'或 'n' 為不轉置, ‘T'或 't' 或'C'或 'c' 表示矩陣B需轉置. m -- 數據類型: int； 功能：矩陣A和矩陣C的行數. n -- 數據類型: int； 功能：矩陣B和矩陣C的列數. k -- 數據類型: int； 功能：矩陣A列數和矩陣B的行數. alpha -- 數據類型: float； 功能：數乘系數. 一般設置為1 a -- 數據類型: float array； 功能：保存矩陣A. lda -- 數據類型: int； 功能：矩陣A的遞增步長.就是計算時候折彎的位置，當正常的兩個矩陣相乘，可設置為k， b -- 數據類型: float array； 功能：保存矩陣B. ldb -- 數據類型: int； 功能：矩陣B的遞增步長. beta -- 數據類型: float； 功能：數乘系數.一般設置為1 c -- 數據類型: float array; 功能：保存矩陣C, 計算結果寫入矩陣C. ldc -- 數據類型: int； 功能：矩陣C的遞增步長 */ void gemm(int TA, int TB, int M, int N, int K, float ALPHA, float *A, int lda, float *B, int ldb,float BETA,float *C, int ldc) {gemm_cpu( TA, TB, M, N, K, ALPHA,A,lda, B, ldb,BETA,C,ldc); }

以上就是卷積反向傳播的源碼分析啦，是不是很過癮！

4.標準化層（batch_normalize層）反向傳播源碼分析

batch_normalize層是針對l.output每個通道中的數據進行處理，前向過程的公式如下：
$$l.output==l.scales\frac{l.output?l.rolling\_mean}{\sqrt{l.rolling\_variance}+.000001f}+l.biases$$

其中，$l.rolling\_mean=0.99?l.rolling\_mean+0.01?l.mean$，
$l.rolling\_variance=0.99?l.rolling\_variance+0.01?l.variance$

關于源碼中的l.rolling_mean和 l.rolling_variance都在weight文件中有定義，作為初始值從遷移學習的預學習模型中獲得，為了防止計算l.mean和 l.variance導致過大的波動偏差，實際計算的feature map每個通道的均值和均方差都是滾動更新的，每次之更新百分之一，如果是訓練，就更新，如果是只有預測，就直接用weight文件中的$l.rolling\_m$和$l.rolling\_variance$。這些在之前的文章《darknet 框架中YOLO權重文件的種類及存儲結構》中也有介紹。通常默認$l.scales=1$，而且l.biases通常和normalize過程中的偏置合并計算。
反向傳播的過程主要完成梯度傳播、bias和scale梯度的求導。bias梯度的需要將每個通道中所有的后面傳過來的delta都累加起來。事實上，沒完成一次滑窗，偏置都要再feature map的一個元素中計算一次，這樣偏置就對每個輸出值都使用過一次，這些分立的delta指向共同的偏置梯度更新，把所有的都delta加起來不失為一種合理的方法，其實也可以采用平均，平均后加權重等方法。scale的求導和bias類似。
具體的傳播原理和公式推導見面文章《Batch Normalization原理 與 反向傳播公式推導》，但是YOLO作者的求導思路很清奇，按照鏈式法則
$$\frac{?LOSS}{?z_m}=\frac{?LOSS}{?z_n^o}\frac{?z_n^o}{?z_n^{norm}}\frac{?z_n^{norm}}{?z_m}$$

作者將這個過程拆分成三個步驟：
步驟1：由于$\frac{?z_n^o}{?z_n^{norm}}=scale$，作者使用scale_bias()函數將這個結果乘到l.delta上。
步驟2：對于$z_n^{norm}=\frac{z_n?Mean(\text{z})}{\sqrt{Var(\text{z})}}$，根據求導法則得到
$$\frac{?z_n^{norm}}{?z_m}=\frac{?z_n}{?z_m}\frac{1}{\sqrt{Var(\text{z})}}+\frac{?(?Mean(\text{z}))}{?z_m}\frac{1}{\sqrt{Var(\text{z})}}+\frac{?\frac{1}{\sqrt{Var(\text{z})}}}{?z_m}(z_n?Mean(\text{z}))$$
使用mean_delta_cpu()函數和variance_delta_cpu()計算后面兩項再乘以l.delta
步驟3：使用normalize_delta_cpu()函數將三部分合體。

我們直接看源碼：

//注意l.rolling_mean就是用于調整用的，對于每個層都只有1個值，是提前預置到weight文件中 void forward_batchnorm_layer(layer l, network net) {//如果當前這個層本身就是是個BATCHNORM層，先將net.input復制給l.output//如果當前這個層為CNN層，里面有BATCHNORM的函數操作，就將輸出值給l.xif(l.type == BATCHNORM) copy_cpu(l.outputs*l.batch, net.input, 1, l.output, 1);copy_cpu(l.outputs*l.batch, l.output, 1, l.x, 1);//如果這個過程是訓練的過程if(net.train){mean_cpu(l.output, l.batch, l.out_c, l.out_h*l.out_w, l.mean);//在blas.c中，對l.output每個通道所有值求一個平均值variance_cpu(l.output, l.mean, l.batch, l.out_c, l.out_h*l.out_w, l.variance);//在blas.c中，對l.output每個通道所有值求一個方差scal_cpu(l.out_c, .99, l.rolling_mean, 1);//3個rolling_mean賦值為0.99，rolling_mean在weight文件中axpy_cpu(l.out_c, .01, l.mean, 1, l.rolling_mean, 1);//將每個平均值乘以0.01再加上rolling_meanscal_cpu(l.out_c, .99, l.rolling_variance, 1);axpy_cpu(l.out_c, .01, l.variance, 1, l.rolling_variance, 1);//標準化函數，對l.output完成不加縮放和平移的標準化處理后存入l.outputnormalize_cpu(l.output, l.mean, l.variance, l.batch, l.out_c, l.out_h*l.out_w);copy_cpu(l.outputs*l.batch, l.output, 1, l.x_norm, 1);//將標準化的l.output輸出到l.x_norm中} else {//非訓練的條件下，通過rolling_mean和rolling_variance進行標準化，這兩個值在weight文件中normalize_cpu(l.output, l.rolling_mean, l.rolling_variance, l.batch, l.out_c, l.out_h*l.out_w);}//l.scales在make函數中默認設置為1scale_bias(l.output, l.scales, l.batch, l.out_c, l.out_h*l.out_w);//輸出進行標準化的尺度變換add_bias(l.output, l.biases, l.batch, l.out_c, l.out_h*l.out_w);//l.biases為每次偏置，給l.output加偏置，標準化的偏置和卷積層的偏置合并計算 }//所有的計算都有明確的公式，參考mini-batch normalization那篇論文 void backward_batchnorm_layer(layer l, network net) {//如果不是訓練網絡，則直接將weight文件中的l.rolling_mean賦值給l.mean，將l.rolling_variance賦值給l.varianceif(!net.train){ l.mean = l.rolling_mean;l.variance = l.rolling_variance;}//求偏置的梯度，方法是將同一批次不同通道傳遞過來的delta累加起來//定義在convolutional_layer.c中，因為CNN層中的偏置bias和BN層偏置bias合并計算backward_bias(l.bias_updates, l.delta, l.batch, l.out_c, l.out_w*l.out_h);//求更新的尺度變換scale的梯度，x_norm為標準化的l.output,計算方法是求l.x_norm和l.delta的內積//參考forward_batchnorm_layer，更新結果存入l.scale_updatesbackward_scale_cpu(l.x_norm, l.delta, l.batch, l.out_c, l.out_w*l.out_h, l.scale_updates);//求導步驟1，l.x對l.norm求導，方法就是l.delta×l.scalesscale_bias(l.delta, l.scales, l.batch, l.out_c, l.out_h*l.out_w);//求導步驟2，根據求導法則，將l.norm對每個元素求導拆成三部分，這里求mean和variance部分的求導mean_delta_cpu(l.delta, l.variance, l.batch, l.out_c, l.out_w*l.out_h, l.mean_delta);variance_delta_cpu(l.x, l.delta, l.mean, l.variance, l.batch, l.out_c, l.out_w*l.out_h, l.variance_delta);//依據公式計算出delta(LOSS)/delta(output)，將拆的三部分合體normalize_delta_cpu(l.x, l.mean, l.variance, l.mean_delta, l.variance_delta, l.batch, l.out_c, l.out_w*l.out_h, l.delta);if(l.type == BATCHNORM) copy_cpu(l.outputs*l.batch, l.delta, 1, net.delta, 1);//注意，計算的結果存入net.dalta }

其中，

//每個通道計算一個xnorm和delta的內積 void backward_scale_cpu(float *x_norm, float *delta, int batch, int n, int size, float *scale_updates) {int i,b,f;for(f = 0; f < n; ++f){float sum = 0;for(b = 0; b < batch; ++b){for(i = 0; i < size; ++i){int index = i + size*(f + n*b);//遍歷每一個delta值sum += delta[index] * x_norm[index];//delta與xnorm的內積}}scale_updates[f] += sum;//每個通道單獨計算一個更新值} }void mean_delta_cpu(float *delta, float *variance, int batch, int filters, int spatial, float *mean_delta) {int i,j,k;for(i = 0; i < filters; ++i){mean_delta[i] = 0;for (j = 0; j < batch; ++j) {for (k = 0; k < spatial; ++k) {int index = j*filters*spatial + i*spatial + k;mean_delta[i] += delta[index];}}mean_delta[i] *= (-1./sqrt(variance[i] + .00001f));} } void variance_delta_cpu(float *x, float *delta, float *mean, float *variance, int batch, int filters, int spatial, float *variance_delta) {int i,j,k;for(i = 0; i < filters; ++i){variance_delta[i] = 0;for(j = 0; j < batch; ++j){for(k = 0; k < spatial; ++k){int index = j*filters*spatial + i*spatial + k;variance_delta[i] += delta[index]*(x[index] - mean[i]);}}variance_delta[i] *= -.5 * pow(variance[i] + .00001f, (float)(-3./2.));} } void normalize_delta_cpu(float *x, float *mean, float *variance, float *mean_delta, float *variance_delta, int batch, int filters, int spatial, float *delta) {int f, j, k;for(j = 0; j < batch; ++j){for(f = 0; f < filters; ++f){for(k = 0; k < spatial; ++k){int index = j*filters*spatial + f*spatial + k;delta[index] = delta[index] * 1./(sqrt(variance[f] + .00001f)) + variance_delta[f] * 2. * (x[index] - mean[f]) / (spatial * batch) + mean_delta[f]/(spatial*batch);}}} }

5.殘差層（shortcut層）反向傳播源碼分析

殘差層比較簡單，不涉及參數梯度求解，只涉及梯度傳遞，方法很簡單，就是將關聯的兩個層的delta累加，只涉及加法求導，這里不再推導原理公式。源碼如下：

//backward_shortcut_layer再shortcut_layer.c中 void backward_shortcut_layer(const layer l, network net) {//求激活函數的梯度，l.output和梯度相乘得l.deltagradient_array(l.output, l.outputs*l.batch, l.activation, l.delta);axpy_cpu(l.outputs*l.batch, l.alpha, l.delta, 1, net.delta, 1);//l.delta傳遞給net.delta /* 對比前向傳播中的shortcut_cpu，是倒著將不同層的delta加一次，導數也是直接累加shortcut_cpu(l.batch, l.w, l.h, l.c, net.layers[l.index].output, l.out_w, l.out_h, l.out_c, l.alpha, l.beta, l.output);*/shortcut_cpu(l.batch, l.out_w, l.out_h, l.out_c, l.delta, l.w, l.h, l.c, 1, l.beta, net.layers[l.index].delta); }// shortcut_cpu在blas.c中 //參數： //int batch批次 //int w1, int h1, int c1, float *add:長寬高通道數，需要加的數據 //int w2, int h2, int c2：長寬高 //float s1, float s2, 加權項1，加權限2 //float *out:輸出 //assert的作用是先計算表達式 expression ，如果其值為假（即為0），那么它先向stderr打印一條出錯信息，然后通過調用 abort 來終止程序運行。 void shortcut_cpu(int batch, int w1, int h1, int c1, float *add, int w2, int h2, int c2, float s1, float s2, float *out) {int stride = w1/w2;int sample = w2/w1;assert(stride == h1/h2);//校驗用，如果長寬比不對，則退出程序assert(sample == h2/h1);if(stride < 1) stride = 1;//如果w1＜w2，則stride = 1，sample不變if(sample < 1) sample = 1;//如果w2＜w1，則sample = 1，stride不變int minw = (w1 < w2) ? w1 : w2;//如w1＜w2，則minw = w1int minh = (h1 < h2) ? h1 : h2;int minc = (c1 < c2) ? c1 : c2;//可見，shortcut相加的策略是按小的output進行int i,j,k,b;for(b = 0; b < batch; ++b){//一個batch內的圖片數bfor(k = 0; k < minc; ++k){//最小通道數for(j = 0; j < minh; ++j){//最小hfor(i = 0; i < minw; ++i){//最小w//輸出序號 = 按sample采樣的列數 + 第二個output寬度×(按sample采樣的行數+第二個output高度×(最小通道數+第二個output通道數×圖片序號))int out_index = i*sample + w2*(j*sample + h2*(k + c2*b));//累加序號 = 按stride采樣的列數 + 第二個output寬度×(按stride采樣的行數+第二個output高度×(最小通道數+第二個output通道數×圖片序號))//如果output1更大，output2抽樣，如果output1小，output1跨步int add_index = i*stride + w1*(j*stride + h1*(k + c1*b));//輸出序列為output2的尺寸，兩個層加權累加，系數默認為1out[out_index] = s1*out[out_index] + s2*add[add_index];}}}} }

6.路由層（route層）反向傳播源碼分析

不涉及參數梯度求導，只是把不同層的delta按照對應位置擺放到一層即可，源碼如下：

void backward_route_layer(const route_layer l, network net) {int i, j;int offset = 0;for(i = 0; i < l.n; ++i){int index = l.input_layers[i];float *delta = net.layers[index].delta;int input_size = l.input_sizes[i];for(j = 0; j < l.batch; ++j){//和forward類似，將delta按層位置擺放到相應的內存位置axpy_cpu(input_size, 1, l.delta + offset + j*l.outputs, 1, delta + j*input_size, 1);}offset += input_size;} }

7.激活函數相關源碼分析

YOLO對所有使用到的激活函數都有定義，定義在activation.h中，以內聯函數形式存在，前向和反向源碼如下，非常簡單：

/** 內聯函數可以加快調用的速度，但是調用多次的話，會使執行文件變大，這樣會降低速度。* static 修飾的內聯函數，一般情況下不會產生函數本身的代碼，而是全部嵌入在被調用的地方。* 如果不加 static，則表示該函數有可能被其他編譯單元所調用，所以一定會產生函數本身的代碼；** gcc的 static inline相對于static函數來說只是在調用時建議編譯器進行內聯展開；* gcc不會特意為 static inline 函數生成獨立的匯編碼，除非出現了必須生成不可的情況（如通過函數指針和遞歸調用）；* gcc 的static inline 函數僅能作用于文件范圍內。*/ static inline float stair_activate(float x) {int n = floor(x);if (n%2 == 0) return floor(x/2.);else return (x - n) + floor(x/2.); } static inline float hardtan_activate(float x) {if (x < -1) return -1;if (x > 1) return 1;return x; } static inline float linear_activate(float x){return x;} static inline float logistic_activate(float x){return 1./(1. + exp(-x));} static inline float loggy_activate(float x){return 2./(1. + exp(-x)) - 1;} static inline float relu_activate(float x){return x*(x>0);} static inline float elu_activate(float x){return (x >= 0)*x + (x < 0)*(exp(x)-1);} static inline float selu_activate(float x){return (x >= 0)*1.0507*x + (x < 0)*1.0507*1.6732*(exp(x)-1);} static inline float relie_activate(float x){return (x>0) ? x : .01*x;} static inline float ramp_activate(float x){return x*(x>0)+.1*x;} static inline float leaky_activate(float x){return (x>0) ? x : .1*x;} static inline float tanh_activate(float x){return (exp(2*x)-1)/(exp(2*x)+1);} static inline float plse_activate(float x) {if(x < -4) return .01 * (x + 4);if(x > 4) return .01 * (x - 4) + 1;return .125*x + .5; }static inline float lhtan_activate(float x) {if(x < 0) return .001*x;if(x > 1) return .001*(x-1) + 1;return x; } static inline float lhtan_gradient(float x) {if(x > 0 && x < 1) return 1;return .001; }static inline float hardtan_gradient(float x) {if (x > -1 && x < 1) return 1;return 0; } static inline float linear_gradient(float x){return 1;} static inline float logistic_gradient(float x){return (1-x)*x;} static inline float loggy_gradient(float x) {float y = (x+1.)/2.;return 2*(1-y)*y; } static inline float stair_gradient(float x) {if (floor(x) == x) return 0;return 1; } static inline float relu_gradient(float x){return (x>0);} static inline float elu_gradient(float x){return (x >= 0) + (x < 0)*(x + 1);} static inline float selu_gradient(float x){return (x >= 0)*1.0507 + (x < 0)*(x + 1.0507*1.6732);} static inline float relie_gradient(float x){return (x>0) ? 1 : .01;} static inline float ramp_gradient(float x){return (x>0)+.1;} static inline float leaky_gradient(float x){return (x>0) ? 1 : .1;} static inline float tanh_gradient(float x){return 1-x*x;} static inline float plse_gradient(float x){return (x < 0 || x > 1) ? .01 : .125;}

好了，以上就是YOLOv3涉及到的所有反向傳播的源碼分析和總結。如有描述不當，歡迎大家共同交流。

總結

以上是生活随笔為你收集整理的YOLOv3反向传播原理 之 全流程源码分析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。