caffe代码阅读6：Filler的实现细节-2016.3.18

最新推荐文章于 2024-04-08 14:57:02 发布

xizero00

最新推荐文章于 2024-04-08 14:57:02 发布

阅读量1w

点赞数 9

分类专栏： c/c++ 神经网络图像处理文章标签： caffe 源码阅读计算机视觉 c++ 神经网络

本文链接：https://blog.csdn.net/xizero00/article/details/50921692

版权

c/c++ 同时被 3 个专栏收录

46 篇文章 1 订阅

订阅专栏

图像处理

30 篇文章 3 订阅

订阅专栏

神经网络

23 篇文章 0 订阅

订阅专栏

一、Filler的作用简介

Filler层的作用实际上就是根据proto中给出的参数对权重进行初始化，初始化的方式有很多种，分别为常量初始化（constant）、高斯分布初始化（gaussian）、positive_unitball初始化、均匀分布初始化（uniform）、xavier初始化、msra初始化、双线性初始化（bilinear）这么几种。

二、Filler类的详细介绍

首先了解一下Filler类的第一个函数：该函数把整个Filler类一下子就看明白了

template <typename Dtype>
Filler<Dtype>* GetFiller(const FillerParameter& param) {
  const std::string& type = param.type();
  if (type == "constant") {
    return new ConstantFiller<Dtype>(param);
  } else if (type == "gaussian") {
    return new GaussianFiller<Dtype>(param);
  } else if (type == "positive_unitball") {
    return new PositiveUnitballFiller<Dtype>(param);
  } else if (type == "uniform") {
    return new UniformFiller<Dtype>(param);
  } else if (type == "xavier") {
    return new XavierFiller<Dtype>(param);
  } else if (type == "msra") {
    return new MSRAFiller<Dtype>(param);
  } else if (type == "bilinear") {
    return new BilinearFiller<Dtype>(param);
  } else {
    CHECK(false) << "Unknown filler name: " << param.type();
  }
  return (Filler<Dtype>*)(NULL);

根据给定的参数获取对应的Filler，由该段代码可以看出proto文件里面对于权重可以有哪些指定的初始化方式。

1）基类Filler

template <typename Dtype>
class Filler {
 public:
 // 构造函数
  explicit Filler(const FillerParameter& param) : filler_param_(param) {}
  // 析构函数，并且是虚函数
  virtual ~Filler() {}
  // 纯虚函数，继承的子类必须要实现
  virtual void Fill(Blob<Dtype>* blob) = 0;
 protected:
  FillerParameter filler_param_;
};  // class Filler

2）继承Filler的类

2-1常量初始化类

template <typename Dtype>
class ConstantFiller : public Filler<Dtype> {
 public:
  explicit ConstantFiller(const FillerParameter& param)
      : Filler<Dtype>(param) {}
  virtual void Fill(Blob<Dtype>* blob) {
    // 获取数据指针
    Dtype* data = blob->mutable_cpu_data();
    // 获取数据长度
    const int count = blob->count();
    // 获取常量初始化的常数值
    const Dtype value = this->filler_param_.value();
    CHECK(count);
    for (int i = 0; i < count; ++i) {
      data[i] = value;//对于每一个元素都初始化为常数值
    }
    CHECK_EQ(this->filler_param_.sparse(), -1)
         << "Sparsity not supported by this Filler.";
  }
};

2-2均匀分布初始化类

template <typename Dtype>
class UniformFiller : public Filler<Dtype> {
 public:
  explicit UniformFiller(const FillerParameter& param)
      : Filler<Dtype>(param) {}
  virtual void Fill(Blob<Dtype>* blob) {
    // 检查blob中的元素是否为0
    CHECK(blob->count());
    // 调用caffe_rng_uniform进行初始化
    caffe_rng_uniform<Dtype>(blob->count(), Dtype(this->filler_param_.min()),
        Dtype(this->filler_param_.max()), blob->mutable_cpu_data());
    // 均匀分布初始化是不支持稀疏特性的
    CHECK_EQ(this->filler_param_.sparse(), -1)
         << "Sparsity not supported by this Filler.";
  }
};

2-3高斯分布初始化类（支持稀疏特性）

template <typename Dtype>
class GaussianFiller : public Filler<Dtype> {
 public:
  explicit GaussianFiller(const FillerParameter& param)
      : Filler<Dtype>(param) {}
  virtual void Fill(Blob<Dtype>* blob) {
    Dtype* data = blob->mutable_cpu_data();
    CHECK(blob->count());
    // 调用caffe_rng_gaussian初始化、其中输入了高斯分布的均值和标准差
    caffe_rng_gaussian<Dtype>(blob->count(), Dtype(this->filler_param_.mean()),
        Dtype(this->filler_param_.std()), blob->mutable_cpu_data());
    int sparse = this->filler_param_.sparse();
    // 检查sparse > -1
    CHECK_GE(sparse, -1);
    if (sparse >= 0) {//  如果启用稀疏的话
      // Sparse initialization is implemented for "weight" blobs; i.e. matrices.
      // These have num == channels == 1; width is number of inputs; height is
      // number of outputs.  The 'sparse' variable specifies the mean number
      // of non-zero input weights for a given output.
      CHECK_GE(blob->num_axes(), 1);
      // 假设权重的形状是 输出单元个数 X输入单元个数
      // blob->shape(0) = 输出单元的个数
      const int num_outputs = blob->shape(0);
      // 不为0的概率 = 1/输出单元个数
      // 那么为0的概率= 1 - 1/输出单元个数
      Dtype non_zero_probability = Dtype(sparse) / Dtype(num_outputs);
      // 新建一个rand_vec，用户存放伯努利分布（二项分布）所生成的值
      rand_vec_.reset(new SyncedMemory(blob->count() * sizeof(int)));
      int* mask = reinterpret_cast<int*>(rand_vec_->mutable_cpu_data());
      caffe_rng_bernoulli(blob->count(), non_zero_probability, mask);
      for (int i = 0; i < blob->count(); ++i) {
        data[i] *= mask[i];// 每一个数据元素都与生成的二项分布的样本值相乘
      }
    }
  }

 protected:
  shared_ptr<SyncedMemory> rand_vec_;
};

2-4PositiveUnitballFiller初始化

不懂的可以看 http://math.stackexchange.com/questions/520002/unit-ball-with-p-norm

相当于是一个单位球

// PositiveUnitballFiller首先用均匀分布填充W
// 然后将W中的元素按行求和，然后该行每一个的元素都除以该行的和
template <typename Dtype>
class PositiveUnitballFiller : public Filler<Dtype> {
 public:
  explicit PositiveUnitballFiller(const FillerParameter& param)
      : Filler<Dtype>(param) {}
  virtual void Fill(Blob<Dtype>* blob) {
    Dtype* data = blob->mutable_cpu_data();
    DCHECK(blob->count());// 我很奇怪为啥这里用DCHECK
    // 先填充均匀分布到权重
    caffe_rng_uniform<Dtype>(blob->count(), 0, 1, blob->mutable_cpu_data());
    // We expect the filler to not be called very frequently, so we will
    // just use a simple implementation
    // count / num = 输入的维度
    int dim = blob->count() / blob->num();
    CHECK(dim);// 检查输入维度是否小于0
    for (int i = 0; i < blob->num(); ++i) {// 遍历隐藏单元的个数（或者是输出单元的个数）
      Dtype sum = 0;
      for (int j = 0; j < dim; ++j) {
        sum += data[i * dim + j];//sum += data[i][j] 也就是说要按行求和
      }
      for (int j = 0; j < dim; ++j) {
        data[i * dim + j] /= sum;// 每一行都除以该行的和
      }
    }
    CHECK_EQ(this->filler_param_.sparse(), -1)
         << "Sparsity not supported by this Filler.";
  }
};

2-5 XavierFiller初始化（用于卷积核）

// 这里不明白的就是shape (num, a, b, c) where a * b * c = fan_in and num * b * c = fan_out
 // 扇入和扇出的定义了
// 感谢王峰，后来才知道b*c=kernel size
// a是输入的channel
// num是输出的channel
template <typename Dtype>
class XavierFiller : public Filler<Dtype> {
 public:
  explicit XavierFiller(const FillerParameter& param)
      : Filler<Dtype>(param) {}
  virtual void Fill(Blob<Dtype>* blob) {
    CHECK(blob->count());
    int fan_in = blob->count() / blob->num();
    int fan_out = blob->count() / blob->channels();
    Dtype n = fan_in;  // default to fan_in
    if (this->filler_param_.variance_norm() ==// 如果参数里面定义了方差归一化则n = 扇入+扇出
        FillerParameter_VarianceNorm_AVERAGE) {
      n = (fan_in + fan_out) / Dtype(2);
    } else if (this->filler_param_.variance_norm() ==
        FillerParameter_VarianceNorm_FAN_OUT) {
      n = fan_out;
    }
    Dtype scale = sqrt(Dtype(3) / n);// scale = \frac{sqrt{3}}{n}
    // 然后用[-scale,scale]的均匀分布初始化
    caffe_rng_uniform<Dtype>(blob->count(), -scale, scale,
        blob->mutable_cpu_data());
    CHECK_EQ(this->filler_param_.sparse(), -1)
         << "Sparsity not supported by this Filler.";
  }
};

2-6 MSRAFiller初始化方式（用于卷积核）

template <typename Dtype>
class MSRAFiller : public Filler<Dtype> {
 public:
  explicit MSRAFiller(const FillerParameter& param)
      : Filler<Dtype>(param) {}
  virtual void Fill(Blob<Dtype>* blob) {
    CHECK(blob->count());
    int fan_in = blob->count() / blob->num();
    int fan_out = blob->count() / blob->channels();
    Dtype n = fan_in;  // default to fan_in
    if (this->filler_param_.variance_norm() ==
        FillerParameter_VarianceNorm_AVERAGE) {
      n = (fan_in + fan_out) / Dtype(2);
    } else if (this->filler_param_.variance_norm() ==
        FillerParameter_VarianceNorm_FAN_OUT) {
      n = fan_out;
    }
    // 标准差是\sqrt{\frac{2}{n}}
    Dtype std = sqrt(Dtype(2) / n);
    caffe_rng_gaussian<Dtype>(blob->count(), Dtype(0), std,
        blob->mutable_cpu_data());
    CHECK_EQ(this->filler_param_.sparse(), -1)
         << "Sparsity not supported by this Filler.";
  }
};

2-7 BilinearFiller初始化（用户反卷积核）

// 反卷积所用的初始化，不支持稀疏特性
 // 没研究过。。。也不知道
template <typename Dtype>
class BilinearFiller : public Filler<Dtype> {
 public:
  explicit BilinearFiller(const FillerParameter& param)
      : Filler<Dtype>(param) {}
  virtual void Fill(Blob<Dtype>* blob) {
    CHECK_EQ(blob->num_axes(), 4) << "Blob must be 4 dim.";
    CHECK_EQ(blob->width(), blob->height()) << "Filter must be square";
    Dtype* data = blob->mutable_cpu_data();
    // f是宽度除以2
    int f = ceil(blob->width() / 2.);
    // c的含义不明白
    float c = (2 * f - 1 - f % 2) / (2. * f);
    for (int i = 0; i < blob->count(); ++i) {
      float x = i % blob->width();// x表示列的索引
      float y = (i / blob->width()) % blob->height();// 行的索引%宽度
      data[i] = (1 - fabs(x / f - c)) * (1 - fabs(y / f - c));
    }
    CHECK_EQ(this->filler_param_.sparse(), -1)
         << "Sparsity not supported by this Filler.";
  }
};

三、与Filler类相关类的介绍

因为Filler用到了关于随机数生成的一些方法，下面来看下math_function的相关实现：

（1）高斯分布随机数的生成：

CPU上的实现（直接调用Boost的库了）

template <typename Dtype>
void caffe_rng_gaussian(const int n, const Dtype a,
                        const Dtype sigma, Dtype* r) {
  CHECK_GE(n, 0);
  CHECK(r);
  CHECK_GT(sigma, 0);
  // 直接调用boost中的正太分布了。
  boost::normal_distribution<Dtype> random_distribution(a, sigma);
  boost::variate_generator<caffe::rng_t*, boost::normal_distribution<Dtype> >
      variate_generator(caffe_rng(), random_distribution);
  for (int i = 0; i < n; ++i) {
    r[i] = variate_generator();
  }
}

GPU的实现（直接调用CUDA的库了）

template <>
void caffe_gpu_rng_gaussian(const int n, const float mu, const float sigma,
                            float* r) {
  CURAND_CHECK(
      curandGenerateNormal(Caffe::curand_generator(), r, n, mu, sigma));
}

template <>
void caffe_gpu_rng_gaussian(const int n, const double mu, const double sigma,
                            double* r) {
  CURAND_CHECK(
      curandGenerateNormalDouble(Caffe::curand_generator(), r, n, mu, sigma));
}

（2）均匀分布随机数的生成：

CPU：

template <typename Dtype>
void caffe_rng_uniform(const int n, const Dtype a, const Dtype b, Dtype* r) {
  CHECK_GE(n, 0);
  CHECK(r);
  CHECK_LE(a, b);
  // 调用Boost的库
  boost::uniform_real<Dtype> random_distribution(a, caffe_nextafter<Dtype>(b));
  boost::variate_generator<caffe::rng_t*, boost::uniform_real<Dtype> >
      variate_generator(caffe_rng(), random_distribution);
  for (int i = 0; i < n; ++i) {
    r[i] = variate_generator();
  }
}

GPU：

void caffe_gpu_rng_uniform(const int n, unsigned int* r) {
  CURAND_CHECK(curandGenerate(Caffe::curand_generator(), r, n));
}

template <>
void caffe_gpu_rng_uniform<float>(const int n, const float a, const float b,
                                  float* r) {
  CURAND_CHECK(curandGenerateUniform(Caffe::curand_generator(), r, n));
  const float range = b - a;
  if (range != static_cast<float>(1)) {
    caffe_gpu_scal(n, range, r);
  }
  if (a != static_cast<float>(0)) {
    caffe_gpu_add_scalar(n, a, r);
  }
}

template <>
void caffe_gpu_rng_uniform<double>(const int n, const double a, const double b,
                                   double* r) {
  CURAND_CHECK(curandGenerateUniformDouble(Caffe::curand_generator(), r, n));
  const double range = b - a;
  if (range != static_cast<double>(1)) {
    caffe_gpu_scal(n, range, r);
  }
  if (a != static_cast<double>(0)) {
    caffe_gpu_add_scalar(n, a, r);
  }
}

（3）伯努利分布（二项分布）随机数的生成（竟然没有GPU上的代码。。。）

template <typename Dtype>
void caffe_rng_bernoulli(const int n, const Dtype p, int* r) {
  CHECK_GE(n, 0);
  CHECK(r);
  CHECK_GE(p, 0);
  CHECK_LE(p, 1);
  boost::bernoulli_distribution<Dtype> random_distribution(p);
  boost::variate_generator<caffe::rng_t*, boost::bernoulli_distribution<Dtype> >
      variate_generator(caffe_rng(), random_distribution);
  for (int i = 0; i < n; ++i) {
    r[i] = variate_generator();
  }
}
void caffe_rng_bernoulli(const int n, const Dtype p, unsigned int* r) {
  CHECK_GE(n, 0);
  CHECK(r);
  CHECK_GE(p, 0);
  CHECK_LE(p, 1);
  boost::bernoulli_distribution<Dtype> random_distribution(p);
  boost::variate_generator<caffe::rng_t*, boost::bernoulli_distribution<Dtype> >
      variate_generator(caffe_rng(), random_distribution);
  for (int i = 0; i < n; ++i) {
    r[i] = static_cast<unsigned int>(variate_generator());
  }
}