深度学习笔记6：全连接层的实现

最新推荐文章于 2024-03-22 17:27:28 发布
最新推荐文章于 2024-03-22 17:27:28 发布
阅读量2.6k 收藏 6
点赞数 1
分类专栏： 深度学习

深度学习笔记6：全连接层的实现

标签： c语言神经网络深度学习cuda
2016-08-21 14:31 14420人阅读 评论(3) 收藏 举报
分类：
作者同类文章 X

    版权声明：本文为博主原创文章，未经博主允许不得转载。

    如果有什么疑问或者发现什么错误，欢迎在评论区留言，有时间我会一一回复。

    全连接层的推导

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

    全连接层的前向计算

    下图中连线最密集的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中，关于全连接层的配置信息如下：

    [cpp] view plain copy
    print ?
    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. }  
    layer {
  name: "ip1"
  type: "InnerProduct"
  bottom: "pool2"
  top: "ip1"
  param {
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}

    该层类型为InnerProduct内积，也就是我们常说的全连接层，前一层（底层）为pool2一个池化层，顶层，即该层的输出ip1，即为一个全连接层。关于学习率的参数lr_mult我们后面在权值更新章节再看。其他的参数我们在之前的卷积层都遇到过，含义和卷积层也一样，这里就不再多说。

     

    Caffe中全连接层相关的GPU文件有1个，为\src\caffe\layersi\nner_product_layer.cu 。

    前向计算

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

    [cpp] view plain copy
    print ?
    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. }  
    template <typename Dtype>
void InnerProductLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
    const vector<Blob<Dtype>*>& top) {
  const Dtype* bottom_data = bottom[0]->gpu_data();
  Dtype* top_data = top[0]->mutable_gpu_data();
  const Dtype* weight = this->blobs_[0]->gpu_data();
  //M_为batch_size
  if (M_ == 1) {
	  //top_data(M*N) = bottom_data(M*K) * weight(K*N)
	  //这里的计算实际调用了cublas中的矩阵计算函数，我们之前也有讲解，有兴趣可以深入看一下
    caffe_gpu_gemv<Dtype>(CblasNoTrans, N_, K_, (Dtype)1.,
                         weight, bottom_data, (Dtype)0., top_data);
	//若有偏置，加上偏置
    if (bias_term_)
      caffe_gpu_axpy<Dtype>(N_, bias_multiplier_.cpu_data()[0],
                            this->blobs_[1]->gpu_data(), top_data);
  } else {
	  //同上面
    caffe_gpu_gemm<Dtype>(CblasNoTrans,
                          transpose_ ? CblasNoTrans : CblasTrans,
                          M_, N_, K_, (Dtype)1.,
                          bottom_data, weight, (Dtype)0., top_data);
    if (bias_term_)
      caffe_gpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, M_, N_, 1, (Dtype)1.,
                            bias_multiplier_.gpu_data(),
                            this->blobs_[1]->gpu_data(), (Dtype)1., top_data);
  }
}

    反向传播

    代码及注释如下

    [cpp] view plain copy
    print ?
    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. }  
    template <typename Dtype>
void InnerProductLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down,
    const vector<Blob<Dtype>*>& bottom) {
  if (this->param_propagate_down_[0]) {
    const Dtype* top_diff = top[0]->gpu_diff();
    const Dtype* bottom_data = bottom[0]->gpu_data();
    // Gradient with respect to weight
	//对权重求导weight_diff = top_diff * bottom_data
    if (transpose_) {
      caffe_gpu_gemm<Dtype>(CblasTrans, CblasNoTrans,
          K_, N_, M_,
          (Dtype)1., bottom_data, top_diff,
          (Dtype)1., this->blobs_[0]->mutable_gpu_diff());
    } else {
      caffe_gpu_gemm<Dtype>(CblasTrans, CblasNoTrans,
          N_, K_, M_,
          (Dtype)1., top_diff, bottom_data,
          (Dtype)1., this->blobs_[0]->mutable_gpu_diff());
    }
  }
  if (bias_term_ && this->param_propagate_down_[1]) {
    const Dtype* top_diff = top[0]->gpu_diff();
    // Gradient with respect to bias
	//对偏置值b求导 bias_diff = bias * top_diff
	//这个和我之前公式推导出来的不一样，不知道为什么，如果有谁知道请留言告诉我，谢谢
    caffe_gpu_gemv<Dtype>(CblasTrans, M_, N_, (Dtype)1., top_diff,
        bias_multiplier_.gpu_data(), (Dtype)1.,
        this->blobs_[1]->mutable_gpu_diff());
  }
  if (propagate_down[0]) {
    const Dtype* top_diff = top[0]->gpu_diff();
    // Gradient with respect to bottom data
	//对上一层的输出求导bottom_diff = top_diff * weight
    if (transpose_) {
      caffe_gpu_gemm<Dtype>(CblasNoTrans, CblasTrans,
          M_, K_, N_,
          (Dtype)1., top_diff, this->blobs_[0]->gpu_data(),
          (Dtype)0., bottom[0]->mutable_gpu_diff());
    } else {
      caffe_gpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans,
          M_, K_, N_,
         (Dtype)1., top_diff, this->blobs_[0]->gpu_data(),
         (Dtype)0., bottom[0]->mutable_gpu_diff());
    }
  }
}



    顶
    5
    踩
    0
     
     
      相关文章推荐
    伊藤炫
    关注
    • 1
      点赞
    • 踩
    • 6
      收藏
      觉得还不错? 一键收藏
    • 0
      评论
    专栏目录
    matlab+卷积/池化/全连接/softmax
    03-09
    卷积神经网络中重要部分模块代码，可以从代码上理解各个模块的工作原理。从最简单的传送，等有空给大家传送实例。
    made-deep-learning:深度学习课程笔记本基础知识
    05-20
    深度学习基础（MADE S02E02） 该存储库包含深度学习基础课程的笔记本。 提示1： 加载整个存储库可能需要花费大量时间。 可以通过下载单个文件夹。 提示2： 有时GitHub无法渲染笔记本。 在这种情况下，请使用它就像一个魅力！ 提示3： 在nbviewer找不到笔记本而GitHub觉得很好的情况下，请尝试在nbviewer链接的末尾添加?flush_cache=false 。 讲课 传奇： -幻灯片， - 代码， - 视频。 星期 什么 在哪里 什么时候 深度学习简介：神经元，交叉熵，梯度下降，脾气暴躁，逻辑回归。 01/20/2021 全连接网络，反向传播方法，随机梯度下降，矩阵导数。 01/27/2021 3 深度学习的功能和优化方法，正则化方法，转移学习。 PyTorch基础。 02/03/2021 四 卷积和卷积神经网络。 PyTorch上
    全连接层概念
    最新发布
    qq_41327049的博客
    03-22 422
    全连接层中的每个神经元都与前一层中的所有神经元相连，因此得名“全连接”。首先，由于每个神经元都与前一层中的所有神经元相连，全连接层的参数数量通常很大，容易导致过拟合问题。在卷积神经网络（CNN）中，全连接层通常位于卷积层和池化层之后，用于接收这些层提取的特征，并基于这些特征进行最终的分类或回归任务。全连接层可以将卷积层或池化层产生的局部特征整合成全局特征，从而捕捉输入数据的整体信息。总的来说，全连接层在神经网络中扮演着重要的角色，能够整合和提取前一层网络的特征，并根据这些特征进行最终的分类或回归任务。
    深度学习PyTorch版学习笔记与心得（二）
    01-20
    多层感知机     1.多层感知机的基本知识       多层感知机（MLP）是研究神经网络的一个非常重要的多层模型。       下图展示了一个多层感知机的神经网络图，它含有一个隐藏层，该层中有5个隐藏单元。 表达公式：       具体来说，给定一个小批量样本X∈Rn×dX∈Rn×d，其批量大小为nn，输入个数为dd。假设多层感知机只有一个隐藏层，其中隐藏单元个数为hh。记隐藏层的输出（也称为隐藏层变量或隐藏变量）为HH，有H∈Rn×hH∈Rn×h。因为隐藏层和输出层均是全连接层，可以设隐藏层的权重参数和偏差参数分别为Wh∈Rd×hWh∈Rd×h和 bh∈R1×hbh∈R1×h，输出层的
    【学习笔记】动手学深度学习 Task02
    01-06
    (需要一定时间逐步补充以下内容，暂且用做打卡) 1. 模型选择、过拟合和欠拟合 训练误差和泛化误差 模型选择 验证数据集 K折交叉验证 过拟合和欠拟合 模型复杂度 权重衰减 L2 范数正则化 高维线性回归实验 2. 梯度消失、梯度爆炸 梯度消失 梯度爆炸 模型训练和预测 3. 卷积神经网络基础 二维卷积层 二维互相关运算 特征图与感受野 填充和步幅 多输入通道和多输出通道 卷积层与全连接层的对比 卷积、池化 4. 循环神经网络进阶 GRU LSTM 5. 机器翻译及相关技术 数据预处理 分词 建立词典 载入数据集 Encoder-Decoder -Sequence to Sequence模型
    【连载】深度学习笔记10：三维卷积、池化与全连接.pdf
    03-05
    。
    全连接神经网络百度百科,全连接神经网络的作用
    m0_54846070的博客
    09-04 960
    1、全连接神经网络解析：对n-1层和n层而言，n-1层的任意一个节点，都和第n层所有节点有连接。即第n层的每个节点在进行计算的时候，激活函数的输入是n-1层所有节点的加权。2、全连接的神经网络示意图：3、“全连接”是一种不错的模式，但是网络很大的时候，训练速度回很慢。部分连接就是认为的切断某两个节点直接的连接，这样训练时计算量大大减小。
    【深度学习】全连接层
    冷芝士鸭的学习笔记
    03-27 1万+
    4.5 全连接层 全连接层是一个列向量(单个样本)。通常用于深度神经网络的后面几层，用于图像分类任务。 全连接层，是每一个结点都与上一层的所有结点相连，用来把前边提取到的特征综合起来。由于其全相连的特性， 一般全连接层的参数也是最多的。 全连接层（fully connected layers，FC）在整个卷积神经网络中起到“分类器”的作用。如果说卷积层、池化层和激活函数等操作是将原始数据映射到隐层特征空间的话，全连接层则起到将学到的“分布式特征表示”。映射到样本标记空间的作用。 全连接层将特征提取得到的高
    深度学习——全连接层（Fully connected dence layers）原理解析
    热门推荐
    jmu201521121021的博客
    02-03 2万+
    深度学习——全连接层（Fully connected dence layers）原理解析 一、简介 全连接层有多个神经元，是一个列向量(单个样本)。在计算机视觉领域正常用于深度神经网络的后面几层，用于图像分类任务。 全连接层算法包括两部分：前向传播(Forward)和反向传播(Backward) 二、 算法解析 前向传播(Forward) 上图主要有5个变量，x,a,W,b,σx, a...
    神经网络全连接层详解
    17岁boy的博客
    09-26 6838
    全连接层即：每一个节点都与上一层的节点相连，每个节点都视为一个特征点，当产生一个输入源后会对全连接层做卷积操作，卷积核多大取决于你的全连接层每层数据表有多大，全连接层里每一层都是一组数据，这组数据里包含了每次训练的结果，通俗易懂的说就是当输入一个数据后，对全连接层进行循环遍历的操作，每次遍历时对每层进行卷积运动若每层中有相似数据则记录为1，然后遍历完所有层后将所有记录值集合成一个值输出。 下面用一个简单的例子来看： 我们想在一个方框中识别出是否有一张猫的图片，猫的位置不是固定的，可能在方框的右上角，也可
    【连载】深度学习笔记10：三维卷积、池化与全连接.docx
    03-05
    。
    Pytorch学习笔记11----搭建全连接层实现手写数字识别
    qq_39400324的博客
    03-28 1867
      本文将利用之前学到的 PyTorch 的相关知识，建立一个全连接神经网络模型，用于识别手写字符。通过这个小demo完成数据集的预处理、数据加载器的生成、优化器的定义、损失的定义、全连接神经网络的搭建、训练与测试等过程。 搭建全连接层实现手写数字识别一、import功能包二、处理train、test数据集三、查看几副图片四、model模型建立五、配置优化器六、开始训练七、查看精度 import torch device = torch.device('cuda' if torch.cuda.is_ava
    cuDNN 前向卷积网络搭建 VGG16
    yibayan的博客
    09-05 881
    文章目录cuDNNcuDNN Operations for VGG16环境配置参考资料 cuDNN cuDNN是英伟达提供的闭源库，对CUDA程序进行封装。cuDNN里面的前向传播和后向传播分别是独立的函数，不像利用python那样简单，只要搭建网络框架就好了。这里只介绍如何搭建前向传播模块，也就是载入我们用python程序训练好的参数进行预测。 代码入口 GitHub cuDNN Operati...
    手写数字识别----全连接网络（DNN）
    qq_44263007的博客
    05-04 2350
    手写数字识别 数据集和部分代码来自：https://aistudio.baidu.com/aistudio/projectDetail/101813 我们直接进入我们的实现部分; 我们先来本次任务的流程，大部分神经网络也是这个流程： 接下来我们直接进入数据的处理部分： #导入需要的包 import numpy as np import paddle as paddle import paddle...
    [pytorch学习笔记] 5. 使用pytorch搭建神经网络
    是安澜啊
    04-09 2110
    目录 介绍 设置训练硬件 定义类 模型层 全连接层（nn.Flatten ） nn.Linear(线性层) nn.ReLU nn.Sequential nn.Softmax Model Parameters 介绍 神经网络由对数据执行操作的层/模块组成。 torch.nn 命名空间提供了构建神经网络所需的所有模块。 PyTorch 中的每个模块都是 nn.Module 的子类。 神经网络本身是一个模块，它由其他模块（层）组成。 这种嵌套结构允许轻松构建和管理复杂的架构。 在接下
    全连接层详解
    m0_74890428的博客
    12-12 3743
    全连接层Fully Connected Layer一般位于整个神经网络的最后，负责将卷积输出的二维特征图（矩阵）转换成一维向量，由此实现了端到端的学习过程。
    深度学习之卷积神经网络
    姚蔚敏的博客
    11-26 3197
    一：卷积神经网络结构 左图：全连接神经网络（平面），组成：输入层、激活函数、全连接层 右图：卷积神经网络（立体），组成：输入层、卷积层、激活函数、池化层、全连接层 在卷积神经网络中有一个重要的概念：深度 卷积：在原始的输入上进行特征的提取。特征提取简言之就是，在原始输入上一个小区域一个小区域进行特征的提取，稍后细致讲解卷积的计算过程。 二：卷积神经网络组成 卷积神经网络组成: [INPU...
    深度学习和神经网络的介绍（一）
    无
    11-19 1971
    知道神经网络的概念；知道什么是神经元；知道什么是单层神经网络；知道什么是感知机；知道什么是多层神经网络；知道激活函数是什么、有什么作用理解神经网络的思想。
    鲁伟 深度学习笔记 pdf
    07-08
    《鲁伟深度学习笔记》是一本关于深度学习的资料，提供了对深度学习的深入理解和实践指导。这本笔记以简明扼要的方式介绍了深度学习的基本原理和常用算法，并结合实例讲解了如何使用深度学习解决实际问题。 首先，...

    “相关推荐”对你有帮助么？

    • 非常没帮助
    • 没帮助
    • 一般
    • 有帮助
    • 非常有帮助
    提交
    评论
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

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

    抵扣说明：

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

    余额充值