全連線層的推導

全連線層的每一個結點都與上一層的所有結點相連，用來把前邊提取到的特徵綜合起來。由於其全相連的特性，一般全連線層的引數也是最多的。

全連線層的前向計算

下圖中連線最密集的2個地方就是全連線層，這很明顯的可以看出全連線層的引數的確很多。在前向計算過程，也就是一個線性的加權求和的過程，全連線層的每一個輸出都可以看成前一層的每一個結點乘以一個權重係數W，最後加上一個偏置值b得到，即 。如下圖中第一個全連線層，輸入有50*4*4個神經元結點，輸出有500個結點，則一共需要50*4*4*500=400000個權值引數W和500個偏置引數b。

下面用一個簡單的網路具體介紹一下推導過程

其中，x1、x2、x3為全連線層的輸入，a1、a2、a3為輸出，根據我前邊在筆記1中的推導，有

可以寫成如下矩陣形式：

全連線層的反向傳播

以我們的第一個全連線層為例，該層有50*4*4=800個輸入結點和500個輸出結點。

由於需要對W和b進行更新，還要向前傳遞梯度，所以我們需要計算如下三個偏導數。

1、對上一層的輸出（即當前層的輸入）求導

若我們已知轉遞到該層的梯度，則我們可以通過鏈式法則求得loss對x的偏導數。

首先需要求得該層的輸出a_i對輸入x_j的偏導數

再通過鏈式法則求得loss對x的偏導數：

上邊求導的結果也印證了我前邊那句話：在反向傳播過程中，若第x層的a節點通過權值W對x+1層的b節點有貢獻，則在反向傳播過程中，梯度通過權值W從b節點傳播回a節點。

若我們的一次訓練16張圖片，即batch_size=16，則我們可以把計算轉化為如下矩陣形式。

2、對權重係數W求導

我們前向計算的公式如下圖，

由圖可知，所以：。

當batch_size=16時，寫成矩陣形式：

3、對偏置係數b求導

由上面前向推導公式可知

，

即loss對偏置係數的偏導數等於對上一層輸出的偏導數。

當batch_size=16時，將不同batch對應的相同b的偏導相加即可，寫成矩陣形式即為乘以一個全1的矩陣：

Caffe中全連線層的實現

在caffe中，關於全連線層的配置資訊如下：

1. layer {  
2.   name: "ip1"
3.   type: "InnerProduct"
4.   bottom: "pool2"
5.   top: "ip1"
6.   param {  
7.     lr_mult: 1  
8.   }  
9.   param {  
10.     lr_mult: 2  
11.   }  
12.   inner_product_param {  
13.     num_output: 500  
14.     weight_filler {  
15.       type: "xavier"
16.     }  
17.     bias_filler {  
18.       type: "constant"
19.     }  
20.   }  
21. }  

該層型別為InnerProduct內積，也就是我們常說的全連線層，前一層（底層）為pool2一個池化層，頂層，即該層的輸出ip1，即為一個全連線層。關於學習率的引數lr_mult我們後面在權值更新章節再看。其他的引數我們在之前的卷積層都遇到過，含義和卷積層也一樣，這裡就不再多說。

Caffe中全連線層相關的GPU檔案有1個，為\src\caffe\layersi\nner_product_layer.cu 。

前向計算

前向過程程式碼如下，具體解釋見註釋部分：

1. template <typename Dtype>  
2. void InnerProductLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,  
3.     const vector<Blob<Dtype>*>& top) {  
4.   const Dtype* bottom_data = bottom[0]->gpu_data();  
5.   Dtype* top_data = top[0]->mutable_gpu_data();  
6.   const Dtype* weight = this->blobs_[0]->gpu_data();  
7.   //M_為batch_size
8.   if (M_ == 1) {  
9.       //top_data(M*N) = bottom_data(M*K) * weight(K*N)
10.       //這裡的計算實際呼叫了cublas中的矩陣計算函式，我們之前也有講解，有興趣可以深入看一下
11.     caffe_gpu_gemv<Dtype>(CblasNoTrans, N_, K_, (Dtype)1.,  
12.                          weight, bottom_data, (Dtype)0., top_data);  
13.     //若有偏置，加上偏置
14.     if (bias_term_)  
15.       caffe_gpu_axpy<Dtype>(N_, bias_multiplier_.cpu_data()[0],  
16.                             this->blobs_[1]->gpu_data(), top_data);  
17.   } else {  
18.       //同上面
19.     caffe_gpu_gemm<Dtype>(CblasNoTrans,  
20.                           transpose_ ? CblasNoTrans : CblasTrans,  
21.                           M_, N_, K_, (Dtype)1.,  
22.                           bottom_data, weight, (Dtype)0., top_data);  
23.     if (bias_term_)  
24.       caffe_gpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, 1, (Dtype)1.,  
25.                             bias_multiplier_.gpu_data(),  
26.                             this->blobs_[1]->gpu_data(), (Dtype)1., top_data);  
27.   }  
28. }  

反向傳播

程式碼及註釋如下

1. template <typename Dtype>  
2. void InnerProductLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,  
3.     const vector<bool>& propagate_down,  
4.     const vector<Blob<Dtype>*>& bottom) {  
5.   if (this->param_propagate_down_[0]) {  
6.     const Dtype* top_diff = top[0]->gpu_diff();  
7.     const Dtype* bottom_data = bottom[0]->gpu_data();  
8.     // Gradient with respect to weight
9.     //對權重求導weight_diff = top_diff * bottom_data
10.     if (transpose_) {  
11.       caffe_gpu_gemm<Dtype>(CblasTrans, CblasNoTrans,  
12.           K_, N_, M_,  
13.           (Dtype)1., bottom_data, top_diff,  
14.           (Dtype)1., this->blobs_[0]->mutable_gpu_diff());  
15.     } else {  
16.       caffe_gpu_gemm<Dtype>(CblasTrans, CblasNoTrans,  
17.           N_, K_, M_,  
18.           (Dtype)1., top_diff, bottom_data,  
19.           (Dtype)1., this->blobs_[0]->mutable_gpu_diff());  
20.     }  
21.   }  
22.   if (bias_term_ && this->param_propagate_down_[1]) {  
23.     const Dtype* top_diff = top[0]->gpu_diff();  
24.     // Gradient with respect to bias
25.     //對偏置值b求導 bias_diff = bias * top_diff
26.     //這個和我之前公式推匯出來的不一樣，不知道為什麼，如果有誰知道請留言告訴我，謝謝
27.     caffe_gpu_gemv<Dtype>(CblasTrans, M_, N_, (Dtype)1., top_diff,  
28.         bias_multiplier_.gpu_data(), (Dtype)1.,  
29.         this->blobs_[1]->mutable_gpu_diff());  
30.   }  
31.   if (propagate_down[0]) {  
32.     const Dtype* top_diff = top[0]->gpu_diff();  
33.     // Gradient with respect to bottom data
34.     //對上一層的輸出求導bottom_diff = top_diff * weight
35.     if (transpose_) {  
36.       caffe_gpu_gemm<Dtype>(CblasNoTrans, CblasTrans,  
37.           M_, K_, N_,  
38.           (Dtype)1., top_diff, this->blobs_[0]->gpu_data(),  
39.           (Dtype)0., bottom[0]->mutable_gpu_diff());  
40.     } else {  
41.       caffe_gpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans,  
42.           M_, K_, N_,  
43.          (Dtype)1., top_diff, this->blobs_[0]->gpu_data(),  
44.          (Dtype)0., bottom[0]->mutable_gpu_diff());  
45.     }  
46.   }  
47. }