Caffe框架源码剖析(7)—全连接层InnerProductLayer

最新推荐文章于 2021-11-30 12:45:11 发布
最新推荐文章于 2021-11-30 12:45:11 发布
阅读量714 收藏 1
点赞数 1
分类专栏： deep learning 文章标签： deep learning caffe
本文深入解析全连接层(InnerProductLayer)的工作原理及其在CPU和GPU上的实现方式。介绍了全连接层的矩阵乘法运算过程，并详细阐述了其在深度学习框架中的具体实现细节。
全连接层InnerProductLayer的原理很简单，说白了就是矩阵乘法运算。正向传导时输出数据等于输入数据乘上权重，如果有偏置项就再加上偏置项。写成公式就是：


    矩阵乘法在CPU端采用OpenBLAS实现，在GPU端则采用NVIDIA cuBLAS实现加速。

    inner_product_layer.hpp定义如下，

[cpp] view plain copy
  1. template <typename Dtype>  
  2. class InnerProductLayer : public Layer<Dtype> {  
  3.  public:  
  4.   explicit InnerProductLayer(const LayerParameter& param)  
  5.       : Layer<Dtype>(param) {}  
  6.   virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,  
  7.       const vector<Blob<Dtype>*>& top);  
  8.   virtual void Reshape(const vector<Blob<Dtype>*>& bottom,  
  9.       const vector<Blob<Dtype>*>& top);  
  10.   
  11.   virtual inline const char* type() const { return "InnerProduct"; }  
  12.   virtual inline int ExactNumBottomBlobs() const { return 1; }  
  13.   virtual inline int ExactNumTopBlobs() const { return 1; }  
  14.   
  15.  protected:  
  16.   virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,  
  17.       const vector<Blob<Dtype>*>& top);  
  18.   virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,  
  19.       const vector<Blob<Dtype>*>& top);  
  20.   virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,  
  21.       const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);  
  22.   virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,  
  23.       const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);  
  24.   
  25.   // 矩阵乘法参数(M, K) * (K, N) = (M, N)  
  26.   int M_;  // 输入数据的数量, 即patch_size  
  27.   int K_;  // 单个输入数据包含的元素个数  
  28.   int N_;  // 输出层的神经元个数  
  29.   // 是否包含偏置项  
  30.   bool bias_term_;  
  31.   // 偏置项乘子  
  32.   Blob<Dtype> bias_multiplier_;  
  33.   // 是否转置  
  34.   bool transpose_;  ///< if true, assume transposed weights  
  35. };  

inner_product_layer.cpp定义如下，

[cpp] view plain copy
  1. template <typename Dtype>  
  2. void InnerProductLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,  
  3.       const vector<Blob<Dtype>*>& top) {  
  4.   const int num_output = this->layer_param_.inner_product_param().num_output();  
  5.   bias_term_ = this->layer_param_.inner_product_param().bias_term();  
  6.   transpose_ = this->layer_param_.inner_product_param().transpose();  
  7.   N_ = num_output;  
  8.   const int axis = bottom[0]->CanonicalAxisIndex(  
  9.       this->layer_param_.inner_product_param().axis());  
  10.   // 如果输入图像的维度是(N, C, H, W)，则K_ = C * H * W  
  11.   K_ = bottom[0]->count(axis);  
  12.   // 确认是否需要初始化权重  
  13.   if (this->blobs_.size() > 0) {  
  14.     LOG(INFO) << "Skipping parameter initialization";  
  15.   } else {  
  16.     if (bias_term_) {  
  17.       // 如果包含偏置项，则将blobs_的size设为2  
  18.       this->blobs_.resize(2);  
  19.     } else {  
  20.       this->blobs_.resize(1);  
  21.     }  
  22.     // 设置权重的维度  
  23.     vector<int> weight_shape(2);  
  24.     if (transpose_) {  
  25.       weight_shape[0] = K_;  
  26.       weight_shape[1] = N_;  
  27.     } else {  
  28.       weight_shape[0] = N_;  
  29.       weight_shape[1] = K_;  
  30.     }  
  31.     this->blobs_[0].reset(new Blob<Dtype>(weight_shape));  
  32.     // 初始化权重（使用xavier初始化方法）  
  33.     shared_ptr<Filler<Dtype> > weight_filler(GetFiller<Dtype>(  
  34.         this->layer_param_.inner_product_param().weight_filler()));  
  35.     weight_filler->Fill(this->blobs_[0].get());  
  36.     // 如果包含偏置项，则将偏置项初始化为0  
  37.     if (bias_term_) {  
  38.       vector<int> bias_shape(1, N_);  
  39.       this->blobs_[1].reset(new Blob<Dtype>(bias_shape));  
  40.       shared_ptr<Filler<Dtype> > bias_filler(GetFiller<Dtype>(  
  41.           this->layer_param_.inner_product_param().bias_filler()));  
  42.       bias_filler->Fill(this->blobs_[1].get());  
  43.     }  
  44.   }  // parameter initialization  
  45.   this->param_propagate_down_.resize(this->blobs_.size(), true);  
  46. }  
  47.   
  48. template <typename Dtype>  
  49. void InnerProductLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,  
  50.       const vector<Blob<Dtype>*>& top) {  
  51.   // 确认维度  
  52.   const int axis = bottom[0]->CanonicalAxisIndex(  
  53.       this->layer_param_.inner_product_param().axis());  
  54.   const int new_K = bottom[0]->count(axis);  
  55.   CHECK_EQ(K_, new_K)  
  56.       << "Input size incompatible with inner product parameters.";  
  57.   // M_等于patch_size  
  58.   M_ = bottom[0]->count(0, axis);  
  59.   // 将输出项top[0]的维度置为(patch_size, N_)  
  60.   vector<int> top_shape = bottom[0]->shape();  
  61.   top_shape.resize(axis + 1);  
  62.   top_shape[axis] = N_;  
  63.   top[0]->Reshape(top_shape);  
  64.   // 设置偏置项乘子  
  65.   if (bias_term_) {  
  66.     vector<int> bias_shape(1, M_);  
  67.     bias_multiplier_.Reshape(bias_shape);  
  68.     // 将偏置项乘子bias_multiplier_初始化为1  
  69.     caffe_set(M_, Dtype(1), bias_multiplier_.mutable_cpu_data());  
  70.   }  
  71. }  
  72.   
  73. // CPU正向传导  
  74. template <typename Dtype>  
  75. void InnerProductLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,  
  76.     const vector<Blob<Dtype>*>& top) {  
  77.   const Dtype* bottom_data = bottom[0]->cpu_data();  
  78.   Dtype* top_data = top[0]->mutable_cpu_data();  
  79.   const Dtype* weight = this->blobs_[0]->cpu_data();  
  80.   // bottom_data为M*K矩阵，权重为K*N矩阵，top_data为M*N矩阵  
  81.   // top_data = bottom_data * weight  
  82.   caffe_cpu_gemm<Dtype>(CblasNoTrans, transpose_ ? CblasNoTrans : CblasTrans,  
  83.       M_, N_, K_, (Dtype)1.,  
  84.       bottom_data, weight, (Dtype)0., top_data);  
  85.   // 如果包含有偏置项  
  86.   if (bias_term_) {  
  87.     // top_data += bias_multiplier * bias  
  88.     caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, 1, (Dtype)1.,  
  89.         bias_multiplier_.cpu_data(),  
  90.         this->blobs_[1]->cpu_data(), (Dtype)1., top_data);  
  91.   }  
  92.   // 因此两步合并的结果就是 top_data = bottom_data * weight + bias_multiplier * bias  
  93. }  
  94.   
  95. // CPU反向传导  
  96. template <typename Dtype>  
  97. void InnerProductLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,  
  98.     const vector<bool>& propagate_down,  
  99.     const vector<Blob<Dtype>*>& bottom) {  
  100.   if (this->param_propagate_down_[0]) {  
  101.     const Dtype* top_diff = top[0]->cpu_diff();  
  102.     const Dtype* bottom_data = bottom[0]->cpu_data();  
  103.     // 求权重的偏导，weight_diff += top_diff * bottom_data  
  104.     if (transpose_) {  
  105.       caffe_cpu_gemm<Dtype>(CblasTrans, CblasNoTrans,  
  106.           K_, N_, M_,  
  107.           (Dtype)1., bottom_data, top_diff,  
  108.           (Dtype)1., this->blobs_[0]->mutable_cpu_diff());  
  109.     } else {  
  110.       caffe_cpu_gemm<Dtype>(CblasTrans, CblasNoTrans,  
  111.           N_, K_, M_,  
  112.           (Dtype)1., top_diff, bottom_data,  
  113.           (Dtype)1., this->blobs_[0]->mutable_cpu_diff());  
  114.     }  
  115.   }  
  116.   // 求偏置项的偏导，bias_diff += top_diff * bias_multiplier  
  117.   if (bias_term_ && this->param_propagate_down_[1]) {  
  118.     const Dtype* top_diff = top[0]->cpu_diff();  
  119.     // Gradient with respect to bias  
  120.     caffe_cpu_gemv<Dtype>(CblasTrans, M_, N_, (Dtype)1., top_diff,  
  121.         bias_multiplier_.cpu_data(), (Dtype)1.,  
  122.         this->blobs_[1]->mutable_cpu_diff());  
  123.   }  
  124.   if (propagate_down[0]) {  
  125.     const Dtype* top_diff = top[0]->cpu_diff();  
  126.     // 求bottom数据的偏导，bottom_data_diff = top_diff * weight  
  127.     if (transpose_) {  
  128.       caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasTrans,  
  129.           M_, K_, N_,  
  130.           (Dtype)1., top_diff, this->blobs_[0]->cpu_data(),  
  131.           (Dtype)0., bottom[0]->mutable_cpu_diff());  
  132.     } else {  
  133.       caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans,  
  134.           M_, K_, N_,  
  135.           (Dtype)1., top_diff, this->blobs_[0]->cpu_data(),  
  136.           (Dtype)0., bottom[0]->mutable_cpu_diff());  
  137.     }  
  138.   }  
  139. }  
  140.   
  141. // 如果CPU_ONLY模式则禁止Forward_gpu和Backward_gpu函数  
  142. #ifdef CPU_ONLY  
  143. STUB_GPU(InnerProductLayer);  
  144. #endif 
Caffe源码 - inner_product_layer 全连接层
长风破浪会有时，直挂云帆济沧海
01-12 2199
Caffe - 全连接层 inner_product_layer 图像分类中，网络结构的最后一般有一个或多个全连接层. 全连接层的每个节点都与其上层的所有节点相连，以综合前面网络层提取的特征. 其全连接性，导致参数较多. 全连接层将卷积的 2D 特征图结果转化为 1D 向量. 如 MNIST： 最后两层为全连接层，在pooling 层后，转化为 1D 的 1*100 长度的向量. ...
caffe源码理解之inner_product_layer
热门推荐
鱼蛋蛋哥
03-29 1万+
介绍inner_product_layer也即全连接层，如下示意图，每个输出都连接到所有的输入。 正文成员变量首先介绍一下几个成员变量protected: int M_;//样本数量 int K_;//单个输入特征长度 int N_;//输出神经元数量 bool bias_term_;//是否添加偏置，上图中的（+1）。 Blob<Dtype> bias_multiplier
caffe InnerProductLayer
无左无右的博客
03-13 688
inner_product_layer也即全连接层，如下示意图，每个输出都连接到所有的输入。 网络: layer { name: &amp;amp;amp;amp;amp;amp;amp;amp;amp;quot;ip1&amp;amp;amp;amp;amp;amp;amp;amp;amp;quot; type: &amp;amp;amp;amp;amp;amp;amp;amp;amp;quot;InnerProduct&amp;amp;amp;amp;
caffe——全连接层inner_product_layer
06-12 376
　　在caffe中，全连接层叫做"inner_product_layer"，区别于tensorflow中的fullyconnected_layer。 　 1、prototxt中的定义 layer { bottom: "fc7" top: "fc8" name: "fc8" type: "InnerProduct" param { # 权重学习参数 ...
Caffe源码:inner_product_layer.cpp
zzqiuzz的博客
12-06 612
@brief: Caffe全连接层ip2–>ip1反向传播（不包含ReluLayer） 以LeNet全连接层反向传播为例，ip2–>ip1，如图示，输入神经元个数500，输出神经元个数10，batchsize为64，则要更新的权重矩阵为500x10。 对每一个输出神经元 yi=∑djwji∗xj+biasmultiplier∗bi,∴∂yi∂wji=xj y_i=\sum _j^dw_{ji}
caffe框架源码
11-22
国外资源更新过慢 直接从github上下载 caffe源码 其中含有caffe示例demo
深度学习实战：Caffe框架源码剖析
通过源码分析，读者能够掌握如何根据需要修改和扩展Caffe框架，以适应特定的深度学习任务。 ### 知识点五：Caffe框架的应用实例 书中可能会通过多个实战案例来展示如何利用Caffe框架解决实际问题。这些案例可能...
基于C++深度学习的快速开源框架Caffe设计源码
最新发布
10-04
Caffe广泛应用于图像识别、语音识别、文本分析等领域，它的易用性和模块化设计使得研究人员可以专注于深度学习模型的设计，而不必担心底层的实现细节。 Caffe之所以能够在深度学习领域占据一席之地，离不开其在编程...
【笔记】Caffe全连接层源码（inner product layer）：区别于tensorflow中的fullyconnected_layer
nyist_yangguang的博客
11-30 546
caffe的官方文档，介绍如下： 那么，它究竟做了什么那？ 假设conv2的输入是256*27*27,那么conv2的输出即50*22*22，conv2的输入即pool2的输入，pool2的输出为50*11*11，即ip1的输入,ip1的输出为500*1*1，那么pool2->ip1的参数个数是多少呢？这里就要理解好什么是fully_connected了，即wTx，x为列向量，w的长度与x相同。在本文的例子中x的维度为50*11*11，那么pool2->ip1的参数个...
花书+吴恩达深度学习（十二）卷积神经网络 CNN 之全连接层
今天你学习了吗
12-19 1850
目录 0. 前言 1. 全连接层（fully connected layer） 如果这篇文章对你有一点小小的帮助，请给个关注，点个赞喔~我会非常开心的~ 花书+吴恩达深度学习（十）卷积神经网络 CNN 之卷积层 花书+吴恩达深度学习（十一）卷积神经网络 CNN 之池化层 花书+吴恩达深度学习（十二）卷积神经网络 CNN 之全连接层 花书+吴恩达深度学习（十三）卷积神经网络 CNN ...
概念：Inner_Product（IP）层
wonengguwozai的博客
11-11 1369
在caffe中所谓的Inner_Product（IP) 层即fully_connected (fc)layer
CAFFE源码学习笔记之内积层-inner_product_layer
sinat_22336563的博客
04-11 4466
一、前言 内积层实际就是全连接。经过之前的卷积层、池化层和非线性变换层，样本已经被映射到隐藏层的特征空间之中，而全连接层就是将学习到的特征又映射到样本分类空间。虽然已经出现了全局池化可以替代全连接，但是仍然不能说全连接就不能用了。 二、源码分析 1、成员变量全连接的输入时一个M*K的矩阵，权重是K*N的矩阵，所以输出是一个M*N的矩阵 int M_;//num_input int K_;
海思平台浮点计算加速之OpenBlas使用记录
haohaohaihuai的博客
03-17 1365
OpenBlas单精度点积-cblas_sdot 一、交叉编译 由于要在海思平台处理大量浮点数据，测试过程中，发现使用cpu计算，速度跟不上，遂思考需求加速的办法，开始考虑移植caffe到海思平台使用cuda加速，但是移植过程比较麻烦，放弃了。最后决定单独编译使用OpenBlas来加速计算，这个库是我们国内牛人张博士大神写的开源库现已被广泛应用。废话不多说，老规矩先上源码链接：https://gi...
学习笔记: 源码 inner_product_layer.cpp 略识
smallplum123的博客
05-15 881
InnerProductLayer 也是主要为三部分：初始化，前向传播，后向传播。 1. LayerSetUp() template void InnerProductLayer::LayerSetUp(const vector*>& bottom, const vector*>& top) { const int num_output = this->layer_p
全连接层（FullConnect Layer）
AI.PLAY
12-28 1558
全连接层： 在讨论卷积神经网络时，若直接在输入层采用全连接的方式，会导致权值过多而无法训练，但是全连接层并非无用武之地，在卷积神经网络特征提取完成后，这时的特征维度相对于原始的图片输入已经大大减小，这时可以采用全连接层来最大限度利用每一个特征。 全连接层的每一个节点都与上一层的所有节点相连，用来把前边提取到的特征综合起来。 I为输入，O为输出。 前向的传导过程为：
caffe源码解析-inner_product_layer
小羊哈利
09-11 3178
打开inner_product_layer.hpp文件，发现全连接层是非常清晰简单的，我们主要关注如下四个函数就行。 LayerSetUp（SetUp的作用一般用于初始化，比如网络结构参数的获取） Reshape Forward_cpu Backward_cpu **inner_product_layer.hpp**namespace caffe { template <typename Dtype
关于caffe innerproduct层的理解
u010935076的博客
05-16 6173
假设innerproduct（以下称IP层）层的层参数output_num为n, IP层输入blob尺寸为m*c*w*h  ,那么输出尺寸为m*n   ,即m*n*1*1,不难看出IP层把输入blob的m个二维矩阵（图片）通过与权重矩阵的卷积运算，最终转化为了一个m*n的二维矩阵，很显然，这个二维矩阵感知了输入的m张图片的综合特征，这也是IP层被称为多层感知的原因吧！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值