全连接层的推导

全连接层的每一个结点都与上一层的所有结点相连，用来把前边提取到的特征综合起来。由于其全相连的特性，一般全连接层的参数也是最多的。

全连接层的前向计算

下图中连线最密集的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的偏导数。
首先需要求得该层的输出ai对输入xj的偏导数

再通过链式法则求得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中，关于全连接层的配置信息如下：

[cpp] 

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 。

前向计算

前向过程代码如下，具体解释见注释部分：

[cpp]

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. }  

反向传播

代码及注释如下

[cpp]

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. }