caffe源码 之 layer类

最新推荐文章于 2021-03-17 16:30:40 发布
最新推荐文章于 2021-03-17 16:30:40 发布
阅读量2k 收藏 2
点赞数
分类专栏： 深度学习 文章标签： caffe layer 类 loss-layer data-layer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lanxuecc/article/details/53023211
版权

本文主要解析caffe的中层类定义模块文件/src/caffe/layer.hpp layer.cpp，layer是所有层的基类。

综述：：layer.hpp定义了layer的基类，其他例如：loss_layer，data_layer，vision_layer都是在这个layer类的基础上继承的，他们分别实现了基类layer中的一些弱函数，下面通过注释记录下我对基类源码的理解：：：：：

layer.hpp：：：：：：：：：：：：：：

#ifndef CAFFE_LAYER_H_
#define CAFFE_LAYER_H_

#include <algorithm>
#include <string>
#include <vector>

#include "caffe/blob.hpp"
#include "caffe/common.hpp"
#include "caffe/layer_factory.hpp"
#include "caffe/proto/caffe.pb.h"
#include "caffe/util/math_functions.hpp"

/**
 Forward declare boost::thread instead of including boost/thread.hpp
 to avoid a boost/NVCC issues (#1009, #1010) on OSX.
 */
namespace boost { class mutex; }

namespace caffe {

/**
 * @brief An interface for the units of computation which can be composed into a
 *        Net.
 *
 * Layer%s must implement a Forward function, in which they take their input
 * (bottom) Blob%s (if any) and compute their output Blob%s (if any).
 * They may also implement a Backward function, in which they compute the error
 * gradients with respect to their input Blob%s, given the error gradients with
 * their output Blob%s.
 */
template <typename Dtype>
class Layer {
 public:
  /**
   * You should not implement your own constructor. Any set up code should go
   * to SetUp(), where the dimensions of the bottom blobs are provided to the
   * layer.
   */
  explicit Layer(const LayerParameter& param)   /*从solver.prototxt文件中传入的网络参数*/
    : layer_param_(param), is_shared_(false) {
      // Set phase and copy blobs (if there are any).
      phase_ = param.phase();  /*将当前网络是用来测试test还是train的属性值赋值*/
      if (layer_param_.blobs_size() > 0) {
        blobs_.resize(layer_param_.blobs_size());
        for (int i = 0; i < layer_param_.blobs_size(); ++i) {
          blobs_[i].reset(new Blob<Dtype>());
          blobs_[i]->FromProto(layer_param_.blobs(i));  /*blobs_ 是一个容器用来存放指向Blob类的智能指针, 这里将protobuf中所有的blobs拷贝到参数blobs_ 所指向缓存*/
        }
      }
    }
  virtual ~Layer() {}  /*类的析构函数*/

  /**
   * @brief Implements common layer setup functionality.
   *
   * @param bottom the preshaped input blobs
   * @param top
   *     the allocated but unshaped output blobs, to be shaped by Reshape
   *
   * Checks that the number of bottom and top blobs is correct.
   * Calls LayerSetUp to do special layer setup for individual layer types,
   * followed by Reshape to set up sizes of top blobs and internal buffers.
   * Sets up the loss weight multiplier blobs for any non-zero loss weights.
   * This method may not be overridden.
   */
  void SetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
    InitMutex();
    CheckBlobCounts(bottom, top);   /*检查传入的top与bottom数据的blob是否正确*/
    //每层进行具体配置
    LayerSetUp(bottom, top);
    //为了适应输入（bottom）数据的blob的shape的需要，来修改输出（top）数据的blob的shape
    Reshape(bottom, top);  
    //初始化损失函数中任何与输入（top）blob数据相关的权重
    SetLossWeights(top);
  }

  /**
   * @brief Does layer-specific setup: your layer should implement this function
   *        as well as Reshape.
   *
   * @param bottom
   *     the preshaped input blobs, whose data fields store the input data for
   *     this layer
   * @param top
   *     the allocated but unshaped output blobs
   *
   * This method should do one-time layer specific setup. This includes reading
   * and processing relevent parameters from the <code>layer_param_</code>.
   * Setting up the shapes of top blobs and internal buffers should be done in
   * <code>Reshape</code>, which will be called before the forward pass to
   * adjust the top blob sizes.
   */
   /*具体的每层的设置函数，虚函数每层要具体的实现这个函数*/
  virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {}

  /**
   * @brief Whether a layer should be shared by multiple nets during data
   *        parallelism. By default, all layers except for data layers should
   *        not be shared. data layers should be shared to ensure each worker
   *        solver access data sequentially during data parallelism.
   */ 
   /*反回并行状态,默认除了data layer层其他层都是关闭的*/
  virtual inline bool ShareInParallel() const { return false; }

  /** @brief Return whether this layer is actually shared by other nets.
   *         If ShareInParallel() is true and using more than one GPU and the
   *         net has TRAIN phase, then this function is expected return true.
   */  
   /*在ShareInParallel返回的值表示该层被共享的前提下，
     用这个函数来确定返回参数is_shared_来确定当前层是否被多个网络共享*/
  inline bool IsShared() const { return is_shared_; }

  /** @brief Set whether this layer is actually shared by other nets
   *         If ShareInParallel() is true and using more than one GPU and the
   *         net has TRAIN phase, then is_shared should be set true.
   */
   /*在ShareInParallel返回的值表示该层被共享的前提下, 
     用这个函数来设置参数is_shared_与上面的函数IsShared()相对应*/
  inline void SetShared(bool is_shared) {
    CHECK(ShareInParallel() || !is_shared)
        << type() << "Layer does not support sharing.";
    is_shared_ = is_shared;
  }

  /**
   * @brief Adjust the shapes of top blobs and internal buffers to accommodate
   *        the shapes of the bottom blobs.
   *
   * @param bottom the input blobs, with the requested input shapes
   * @param top the top blobs, which should be reshaped as needed
   *
   * This method should reshape top blobs as needed according to the shapes
   * of the bottom (input) blobs, as well as reshaping any internal buffers
   * and making any other necessary adjustments so that the layer can
   * accommodate the bottom blobs.
   */
   //为了适应输入（bottom）数据的blob的shape的需要，来修改输出（top）数据的blob的shape
  virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) = 0;

  /**
   * @brief Given the bottom blobs, compute the top blobs and the loss.
   *
   * @param bottom
   *     the input blobs, whose data fields store the input data for this layer
   * @param top
   *     the preshaped output blobs, whose data fields will store this layers'
   *     outputs
   * \return The total loss from the layer.
   *
   * The Forward wrapper calls the relevant device wrapper function
   * (Forward_cpu or Forward_gpu) to compute the top blob values given the
   * bottom blobs.  If the layer has any non-zero loss_weights, the wrapper
   * then computes and returns the loss.
   *
   * Your layer should implement Forward_cpu and (optionally) Forward_gpu.
   */
   /*实现前向传播函数，根据输入数据的blob来计算输出数据的blob，并且计算损失量*/
  inline Dtype Forward(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);

  /**
   * @brief Given the top blob error gradients, compute the bottom blob error
   *        gradients.
   *
   * @param top
   *     the output blobs, whose diff fields store the gradient of the error
   *     with respect to themselves
   * @param propagate_down
   *     a vector with equal length to bottom, with each index indicating
   *     whether to propagate the error gradients down to the bottom blob at
   *     the corresponding index
   * @param bottom
   *     the input blobs, whose diff fields will store the gradient of the error
   *     with respect to themselves after Backward is run
   *
   * The Backward wrapper calls the relevant device wrapper function
   * (Backward_cpu or Backward_gpu) to compute the bottom blob diffs given the
   * top blob diffs.
   *
   * Your layer should implement Backward_cpu and (optionally) Backward_gpu.
   */
   /*实现后向传播函数, 根据输出数据的误差梯度计算输出数据的误差梯度*/
  inline void Backward(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down,
      const vector<Blob<Dtype>*>& bottom);

  /**
   * @brief Returns the vector of learnable parameter blobs.
   */
  vector<shared_ptr<Blob<Dtype> > >& blobs() {
    return blobs_;   /*返回学习的参数，以blobs的容器保存的*/
  }

  /**
   * @brief Returns the layer parameter.
   */
   /*返回传入的该层的配置参数*/
  const LayerParameter& layer_param() const { return layer_param_; }

  /**
   * @brief Writes the layer parameter to a protocol buffer
   */
   /*将层参数写成Protobuffer文件*/
  virtual void ToProto(LayerParameter* param, bool write_diff = false);

  /**
   * @brief Returns the scalar loss associated with a top blob at a given index.
   */
   /*根据索引返回输出数据相关的损失量*/
  inline Dtype loss(const int top_index) const {
    return (loss_.size() > top_index) ? loss_[top_index] : Dtype(0);
  }

  /**
   * @brief Sets the loss associated with a top blob at a given index.
   */
   /*根据索引设置相关的损失量*/
  inline void set_loss(const int top_index, const Dtype value) {
    if (loss_.size() <= top_index) {
      loss_.resize(top_index + 1, Dtype(0));
    }
    loss_[top_index] = value;
  }

  /**
   * @brief Returns the layer type.
   */
   /*返回layer的类型，具体的层具体实现*/
  virtual inline const char* type() const { return ""; }

  /**
   * @brief Returns the exact number of bottom blobs required by the layer,
   *        or -1 if no exact number is required.
   *
   * This method should be overridden to return a non-negative value if your
   * layer expects some exact number of bottom blobs.
   */
   /*返回具体的输入的blobs的个数*/
  virtual inline int ExactNumBottomBlobs() const { return -1; }
  /**
   * @brief Returns the minimum number of bottom blobs required by the layer,
   *        or -1 if no minimum number is required.
   *
   * This method should be overridden to return a non-negative value if your
   * layer expects some minimum number of bottom blobs.
   */
   /*返回当前层所需的最少输入的blobs数量*/
  virtual inline int MinBottomBlobs() const { return -1; }
  /**
   * @brief Returns the maximum number of bottom blobs required by the layer,
   *        or -1 if no maximum number is required.
   *
   * This method should be overridden to return a non-negative value if your
   * layer expects some maximum number of bottom blobs.
   */
   /*返回当前层所需的最多的输入的blobs数量*/
  virtual inline int MaxBottomBlobs() const { return -1; }
  /**
   * @brief Returns the exact number of top blobs required by the layer,
   *        or -1 if no exact number is required.
   *
   * This method should be overridden to return a non-negative value if your
   * layer expects some exact number of top blobs.
   */
   /*返回具体的输出的blobs的个数*/
  virtual inline int ExactNumTopBlobs() const { return -1; }
  /**
   * @brief Returns the minimum number of top blobs required by the layer,
   *        or -1 if no minimum number is required.
   *
   * This method should be overridden to return a non-negative value if your
   * layer expects some minimum number of top blobs.
   */
   /*返回当前层所需的最少输出的blobs数量*/
  virtual inline int MinTopBlobs() const { return -1; }
  /**
   * @brief Returns the maximum number of top blobs required by the layer,
   *        or -1 if no maximum number is required.
   *
   * This method should be overridden to return a non-negative value if your
   * layer expects some maximum number of top blobs.
   */
   /*返回当前层所需的最多输出的blobs数量*/
  virtual inline int MaxTopBlobs() const { return -1; }
  /**
   * @brief Returns true if the layer requires an equal number of bottom and
   *        top blobs.
   *
   * This method should be overridden to return true if your layer expects an
   * equal number of bottom and top blobs.
   */
   /*判断输入与输出的blobs数量是否一致*/
  virtual inline bool EqualNumBottomTopBlobs() const { return false; }

  /**
   * @brief Return whether "anonymous" top blobs are created automatically
   *        by the layer.
   *
   * If this method returns true, Net::Init will create enough "anonymous" top
   * blobs to fulfill the requirement specified by ExactNumTopBlobs() or
   * MinTopBlobs().
   */
   /*如果返回true， Net::Init就会自动创建足够的top blobs来满足
     ExactNumTopBlobs()和MinTopBlobs()的需要*/
  virtual inline bool AutoTopBlobs() const { return false; }

  /**
   * @brief Return whether to allow force_backward for a given bottom blob
   *        index.
   *
   * If AllowForceBackward(i) == false, we will ignore the force_backward
   * setting and backpropagate to blob i only if it needs gradient information
   * (as is done when force_backward == false).
   */
   /*设置是否强制梯度返回，因为有些层其实不需要梯度信息 */
  virtual inline bool AllowForceBackward(const int bottom_index) const {
    return true;
  }

  /**
   * @brief Specifies whether the layer should compute gradients w.r.t. a
   *        parameter at a particular index given by param_id.
   *
   * You can safely ignore false values and always compute gradients
   * for all parameters, but possibly with wasteful computation.
   */
   /*确定当前层是否应该计算梯度*/
  inline bool param_propagate_down(const int param_id) {
    return (param_propagate_down_.size() > param_id) ?
        param_propagate_down_[param_id] : false;
  }
  /**
   * @brief Sets whether the layer should compute gradients w.r.t. a
   *        parameter at a particular index given by param_id.
   */
   /*设置当前层是否需要计算梯度*/
  inline void set_param_propagate_down(const int param_id, const bool value) {
    if (param_propagate_down_.size() <= param_id) {
      param_propagate_down_.resize(param_id + 1, true);
    }
    param_propagate_down_[param_id] = value;
  }


 protected:
  /** The protobuf that stores the layer parameters */
  LayerParameter layer_param_;  //配置的层参数
  /** The phase: TRAIN or TEST */
  Phase phase_;  //当前处在test还是train阶段
  /** The vector that stores the learnable parameters as a set of blobs. */
  vector<shared_ptr<Blob<Dtype> > > blobs_;  //blobs_是一个vector容器，其元素是指向Blob的shared_ptr指针，将可学习的参数存在一组Blob类内
  /** Vector indicating whether to compute the diff of each param blob. */
  vector<bool> param_propagate_down_;  //标识是否为每个参数的blob计算梯度

  /** The vector that indicates whether each top blob has a non-zero weight in
   *  the objective function. */
  vector<Dtype> loss_;  /*标识哪个top blob 有非零的权重*/

  /** @brief Using the CPU device, compute the layer output. */
  virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) = 0;   /*用cpu实现的前向传播函数*/
  /**
   * @brief Using the GPU device, compute the layer output.
   *        Fall back to Forward_cpu() if unavailable.
   */
  virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
    // LOG(WARNING) << "Using CPU code as backup.";
    return Forward_cpu(bottom, top);  /*gpu实现的前向传播函数*/
  }

  /**
   * @brief Using the CPU device, compute the gradients for any parameters and
   *        for the bottom blobs if propagate_down is true.
   */
  virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down,
      const vector<Blob<Dtype>*>& bottom) = 0;  /*cpu实现后向传播*/
  /**
   * @brief Using the GPU device, compute the gradients for any parameters and
   *        for the bottom blobs if propagate_down is true.
   *        Fall back to Backward_cpu() if unavailable.
   */
  virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down,
      const vector<Blob<Dtype>*>& bottom) {
    // LOG(WARNING) << "Using CPU code as backup.";
    Backward_cpu(top, propagate_down, bottom);  /*gpu实现后向传播*/
  }

  /**
   * Called by the parent Layer's SetUp to check that the number of bottom
   * and top Blobs provided as input match the expected numbers specified by
   * the {ExactNum,Min,Max}{Bottom,Top}Blobs() functions.
   */
   /*检查输入与输出的blobs个数是否正确*/
  virtual void CheckBlobCounts(const vector<Blob<Dtype>*>& bottom,
                               const vector<Blob<Dtype>*>& top) {
    if (ExactNumBottomBlobs() >= 0) {
      CHECK_EQ(ExactNumBottomBlobs(), bottom.size())
          << type() << " Layer takes " << ExactNumBottomBlobs()
          << " bottom blob(s) as input.";
    }
    if (MinBottomBlobs() >= 0) {
      CHECK_LE(MinBottomBlobs(), bottom.size())
          << type() << " Layer takes at least " << MinBottomBlobs()
          << " bottom blob(s) as input.";
    }
    if (MaxBottomBlobs() >= 0) {
      CHECK_GE(MaxBottomBlobs(), bottom.size())
          << type() << " Layer takes at most " << MaxBottomBlobs()
          << " bottom blob(s) as input.";
    }
    if (ExactNumTopBlobs() >= 0) {
      CHECK_EQ(ExactNumTopBlobs(), top.size())
          << type() << " Layer produces " << ExactNumTopBlobs()
          << " top blob(s) as output.";
    }
    if (MinTopBlobs() >= 0) {
      CHECK_LE(MinTopBlobs(), top.size())
          << type() << " Layer produces at least " << MinTopBlobs()
          << " top blob(s) as output.";
    }
    if (MaxTopBlobs() >= 0) {
      CHECK_GE(MaxTopBlobs(), top.size())
          << type() << " Layer produces at most " << MaxTopBlobs()
          << " top blob(s) as output.";
    }
    if (EqualNumBottomTopBlobs()) {
      CHECK_EQ(bottom.size(), top.size())
          << type() << " Layer produces one top blob as output for each "
          << "bottom blob input.";
    }
  }

  /**
   * Called by SetUp to initialize the weights associated with any top blobs in
   * the loss function. Store non-zero loss weights in the diff blob.
   */
   /*初始化输出数据的权重*/
  inline void SetLossWeights(const vector<Blob<Dtype>*>& top) {
    const int num_loss_weights = layer_param_.loss_weight_size();
    if (num_loss_weights) {
      CHECK_EQ(top.size(), num_loss_weights) << "loss_weight must be "
          "unspecified or specified once per top blob.";
      for (int top_id = 0; top_id < top.size(); ++top_id) {
        const Dtype loss_weight = layer_param_.loss_weight(top_id);
        if (loss_weight == Dtype(0)) { continue; }
        this->set_loss(top_id, loss_weight);
        const int count = top[top_id]->count();
        Dtype* loss_multiplier = top[top_id]->mutable_cpu_diff();
        caffe_set(count, loss_weight, loss_multiplier);
      }
    }
  }

 private:
  /** Whether this layer is actually shared by other nets*/
  bool is_shared_;  /*标识该层是否被其他网络共享*/

  /** The mutex for sequential forward if this layer is shared */
  shared_ptr<boost::mutex> forward_mutex_;  

  /*下面是多线程的一些操作*/
  /** Initialize forward_mutex_ */
  void InitMutex();
  /** Lock forward_mutex_ if this layer is shared */
  void Lock();
  /** Unlock forward_mutex_ if this layer is shared */
  void Unlock();

  DISABLE_COPY_AND_ASSIGN(Layer);
};  // class Layer

// Forward and backward wrappers. You should implement the cpu and
// gpu specific implementations instead, and should not change these
// functions.
template <typename Dtype>
inline Dtype Layer<Dtype>::Forward(const vector<Blob<Dtype>*>& bottom,
    const vector<Blob<Dtype>*>& top) {
  // Lock during forward to ensure sequential forward
  Lock();   /*锁住保证按顺序实现前向传播*/
  Dtype loss = 0;
  Reshape(bottom, top);
  switch (Caffe::mode()) {   /*检查传入的运行模式，是只在cpu模式下运行，还是gpu模式下运行*/
  case Caffe::CPU:
    Forward_cpu(bottom, top); /*如果是cpu模式下运行，则调用Forward_cpu计算输入的blobs与loss,不同的layer实现不同*/
    for (int top_id = 0; top_id < top.size(); ++top_id) {
      if (!this->loss(top_id)) { continue; }
      const int count = top[top_id]->count();
      const Dtype* data = top[top_id]->cpu_data();
      const Dtype* loss_weights = top[top_id]->cpu_diff();
      loss += caffe_cpu_dot(count, data, loss_weights);   /*累加每个输出数据的loss*/
    }
    break;
  case Caffe::GPU:
    Forward_gpu(bottom, top);   /*如果是gpu模式下运行，则调用Forward_gpu计算输入的blobs与loss,不同的layer实现不同*/
#ifndef CPU_ONLY
    for (int top_id = 0; top_id < top.size(); ++top_id) {
      if (!this->loss(top_id)) { continue; }
      const int count = top[top_id]->count();
      const Dtype* data = top[top_id]->gpu_data();
      const Dtype* loss_weights = top[top_id]->gpu_diff();
      Dtype blob_loss = 0;
      caffe_gpu_dot(count, data, loss_weights, &blob_loss);/*累加每个输出数据的loss*/
      loss += blob_loss;
    }
#endif
    break;
  default:
    LOG(FATAL) << "Unknown caffe mode.";
  }
  Unlock();
  return loss;
}

/*后向传播的实现，根据模式的不同调用不同的实现函数*/
template <typename Dtype>
inline void Layer<Dtype>::Backward(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down,
    const vector<Blob<Dtype>*>& bottom) {
  switch (Caffe::mode()) {
  case Caffe::CPU:
    Backward_cpu(top, propagate_down, bottom);
    break;
  case Caffe::GPU:
    Backward_gpu(top, propagate_down, bottom);
    break;
  default:
    LOG(FATAL) << "Unknown caffe mode.";
  }
}

// Serialize LayerParameter to protocol buffer
/*将参数保存到protocol缓存*/
template <typename Dtype>
void Layer<Dtype>::ToProto(LayerParameter* param, bool write_diff) {
  param->Clear();
  param->CopyFrom(layer_param_);
  param->clear_blobs();
  for (int i = 0; i < blobs_.size(); ++i) {
    blobs_[i]->ToProto(param->add_blobs(), write_diff);
  }
}

}  // namespace caffe

#endif  // CAFFE_LAYER_H_

layer.cpp

#include <boost/thread.hpp>
#include "caffe/layer.hpp"

namespace caffe {

/*下面是多线程操作函数的实现*/
template <typename Dtype>
void Layer<Dtype>::InitMutex() {
  forward_mutex_.reset(new boost::mutex());
}

template <typename Dtype>
void Layer<Dtype>::Lock() {
  if (IsShared()) {
    forward_mutex_->lock();
  }
}

template <typename Dtype>
void Layer<Dtype>::Unlock() {
  if (IsShared()) {
    forward_mutex_->unlock();
  }
}

INSTANTIATE_CLASS(Layer);

}  // namespace caffe

感谢：：：：
http://www.cnblogs.com/louyihang-loves-baiyan/p/5152653.html
http://blog.csdn.net/mounty_fsc/article/details/51092906
http://blog.csdn.net/u011104550/article/details/51249387
http://blog.163.com/yuyang_tech/blog/static/2160500832015713105052452/

_苏_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
caffe数据结构(二): Layer
sinat_16577223的博客
01-05 1631
Layer是caffe 基本计算单元, 至少有一个输入Blob(Bottom) 和输出Blob(Top), 部分layer带有weight 和bias项. 两个运算方向:前向传播和反向传播. 相关数据结构,位于caffe.proto中的LayerParameter部分: (当增加新的LayerParameter域时,要更新下一个可用ID, 这在自定义层时会用到.) // NOTE /
深度学习caffe框架(2): layer定义
几何君的算法天空
09-15 2506
caffe的layers定义
Caffe Layer层类详解
qwj的博客
03-17 632
原文链接：https://blog.csdn.net/qiu931110/article/details/86560964 简介 Layer层类是Caffe中搭建网络的基本单元，当然也是使用Caffe训练的核心部件单元，因此我们将其称之为Caffe的核心积木。Layer基类派生出了各种不同功能的层类，Layer类派生出来的层类通过实现两个虚函数Forward()和Backward()，产生了各式各样功能的层类。Forward是从根据bottom计算top的过程进行前向计算，Backward则相反根据to
Caffe | 核心积木Layer层类详解
yuanCruise
01-20 1509
0.简介 Layer层类是Caffe中搭建网络的基本单元，当然也是使用Caffe训练的核心部件单元，因此我们将其称之为Caffe的核心积木。Layer基类派生出了各种不同功能的层类，Layer类派生出来的层类通过实现两个虚函数Forward()和Backward()，产生了各式各样功能的层类。Forward是从根据bottom计算top的过程进行前向计算，Backward则相反根据top计算bot...
caffe代码阅读5：Layer的实现细节-2016.3.17
一亩半分地
03-17 1万+
解析Caffe中的Layer类的相关具体的实现。
caffe源码 池化层
ERKELIU的博客
11-01 308
1、标题图示池化层（前向传播） 池化层其实和卷积层有点相似，有个类似卷积核的窗口按照固定的步长在移动，每个窗口做一定的操作，按照这个操作的类型可以分为两种池化层： 输入参数如下： 输入： 1 * 3 * 4 * 4 池化核: 2 * 2 pad: 0 步长：2 输出参数如下： 输出：1 * 3 * 2 * 2 1.1、MAX （max pooling）在窗口中取最大值当做结果 1.2、AVG...
caffe源码中的common_layers
abcef31415926的博客
08-11 444
1. split_layer bottom中一个blob，top层中多个blob top层中的所有blob共享bottom中的data，但diff数据不同 因此，backward过程，实际上是把top中对应位置的diff相加，所得到的结果作为bottom中的diff 2. inner_product_layer 是全连接层 输入是一个K维矢量，输出是N维
深度学习框架Caffe源码解析
02-25
本文将从整体架构和底层实现的视角，对Caffe源码进行解析。Caffe框架主要有五个组件，Blob，Solver，Net，Layer，Proto，其结构图如下图1所示。Solver负责深度网络的训练，每个Solver中包含一个训练网络对象和一个...
caffe 源码解析部分
07-06
**深度学习框架Caffe源码解析** Caffe（Convolutional Architecture for Fast Feature Embedding）是由Berkeley Vision and Learning Center（BVLC）开发的一款高效、开源的深度学习框架，广泛应用于计算机视觉领域...
caffe源码简单解析1
08-08
标题中的“caffe源码简单解析1”表明我们将探讨深度学习框架Caffe的源代码，而描述提到了`caffe_cpu_gemm`函数，这是Caffe中用于执行矩阵乘法的一个关键部分。标签“caffe 软件/插件”进一步确认我们关注的是Caffe这...
知识蒸馏-基于Caffe实现的知识蒸馏Layer算子实现-附项目源码-优质项目实战.zip
最新发布
06-01
本项目主要关注的是在Caffe框架中实现知识蒸馏的Layer算子。Caffe是一个流行的深度学习库，以其高效的速度和简洁的模型定义而著称。它支持卷积神经网络（CNNs）、全连接层、池化层等多种神经网络层。在Caffe中，用户...
Caffe源码解读：Layer类
小肥柴不是小废柴的博客
11-18 1191
Layer类简介 至少有一个输入，输出Blob。 部分Layer带有权值和偏置项（如：激活层没有权值项） 前向传播对输入Blob处理，得到输出Blob。反向传播对输出的diff进行处理，得到输入的diff ProtoBuffer描述 打开./caffe/src/caffe/caffe.proto文件，找到LayerParameter，查看对应的数据结构...
caffe layer
visionfans的专栏
10-26 1244
看Caffe/wiki/Development，同时对照ArgMaxLayer来看！   layer的声明要写到： l  common_layers.hpp l  data_layers.hpp l  loss_layers.hpp l  neuron_layers.hpp l  vision_layers.hpp   要实现以下函数： l  LayerSetUp l  Re
caffe-layer.hpp-layer.cpp源代码讲解
MultimediaComputingGroup_blogs
11-04 1251
1、outline Layer是所有层的父类，其中主要定义一些共有的变量，函数。 protected:   LayerParameter layer_param；           //层参数 Phase phase；                        //层的属性，Train or Test Vector > > blobs_; //用于存储层参数，如卷积层的w,b v
caffe中的layer
JH0lmes的博客
09-07 1878
layer是神经网络搭建的脚手架，理解了layer，才能盖好神经网络这座摩天大楼。 下图是一张关于layer的思维导图，在功力到达一定程度的时候才可练此功，到时一定会有不一样的收获。 1. Outline 此部分主要概述了与layer有关的方方面面。 1.1 layer.hpp 与layer相关的头文件： layer.hpp common_layers.hpp data_lay...
caffe网络配置文件中layer和layers的区别
wo4691205的博客
04-19 2112
最近使用vggface模型训练自己的人脸库，根据网上的代码把数据层加入到自己的文件中，训练时报错，大概意思是layer和layers只能使用一个。仔细看了一下，vggface的模型用的层的定义都是layers，我添加的是layer，两者只是写法不一样，实际上效果是一样的。目前我发现的不同处就是type的写法有区别。layers { type: DATA } layer{ type: "Data" }
Caffe学习(七)——layer代码文件介绍
cui841923894的博客
08-21 363
层（layer）是网络（Net）组成的基本单位，表示对此层输入数据（上层的输出）的运算，比如Convolution、Pooling、Softmax等运算。 Layer层会对输入数据（上一层的输出数据）进行对应(layer type指定运算类型)运算，然后输出结果到下一层。至少包括一个输入层（Bottom layer）或一个输出层（Top layer），部分带有参数，比如权值（Weight）和偏置...
caffe源码 Layer 详解
小小码农的博客
05-17 709
Layer层是深度网络中基础单元，了解其源码架构，利于我们编写自定义的caffe层。通过阅读源码我们可以了解到Layer层的上通下达，不仅是对输入输出明确，还要明确需要重写、覆写的部分是哪些。#ifndef CAFFE_LAYER_H_ #define CAFFE_LAYER_H_ #include &lt;algorithm&gt; #include &lt;string&gt; #inclu...
（Caffe）基本类Blob，Layer，Net（一）
热门推荐
沤江一流的专栏
04-07 1万+
本文地址：http://blog.csdn.net/mounty_fsc/article/details/51037006 Caffe中，Blob，Layer，Net，Solver是最为核心的类，以下介绍这几个类，Solver将在下一节介绍。1 Blob1.1 简介Blob是： 对待处理数据带一层封装，用于在Caffe中通信传递。 也为CPU和GPU间提供同步能力 数学上，是一个N维的C风格的存储数
"深入浅出解析caffe源码中的Blob类
通过对caffe源码中Blob类的分析，我们可以了解到Blob类是caffe框架中的基本数据结构，它被设计为一个多维数组，可以用来存储神经网络中的各种数据，包括输入数据、输出数据、权值等。Blob类定义了一系列的成员函数，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值