Deep Learning 工具

最新推荐文章于 2025-03-04 22:09:01 发布

卡列宁在睡觉

最新推荐文章于 2025-03-04 22:09:01 发布

阅读量233

点赞数

分类专栏： DeepLearning 文章标签： caffe 深度学习

本文链接：https://blog.youkuaiyun.com/longwoo1012/article/details/106957970

版权

DeepLearning 专栏收录该内容

9 篇文章

订阅专栏

伸手党的福音，工具真的有好多呀。。。。。

后之视今，亦犹今之视昔

后之视今，亦犹今之视昔

在风口的时候，可以亲眼见证各种变化，于是才有机会体验什么是瞬息万变。当年以目标识别为切入点，依据网上有的各种资料，各种填坑安装，重装，兵分几路，尝试caffe, mxnet, tensorflow,torch, cntk, darknet。

cntk用的太少，基本被放弃。
darknet仅仅是对yolo的专属，难以扩展，也没有专门去看。
torch那时仅仅支持lua,虽然买了本lua的书啃，但是生态还是个大问题，迫于tensorflow的压力后面最终还是推出了pytorch,大有超越tensorflow之势。
tensorflow感觉越来越庞杂，bazel的编译也是。。。
李沐、陈天奇等人的mxnet当时也是个厉害的角色，可惜没有大公司背书，生态很难起来。现在李沐本尊都已经有了《手把手教你》系列教程了。
caffe真的是个祖传工具，推出早，成名早，用户积累广，是源码debug研究的绝好材料，虽然后面一度被python接口的tensorflow碾压，在贾扬清大神加盟Facebook，推出caffe2以后，和pytorch配合训练+部署一条龙服务，简直不要太友好。

Caffe概览

祖传工具的好处是，有各种前人已经帮你把它揉碎嚼烂消化吸收好之后，呈现在你面前，可以大大的提升小白的学习效率。总的印象它大约是长成如下这个样子
在这里插入图片描述

Caffe的反向传播推导

结合安排和自己的兴趣，当时重点源码debug反向传播这一块。
以Softmax 函数为例，假设数据 ${\mathbf{x}}$ 对应的标签为 ${\mathbf{y}}$ ,观察到的数据 ${\mathbf{x}}$ ，属于类别 ${i}$ 的概率为 ${o_{i}}$ ， Softmax 函数： ${\mathbf{\sigma}(\mathbf{z} )=(\sigma_{1}(\mathbf{z}),...,\sigma_{m}(\mathbf{z}))}$
$o_{i}=\sigma_{i}(\mathbf{z})=\frac{exp(z_{i})}{\sum_{j=1}^{m}exp(z_{j})},i=1,...,m$
反向传播的动力源头-Multinomial Logistic Loss
$l(y,o)=-log(o_{y})$
$\frac{\partial l(y,o)}{\partial o_{i}}=-\frac{\delta_{iy}}{o_{y}}$
$\delta_{ky}=\left\{ \begin{array}{ll} 1 & \textrm{k = y}\\ 0 & \textrm{k!= y}\\ \end{array} \right.$
Softmax的导数
$\frac{\partial o_{i}}{\partial z_{k}}=\frac{\delta_{ik}e^{z_{i}}(\sum_{j=1}^{m}e^{z_{i}})-e^{z_{i}}e^{z_{k}}}{(\sum_{j=1}^{m}e^{z_{i}})^2}=\delta_{ik}o_{k}-o_{i}o_{k}$
引入chain rule，得到SoftmaxWithLoss的导数
$\sum_{i=1}^{m}\frac{\partial o_{i}}{\partial z_{k}}\cdot \frac{\partial l(y,o)}{\partial o_{i}}=o_{k}-\delta_{yk}\frac{o_{k}}{o_{y}}=o_{k}-\delta_{yk}$
Numerical Stability:
如果分成两层计算，除了计算量增大，数值稳定性也变差。由于浮点数有精度限制，每多一次运算就多累积一定误差，且分两步计算时，我们需要计算 $\frac{\delta_{iy}}{o_{y}}$ ，如果这次预测非常不准，正确的类别所得到的概率非常小，会产生overflow。

Caffe的反向传播代码

softmaxwithloss的反向传播实现

template <typename Dtype>
void KLNSOFTMAXLossLayer<Dtype>::Backward_cpu(
const vector<Blob<Dtype>*>& top,
const vector<bool>& propagate_down, 
const vector<Blob<Dtype>*>& bottom) {
  if (propagate_down[1]) {
    LOG(FATAL) << this->type()
               << "Layer cannot backpropagate to label inputs.";
  }
  if (propagate_down[0]) {
    Dtype* bottom_diff = bottom[0]->mutable_cpu_diff();
    const Dtype* prob_data = prob_.cpu_data();
    caffe_copy(prob_.count(), prob_data, bottom_diff);
    const Dtype* label = bottom[1]->cpu_data();
    int dim = prob_.count() / outer_num_;
    int count = 0;
    for (int i = 0; i < outer_num_; ++i) {
      for (int j = 0; j < inner_num_; ++j) {
        const int label_value = 
        static_cast<int>(label[i * inner_num_ + j]);
        if (has_ignore_label_ && label_value == ignore_label_) {
         for (int c = 0; c < bottom[0]->shape(kln_softmax_axis_); ++c) 
         {
            bottom_diff[i * dim + c * inner_num_ + j] = 0;
          }
        } else {
          bottom_diff[i * dim + label_value * inner_num_ + j] -= 1;
          ++count;
        }
      }
    }// Scale gradient
    Dtype loss_weight = top[0]->cpu_diff()[0] /
                        get_normalizer(normalization_, count);
    caffe_scal(prob_.count(), loss_weight, bottom_diff);
  }
}

Caffe手动添加一个自己的层

Step1: 添加ReLU在caffe.proto中的消息定义

message KLNReLUParameter {
   optional float negative_slope = 1 [default = 0];
  enum Engine {
    DEFAULT = 0;
    CAFFE = 1;
    CUDNN = 2;
  }
  optional Engine engine = 2 [default = DEFAULT];
}

Step2：在caffe.proto的LayerParameter中添加最新的ID

message LayerParameter {
  optional string name = 1; 
  optional string type = 2; 
  repeated string bottom = 3; 
  repeated string top = 4; 
......
  optional AccuracyParameter accuracy_param = 102;
  optional ArgMaxParameter argmax_param = 103;
  optional BatchNormParameter batch_norm_param = 139;
  optional BiasParameter bias_param = 141;
  optional ConcatParameter concat_param = 104;
......
  optional KLNReLUParameter kln_relu_param = 147;
}

Step3：在include/caffe/layers/中添加一个头文件kln_relu_layer.hpp

#ifndef CAFFE_KLN_RELU_LAYER_HPP_
#define CAFFE_KLN_RELU_LAYER_HPP_
#include <vector>
#include "caffe/blob.hpp"
#include "caffe/layer.hpp"
#include "caffe/proto/caffe.pb.h"
#include "caffe/layers/kln_neuron_layer.hpp"
namespace caffe {
template <typename Dtype>
class KLNReLULayer : public KLNNeuronLayer<Dtype> {
 public:
  explicit KLNReLULayer(const LayerParameter& param)
      : KLNNeuronLayer<Dtype>(param) {}
  virtual inline const char* type() const { return "KLNReLU"; }
 protected:
  virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);
  virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top){
      NOT_IMPLEMENTED;
  };
  virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, 
      const vector<Blob<Dtype>*>& bottom);
  virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, 
      const vector<Blob<Dtype>*>& bottom){
      NOT_IMPLEMENTED;
  };
};
}  // namespace caffe
#endif  // CAFFE_KLN_RELU_LAYER_HPP_

Step4：在src/caffe/layers/中添加对应的实现文件kln_relu_layer.cpp


#include <algorithm>
#include <vector>
#include "caffe/layers/kln_relu_layer.hpp"
namespace caffe {
template <typename Dtype>
void KLNReLULayer<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();
  const int count = bottom[0]->count();
  Dtype negative_slope =
  this->layer_param_.kln_relu_param().negative_slope();
  for (int i = 0; i < count; ++i) {
    top_data[i] = std::max(bottom_data[i], Dtype(0))
        + negative_slope * std::min(bottom_data[i], Dtype(0));
  }
}
template <typename Dtype>
void KLNReLULayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down,
    const vector<Blob<Dtype>*>& bottom) {
  if (propagate_down[0]) {
    const Dtype* bottom_data = bottom[0]->cpu_data();
    const Dtype* top_diff = top[0]->cpu_diff();
    Dtype* bottom_diff = bottom[0]->mutable_cpu_diff();
    const int count = bottom[0]->count();
    Dtype negative_slope =
    this->layer_param_.kln_relu_param().negative_slope();
    for (int i = 0; i < count; ++i) {
      bottom_diff[i] = top_diff[i] * ((bottom_data[i] > 0)
          + negative_slope * (bottom_data[i] <= 0));
    }
  }
}
INSTANTIATE_CLASS(KLNReLULayer);
}  // namespace caffe

Step5：在src/caffe/layer_factory.cpp中添加对应的注册实现

...
#include "caffe/layers/kln_relu_layer.hpp"
...
template <typename Dtype>
shared_ptr<Layer<Dtype>> GetKLNReLULayer(const LayerParameter& param) {
  KLNReLUParameter_Engine engine = param.kln_relu_param().engine();
  if (engine == KLNReLUParameter_Engine_DEFAULT) {
    engine = KLNReLUParameter_Engine_CAFFE;
  }
  if (engine == KLNReLUParameter_Engine_CAFFE) {
    return shared_ptr<Layer<Dtype> >(new KLNReLULayer<Dtype>(param));
  } else {
    LOG(FATAL) << "Layer " << param.name() << "has unknown engine.";
  }
}
REGISTER_LAYER_CREATOR(KLNReLU, GetKLNReLULayer);