【caffe】caffe之BatchNorm层

最新推荐文章于 2021-06-23 15:38:48 发布
最新推荐文章于 2021-06-23 15:38:48 发布
阅读量748 收藏
点赞数 2
分类专栏： CAFFE 文章标签： 深度学习 caffe batchnorm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q295684174/article/details/79148185
版权

在用BatchNorm层的时候有use_global_stats和moving_average_fraction不知道什么时候用，特别是在fine-tune的时候，因此把BatchNorm层的代码给解读一下。

————————————————————–caffe.proto——————————————————————–

首先来看BatchNorm有哪些参数。

message BatchNormParameter {
  // If false, accumulate global mean/variance values via a moving average. If
  // true, use those accumulated values instead of computing mean/variance
  // across the batch.
  optional bool use_global_stats = 1;
  // How much does the moving average decay each iteration?
  optional float moving_average_fraction = 2 [default = .999];
  // Small value to add to the variance estimate so that we don't divide by
  // zero.
  optional float eps = 3 [default = 1e-5];
}
  1. use_global_stats ：如果设置为true的话，就用累加的均值和方差而不重新计算；如果为false的话，则用moving average来计算均值与方差。
  2. moving_average_fraction：计算均值和方差时的比例，也就是动量。
  • note：在训练的时候要将use_global_stats 设为false，测试的时候默认为true。

——————————————————-BatchNormLayer::LayerSetUp—————————————————

template <typename Dtype>
void BatchNormLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  //获取这一层的参数
  BatchNormParameter param = this->layer_param_.batch_norm_param();
  //获取moving_average_fraction
  moving_average_fraction_ = param.moving_average_fraction();
  //如果为测试，use_global_stats_ 为true，因此训练时为false
  use_global_stats_ = this->phase_ == TEST;
  if (param.has_use_global_stats())
    use_global_stats_ = param.use_global_stats();
  if (bottom[0]->num_axes() == 1)
    channels_ = 1;
  else
    channels_ = bottom[0]->shape(1);//默认在channel上归一化
  eps_ = param.eps();
  //初始化参数
  if (this->blobs_.size() > 0) {
    LOG(INFO) << "Skipping parameter initialization";
  } else {
    this->blobs_.resize(3);
    vector<int> sz;
    sz.push_back(channels_);
    //均值
    this->blobs_[0].reset(new Blob<Dtype>(sz));
    //方差
    this->blobs_[1].reset(new Blob<Dtype>(sz));
    sz[0] = 1;
    //moving_average_fraction
    this->blobs_[2].reset(new Blob<Dtype>(sz));
    //初始化为0
    for (int i = 0; i < 3; ++i) {
      caffe_set(this->blobs_[i]->count(), Dtype(0),
                this->blobs_[i]->mutable_cpu_data());
    }
  }
  // Mask statistics from optimization by setting local learning rates
  // for mean, variance, and the bias correction to zero.
  //将学习率设为0，因为本层只是归一化操作，不需要更新参数
  for (int i = 0; i < this->blobs_.size(); ++i) {
    if (this->layer_param_.param_size() == i) {
      ParamSpec* fixed_param_spec = this->layer_param_.add_param();
      fixed_param_spec->set_lr_mult(0.f);
    } else {
      CHECK_EQ(this->layer_param_.param(i).lr_mult(), 0.f)
          << "Cannot configure batch normalization statistics as layer "
          << "parameters.";
    }
  }
}

——————————————————–BatchNormLayer::Reshape——————————————————

template <typename Dtype>
void BatchNormLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  if (bottom[0]->num_axes() >= 1)
    CHECK_EQ(bottom[0]->shape(1), channels_);
  //输出与输入大小一致
  top[0]->ReshapeLike(*bottom[0]);

  vector<int> sz;
  sz.push_back(channels_);
  //当前batch的均值与方差blob与channel个数一致
  mean_.Reshape(sz);
  variance_.Reshape(sz);
  //一些中间变量
  temp_.ReshapeLike(*bottom[0]);
  x_norm_.ReshapeLike(*bottom[0]);
  sz[0] = bottom[0]->shape(0);
  batch_sum_multiplier_.Reshape(sz);

  int spatial_dim = bottom[0]->count()/(channels_*bottom[0]->shape(0));
  if (spatial_sum_multiplier_.num_axes() == 0 ||
      spatial_sum_multiplier_.shape(0) != spatial_dim) {
    sz[0] = spatial_dim;
    spatial_sum_multiplier_.Reshape(sz);
    Dtype* multiplier_data = spatial_sum_multiplier_.mutable_cpu_data();
    caffe_set(spatial_sum_multiplier_.count(), Dtype(1), multiplier_data);
  }

  int numbychans = channels_*bottom[0]->shape(0);
  if (num_by_chans_.num_axes() == 0 ||
      num_by_chans_.shape(0) != numbychans) {
    sz[0] = numbychans;
    num_by_chans_.Reshape(sz);
    caffe_set(batch_sum_multiplier_.count(), Dtype(1),
        batch_sum_multiplier_.mutable_cpu_data());
  }
}

——————————————————BatchNormLayer::Forward_cpu—————————————————

template <typename Dtype>
void BatchNormLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
    const vector<Blob<Dtype>*>& top) {
  const Dtype* bottom_data = bottom[0]->cpu_data();
  Dtype* top_data = top[0]->mutable_cpu_data();
  //batchsize
  int num = bottom[0]->shape(0);
  //HxW
  int spatial_dim = bottom[0]->count()/(bottom[0]->shape(0)*channels_);

  //先将输入拷贝到输出
  if (bottom[0] != top[0]) {
    caffe_copy(bottom[0]->count(), bottom_data, top_data);
  }

  //如果训练时use_global_stats_ = true，则不计算当前batch的均值和方差，用全局均值和方差代替（fine-tune）
  if (use_global_stats_) {
    // use the stored mean/variance estimates.
    //首先计算scale = 1 / moving_average_fraction
    const Dtype scale_factor = this->blobs_[2]->cpu_data()[0] == 0 ?
        0 : 1 / this->blobs_[2]->cpu_data()[0];
    //均值除以scale
    caffe_cpu_scale(variance_.count(), scale_factor,
        this->blobs_[0]->cpu_data(), mean_.mutable_cpu_data());
    //方差除以scale
    caffe_cpu_scale(variance_.count(), scale_factor,
        this->blobs_[1]->cpu_data(), variance_.mutable_cpu_data());
  } 
  //否则计算当前batch的均值和方差
  else {
    // compute mean
    //先将HxW的feature map累加起来
    caffe_cpu_gemv<Dtype>(CblasNoTrans, channels_ * num, spatial_dim,
        1. / (num * spatial_dim), bottom_data,
        spatial_sum_multiplier_.cpu_data(), 0.,
        num_by_chans_.mutable_cpu_data());
    //再将一个batch中按照channel维累加起来（计算的是channel上的均值）
    caffe_cpu_gemv<Dtype>(CblasTrans, num, channels_, 1.,
        num_by_chans_.cpu_data(), batch_sum_multiplier_.cpu_data(), 0.,
        mean_.mutable_cpu_data());
  }

  // subtract mean
  //将channel上的均值展开程numxchannel维
  caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1,
      batch_sum_multiplier_.cpu_data(), mean_.cpu_data(), 0.,
      num_by_chans_.mutable_cpu_data());
  //再展开程numxchannelxHxW维, 并减去均值
  caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, channels_ * num,
      spatial_dim, 1, -1, num_by_chans_.cpu_data(),
      spatial_sum_multiplier_.cpu_data(), 1., top_data);

  //如果训练时use_global_stats_ = true，则不计算当前batch的均值和方差，用全局均值和方差代替（fine-tune
  if (!use_global_stats_) {
    // compute variance using var(X) = E((X-EX)^2)
    //计算方差，先平方，在计算均值
    caffe_powx(top[0]->count(), top_data, Dtype(2),
        temp_.mutable_cpu_data());  // (X-EX)^2
    //上面同样的方法计算平方的均值
    caffe_cpu_gemv<Dtype>(CblasNoTrans, channels_ * num, spatial_dim,
        1. / (num * spatial_dim), temp_.cpu_data(),
        spatial_sum_multiplier_.cpu_data(), 0.,
        num_by_chans_.mutable_cpu_data());
    caffe_cpu_gemv<Dtype>(CblasTrans, num, channels_, 1.,
        num_by_chans_.cpu_data(), batch_sum_multiplier_.cpu_data(), 0.,
        variance_.mutable_cpu_data());  // E((X_EX)^2)

    // compute and save moving average
    //计算moving_average_fraction，累加动量
    this->blobs_[2]->mutable_cpu_data()[0] *= moving_average_fraction_;
    this->blobs_[2]->mutable_cpu_data()[0] += 1;
    //将当前batch的均值按照动量存入blob
    caffe_cpu_axpby(mean_.count(), Dtype(1), mean_.cpu_data(),
        moving_average_fraction_, this->blobs_[0]->mutable_cpu_data());
    //将当前batch的方差按照动量存入blob
    int m = bottom[0]->count()/channels_;
    Dtype bias_correction_factor = m > 1 ? Dtype(m)/(m-1) : 1;
    caffe_cpu_axpby(variance_.count(), bias_correction_factor,
        variance_.cpu_data(), moving_average_fraction_,
        this->blobs_[1]->mutable_cpu_data());
  }

  //计算均方差
  // normalize variance
  caffe_add_scalar(variance_.count(), eps_, variance_.mutable_cpu_data());
  caffe_powx(variance_.count(), variance_.cpu_data(), Dtype(0.5),
             variance_.mutable_cpu_data());

  //按照上面同样的方法将方差展开成numxchannelxHxW维
  // replicate variance to input size
  caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, num, channels_, 1, 1,
      batch_sum_multiplier_.cpu_data(), variance_.cpu_data(), 0.,
      num_by_chans_.mutable_cpu_data());
  //temp中保存均方差
  caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, channels_ * num,
      spatial_dim, 1, 1., num_by_chans_.cpu_data(),
      spatial_sum_multiplier_.cpu_data(), 0., temp_.mutable_cpu_data());
  //减去均值后的结果除以均方差
  caffe_div(temp_.count(), top_data, temp_.cpu_data(), top_data);
  // TODO(cdoersch): The caching is only needed because later in-place layers
  //                 might clobber the data.  Can we skip this if they won't?
  //拷贝一份反向使用
  caffe_copy(x_norm_.count(), top_data,
      x_norm_.mutable_cpu_data());
}

—————————————————BatchNormLayer::Backward_cpu—————————————————–

反向推导公式请参考：https://www.cnblogs.com/LaplaceAkuir/p/7811351.html

q295684174
关注
专栏目录
caffe常用层：batchNorm使用
BigCowPeking
12-24 6896
caffe常用层：batchNorm使用
Caffe 源码 - BatchNorm 层与 Scale 层
长风破浪会有时，直挂云帆济沧海
12-19 1万+
batch norm layer &amp; scale layer 简述 Batch Normalization 论文给出的计算： 前向计算： 后向计算： BatchNorm 主要做了两部分： [1] 对输入进行归一化，xnorm=x−μσxnorm=x−μσx_{norm} = \frac{x - \mu}{\sigma}，其中， μμ\mu 和 σσ\sigma 是...
caffe加速:合并BatchNorm层和Scale层到Convolution层
09-10
Convolution+BatchNorm+Scale+Relu的组合模块在卷积后进行归一化，可以加速训练收敛。但在推理时BatchNorm非常耗时，可以将训练时学习到的BatchNorm+Scale的线性变换参数融合到卷积层，替换原来的Convolution层中weights和bias，实现在不影响准确度的前提下加速预测时间。
caffe中的batchNorm层
BigCowPeking
11-05 553
caffe中的batchNorm层
caffe batchnorm
m0_37400316的博客
12-10 359
tensorflow 和pytorch中的batchnorm通常有4个参数构成，其中包括均值、方差、系数乘、系数加。这些框架封装的比较好，在使用时一般不宜出错，但是对于caffe则需要注意，将batchnorm分解长batchnorm和scale进行处理。但需要注意的是系数配置。细节如下： Caffe BN： 在使用BatchNorm时，Batch层共3个参数，1个存储均值向量，一个存储方差向量，第三个存储缩放的值。最终的均值向量=均值向量/缩放；最终的方差向量=方差向量/缩放。 Scale层共2个参数，一
caffe-batch norm层理解
zhanghenan123的博客
07-25 654
1、成员变量 Blob&lt;Dtype&gt; mean_,variance_,temp_,x_norm; //temp_保存(x-mean_x)^2 bool use_global_stats_;//标注训练与测试阶段 Dtype moving_average_fraction_; int channels_; Dtype eps_; // 防止分母为0 // 中...
caffe中BatchNorm层和Scale层实现批量归一化（batch-normalization）注意事项
恰同学少年的博客
12-22 5989
caffe中实现批量归一化（batch-normalization）需要借助两个层：BatchNorm 和 Scale BatchNorm实现的是归一化 Scale实现的是平移和缩放 在实现的时候要注意的是由于Scale需要实现平移功能，所以要把bias_term项设为true 另外，实现BatchNorm的时候需要注意一下参数use_global_stats，在训练的时候设为false，在
【caffe】Layer解读之：BatchNorm/Scale
yuanCruise
08-17 1917
Layer type: BatchNorm 头文件位置：./include/caffe/layers/batch_norm_layer.hpp CPU 执行源文件位置: ./src/caffe/layers/batch_norm_layer.cpp CUDA GPU 执行源文件位置: ./src/caffe/layers/batch_norm_layer.cu BatchNorm层的功能：对mi...
caffe 之batchnorm
06-25 168
caffe中bn往往和scale一起搭配使用。 layer{ 　　bottom: "conv1" 　　top: "conv1" 　　name:"bn_conv1" 　　type:"BatchNorm" 　　batch_norm_param{ 　　　　use_global_stats: true 　　} } layer{ 　　bottom:"conv1" 　　...
caffe学习笔记20-BatchNorm层分析
YiLiang
03-05 4641
caffe学习记录
caffe中batch_norm层代码详细注解
Mr.Gao的博客
09-18 1万+
caffe batch_norm 层代码详细注解
caffe Batchnorm使用
gaotihong的博客
11-29 282
目录 一、简介 二、网络分析 三. 理论知识： CNN 网络中的 Batch Normalization https://blog.csdn.net/sunbaigui/article/details/50807398 一、简介 如果将googlenet称之为google家的inception v1的话，其Batch Normalization（http://arxiv.org/p...
基础 | batchnorm原理及代码详解
热门推荐
Double_V的博客
01-12 11万+
Batchnorm原理详解 前言：Batchnorm是深度网络中经常用到的加速神经网络训练，加速收敛速度及稳定性的算法，可以说是目前深度网络必不可少的一部分。 本文旨在用通俗易懂的语言，对深度学习的常用算法–batchnorm的原理及其代码实现做一个详细的解读。本文主要包括以下几个部分。 Batchnorm主要解决的问题 Batchnorm原理解读 Batchnorm的优点 B
Batch Normalization Caffe版实现解析
lanran2的博客
02-22 7075
建议先看论文Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift，这样会对本文有更好的理解； 同时使用Batch Normalization的GoogLENet也被称为Inception v2；Batch Normalization Caffe版实现解析BatchN
caffe的batchnorm层解析
andeyeluguo的博客
04-26 748
batch norm层batch norm有三组参数打印参数的流程为：&gt;&gt;&gt; import sys&gt;&gt;&gt; sys.path.insert(0,'./python')&gt;&gt;&gt; import caffe&gt;&gt;&gt; net = caffe.Net('./examples/mnist/lenet_train_test.prototxt','...
caffe:BN层转batchnorm+scale修改prototxt
车牌识别
04-07 292
#coding=UTF-8 import sys sys.path.insert(0,'/home/cdli/ECO2/caffe_3d/python') import copy from caffe.proto import caffe_pb2 from google.protobuf import text_format import google def create_layer(base...
caffe固定网络权重参数------遇到BatchNorm层和Scale层的时候
arielkid的专栏
12-06 1339
通常的做法： 实现的关键变量是：propagate_down 含义：表示当前层的梯度是否向前传播 比如有4个全连接层A-&gt;B-&gt;C-&gt;D     a. 你希望C层的参数不会改变，C前面的AB层的参数也不会改变，这种情况也就是D层的梯度不往前反向传播到D层的输入blob（也就是C层的输出blob 没有得到梯度），你可以通过设置D层的propagate_down为false来做到。...
CAFFE源码学习笔记之batch_norm_layer
sinat_22336563的博客
04-13 6723
一、前言 网络训练的过程中参数不断的变化导致后续的每一层输入的分布也发生变化，而学习的过程使得每一层都需要适应输入的分布。所以就需要谨慎的选择初始化，使用小的学习率，这极大的降低了网络收敛的速度。为了使每层的输入分布大致都在0均值和单位方差，需要对每层的输入进行归一化。 为了使 二、源码分析 1、layersetup函数 batch_norm参数：message BatchNorm
【深度学习-基础知识】batchNormal原理及caffe中是如何使用的
chen1234520nnn的博客
06-23 1467
Batchnorm解决的问题： 机器学习领域有个很重要的假设：IID独立同分布假设，就是假设训练数据和测试数据是满足相同分布的，这是通过训练数据获得的模型能够在测试集获得好的效果的一个基本保障。那BatchNorm的作用是什么呢？BatchNorm就是在深度神经网络训练过程中使得每一层神经网络的输入保持相同的分布。 如果ML系统实例集合<X,Y>中的输入值X的分布老是变，这不符合IID假设，网络模型很难稳定的学规律，这不得引入迁移学习才能搞定吗，我们的ML系统还得去学习怎么迎合这种分布变化啊
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值