CAFFE源码学习笔记 - data_layer

最新推荐文章于 2020-08-23 20:09:10 发布
最新推荐文章于 2020-08-23 20:09:10 发布
阅读量147 收藏
点赞数
分类专栏： caffe 文章标签： caffe
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/sinat_22336563/article/details/69524736

一、前言

CAFFE在搭建CNN网络的时候，第一层就是数据层，所以本节梳理一下同样很庞大的DataLayer层。
先给一个网络结构：
这里写图片描述

Layer类： 层的基类;

BaseDataLayer类：数据层的基类;

BasePrefetchingDataLayer类：预取层，主要是预先读取若干批次的数据，平衡CPU与GPU带宽和GPU计算速度。从继承关系可以看出，该层是多线程系统主要发挥作用的地方。
其实多线程系统在caffe中主要就是为GPU服务，准备数据的。

BasePrefetchingDataLayer类要做的就是数据的加工了。这一部分主要完成两件事：

1、确定数据层最终的输出（可以不输出label的）
2、完成数据层预处理（通常要做一些白化数据的简单工作，比如减均值，乘系数）

 
 
  • 1
  • 2

DataLayer类：数据层，网络结构的第一层。Caffe的DataLayer的主要目标是读入两种DB的训练数据作为输入，而两种DB内存储的格式默认是一种叫Datum的数据结构。该层就是将Datum读取到blob中。

message Datum {
  optional int32 channels = 1;
  optional int32 height = 2;
  optional int32 width = 3;
  // the actual image data, in bytes
  optional bytes data = 4;
  optional int32 label = 5;
  // Optionally, the datum could also hold float data.
  repeated float float_data = 6;
  // If true data contains an encoded image that need to be decoded
  optional bool encoded = 7 [default = false];
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

其余层都是数据的存储层，主要存储的格式有：
1、HDF5格式;包括将数据从硬盘读出，将数据写入硬盘;
2、ImageDataLayer：图像文件直接读取
3、MemoryDatalayer：从内存中读取，直观感觉是速度快;
4、WindowDataLayer：从图像数据的窗口，一般是opencv相关的吧。
5、DummyDataLayer：通过Filler产生的数据。

二、base_data_layer文件

在base_data_layer.hpp和base_data_layer.cpp文件中，分别定义了三个类：BaseDataLayer，Batch，BasePrefetchingDataLayer。
1、Batch类
Batch实际就是数据和标签，其数据类型就是Blob。

template <typename Dtype>
class Batch {
 public:
  Blob<Dtype> data_, label_;
};

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

2、BaseDataLayer类
该类是datalayer的基类，其中由该类自己实现的成员函数只有两个：
a、构造函数
由于其继承了Layer类，所以首先构造基类Layer;
然后用transform_param()初始化其成员变量，为转换数据的维度或者预处理做准备。

template <typename Dtype>
BaseDataLayer<Dtype>::BaseDataLayer(const LayerParameter& param)
    : Layer<Dtype>(param),
      transform_param_(param.transform_param()) {
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

b、LayerSetUp函数
数据层的初始化，初始化时根据top的大小来确定，如果大小为1，表明只需要输出数据即可，不输出类标志。

template <typename Dtype>
void BaseDataLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,const vector<Blob<Dtype>*>& top) {
  if (top.size() == 1) {
    output_labels_ = false;
  } else {
    output_labels_ = true;
  }
  data_transformer_.reset(
      new DataTransformer<Dtype>(transform_param_, this->phase_));//初始化DataTransformer实例，进行数据的预处理
  data_transformer_->InitRand();
  // The subclasses should setup the size of bottom and top
  DataLayerSetUp(bottom, top);//实际的Layer初始化是调用DataLayerSetUp函数，对特殊的层进行初始化的。该函数是纯虚函数，继承类必须自己实现。
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

3、BasePrefetchingDataLayer 类
该类继承自InternalThread和BaseDataLayer类，所以预取操作是采用多线程的系统。

a、功能
因为GPU计算速度和带宽跟CPU都有较大的差距，所以需要在GPU在计算的时候预先取出若干批次的数据。而该类就是实现这个功能的。
b、成员变量
可以看出，在batch级别的预取操作中，使用了双阻塞队列。


vector<shared_ptr<Batch<Dtype> > > prefetch_：预先读取的若干批次数据的容器;

BlockingQueue<Batch<Dtype>*> prefetch_free_;生产者队列

BlockingQueue<Batch<Dtype>*> prefetch_full_;消费者队列

Batch<Dtype>* prefetch_current_;指向当前批次的数据的指针

Blob<Dtype> transformed_data_;需要注意的是之前的成员变量都是batch级别的，而该变量则是Blob型数据。
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
template <typename Dtype>
class BasePrefetchingDataLayer :
    public BaseDataLayer<Dtype>, public InternalThread {
 public:
  explicit BasePrefetchingDataLayer(const LayerParameter& param);
  // LayerSetUp: implements common data layer setup functionality, and calls
  // DataLayerSetUp to do special data layer setup for individual layer types.
  // This method may not be overridden.
  void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);

  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);

 protected:
  virtual void InternalThreadEntry();//开启预取线程
  virtual void load_batch(Batch<Dtype>* batch) = 0;//纯虚函数，主要是需要data_layer自己实现

  vector<shared_ptr<Batch<Dtype> > > prefetch_;//预取的若干batch
  BlockingQueue<Batch<Dtype>*> prefetch_free_;
  BlockingQueue<Batch<Dtype>*> prefetch_full_;
  Batch<Dtype>* prefetch_current_;//指向当前批次的指针

  Blob<Dtype> transformed_data_;//被修正过的数据
};

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

c、构造函数

template <typename Dtype>
BasePrefetchingDataLayer<Dtype>::BasePrefetchingDataLayer(
    const LayerParameter& param)
    : BaseDataLayer<Dtype>(param),
      prefetch_(param.data_param().prefetch()),
      prefetch_free_(), prefetch_full_(), prefetch_current_() {//默认初始化阻塞队列
  for (int i = 0; i < prefetch_.size(); ++i) {
    prefetch_[i].reset(new Batch<Dtype>());//根据预取的size初始化prefetch_
    prefetch_free_.push(prefetch_[i].get());//根据prefetch_初始化生产者的阻塞队列
  }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

d、LayerSetUp函数
初始化相关数据结构之后，开启预取线程。

template <typename Dtype>
void BasePrefetchingDataLayer<Dtype>::LayerSetUp(
    const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  BaseDataLayer<Dtype>::LayerSetUp(bottom, top);//调用父类的setup函数


  for (int i = 0; i < prefetch_.size(); ++i) {
    prefetch_[i]->data_.mutable_cpu_data();
    if (this->output_labels_) {
      prefetch_[i]->label_.mutable_cpu_data();
    }//作者解释：在开启预取线程之前，必须主动调用mutable_cpu_data或者mutable_gpu_data，防止线程同时调用两个函数。这是因为在某些GPU上不这么做会发生错误。
  }
#ifndef CPU_ONLY
  if (Caffe::mode() == Caffe::GPU) {
    for (int i = 0; i < prefetch_.size(); ++i) {
      prefetch_[i]->data_.mutable_gpu_data();
      if (this->output_labels_) {
        prefetch_[i]->label_.mutable_gpu_data();
      }
    }
  }
#endif
  DLOG(INFO) << "Initializing prefetch";
  this->data_transformer_->InitRand();//初始化随机数种子
  StartInternalThread();//开启预取线程，线程启动的工作是搬运全局资源，初始化boost::thread等。
  DLOG(INFO) << "Prefetch initialized.";
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

e、InternalThreadEntry()
在之前的internel thread模块提到，InternalThreadEntry()函数没有实现，是在继承类中由继承者实现的。

template <typename Dtype>
void BasePrefetchingDataLayer<Dtype>::InternalThreadEntry() {
#ifndef CPU_ONLY
  cudaStream_t stream;//创建流
  if (Caffe::mode() == Caffe::GPU) {
    CUDA_CHECK(cudaStreamCreateWithFlags(&stream, cudaStreamNonBlocking));
  }
#endif

  try {
    while (!must_stop()) {
      Batch<Dtype>* batch = prefetch_free_.pop();//从生产者队列中pop出一个batch的数据
      load_batch(batch);//load_batch是纯虚函数，任何继承该类的继承类都必须自己实现。
#ifndef CPU_ONLY
      if (Caffe::mode() == Caffe::GPU) {
        batch->data_.data().get()->async_gpu_push(stream);//如果是GPU模式，则是使用异步流同步向GPU推送数据，该函数在syncmem中就已经总结了。
        if (this->output_labels_) {
          batch->label_.data().get()->async_gpu_push(stream);
        }
        CUDA_CHECK(cudaStreamSynchronize(stream));
      }
#endif
      prefetch_full_.push(batch);//将batch装载进消费者队列中
    }
  } catch (boost::thread_interrupted&) {
    // Interrupted exception is expected on shutdown
  }
#ifndef CPU_ONLY
  if (Caffe::mode() == Caffe::GPU) {
    CUDA_CHECK(cudaStreamDestroy(stream));//销毁流
  }
#endif
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

f、datalayer中的foward_cpu()

template <typename Dtype>
void BasePrefetchingDataLayer<Dtype>::Forward_cpu(
    const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  if (prefetch_current_) {
    prefetch_free_.push(prefetch_current_);
  }
  prefetch_current_ = prefetch_full_.pop("Waiting for data");//从消费者队列中弹出一个batch，这中间会有条件变量进行多线程下的资源同步
  // 根据batch的形状修改top的形状
  top[0]->ReshapeLike(prefetch_current_->data_);
  top[0]->set_cpu_data(prefetch_current_->data_.mutable_cpu_data());//初始化top
  if (this->output_labels_) {
    // Reshape to loaded labels.
    top[1]->ReshapeLike(prefetch_current_->label_);
    top[1]->set_cpu_data(prefetch_current_->label_.mutable_cpu_data());
  }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

三、data_layer
该层继承自预取层，
头文件如下：

template <typename Dtype>
class DataLayer : public BasePrefetchingDataLayer<Dtype> {
 public:
  explicit DataLayer(const LayerParameter& param);
  virtual ~DataLayer();
  virtual void DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);
  // DataLayer uses DataReader instead for sharing for parallelism？
  //我看的这个版本中没有DataReader
  virtual inline bool ShareInParallel() const { return false; }//是否并行训练时共享数据
  virtual inline const char* type() const { return "Data"; }
  virtual inline int ExactNumBottomBlobs() const { return 0; }
  virtual inline int MinTopBlobs() const { return 1; }
  virtual inline int MaxTopBlobs() const { return 2; }

 protected:
  void Next();//游标移动
  bool Skip();//跳过某些数据
  virtual void load_batch(Batch<Dtype>* batch);//将图像数据从数据库中读取到batch中

//下面三个变量在之前的版本是用DataReader类表示的。现在看样子是没有了。
  shared_ptr<db::DB> db_;//数据库格式数据
  shared_ptr<db::Cursor> cursor_;//游标，配合数据库取数
  uint64_t offset_;//偏移量，在blob中offset可以算出当前图像在batch中的位置
};

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

具体实现：

template <typename Dtype>
DataLayer<Dtype>::DataLayer(const LayerParameter& param)
  : BasePrefetchingDataLayer<Dtype>(param),
    offset_() {//构造函数中的基类开启线程
  db_.reset(db::GetDB(param.data_param().backend()));//protobuf参数初始化数据库类型
  db_->Open(param.data_param().source(), db::READ);//打开数据库文件
  cursor_.reset(db_->NewCursor());//初始化游标
}

template <typename Dtype>
DataLayer<Dtype>::~DataLayer() {
  this->StopInternalThread();//析构函数是结束线程
}

template <typename Dtype>
void DataLayer<Dtype>::DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  const int batch_size = this->layer_param_.data_param().batch_size();//每批大小

  Datum datum;//表示一个图像数据
  datum.ParseFromString(cursor_->value());//从数据库中的map中根据游标读取图像文件


  vector<int> top_shape = this->data_transformer_->InferBlobShape(datum);//根据datum的形状推测top的形状
  this->transformed_data_.Reshape(top_shape);根据推测出的形状重塑
  // Reshape top[0] and prefetch_data according to the batch_size.  
  // 既然获取了数据的形状(channel,height,width)，那么这里再设置一下batch_size  
  // top_shape[0]=batch_size  
  // top_shape[1]=channel  
  // top_shape[2]=height  
  // top_shape[3]=width 
  top_shape[0] = batch_size;
  top[0]->Reshape(top_shape);
  for (int i = 0; i < this->prefetch_.size(); ++i) {
    this->prefetch_[i]->data_.Reshape(top_shape);
  }//设置预取数据的形状
  LOG_IF(INFO, Caffe::root_solver())
      << "output data size: " << top[0]->num() << ","
      << top[0]->channels() << "," << top[0]->height() << ","
      << top[0]->width();
  // label
  if (this->output_labels_) {
    vector<int> label_shape(1, batch_size);
    top[1]->Reshape(label_shape);
    for (int i = 0; i < this->prefetch_.size(); ++i) {
      this->prefetch_[i]->label_.Reshape(label_shape);
    }
  }
}

template <typename Dtype>
bool DataLayer<Dtype>::Skip() {
  int size = Caffe::solver_count();//并行训练的个数
  int rank = Caffe::solver_rank();//并行训练的序号
  bool keep = (offset_ % size) == rank ||
              // In test mode, only rank 0 runs, so avoid skipping
              this->layer_param_.phase() == TEST;
  return !keep;//跳过了哪些数据？
}

template<typename Dtype>
void DataLayer<Dtype>::Next() {
  cursor_->Next();
  if (!cursor_->valid()) {
    LOG_IF(INFO, Caffe::root_solver())
        << "Restarting data prefetching from start.";
    cursor_->SeekToFirst();//说明游标到了末尾
  }
  offset_++;//游标偏移量的移动
}

// This function is called on prefetch thread
template<typename Dtype>
void DataLayer<Dtype>::load_batch(Batch<Dtype>* batch) {//将数据库中的数据载入到batch中。
  CPUTimer batch_timer;
  batch_timer.Start();
  double read_time = 0;
  double trans_time = 0;
  CPUTimer timer;
  CHECK(batch->data_.count());
  CHECK(this->transformed_data_.count());
  const int batch_size = this->layer_param_.data_param().batch_size();

  Datum datum;//单个图像数据
  for (int item_id = 0; item_id < batch_size; ++item_id) {
    timer.Start();
    while (Skip()) {
      Next();
    }
    datum.ParseFromString(cursor_->value());//从数据库中获取的图像数据
    read_time += timer.MicroSeconds();

    if (item_id == 0) {
      //根据每个batch的第一个数据来推测形状
      //一个Blob的shape，[batch_size,channels,height,width]，后三个shape都可以由Datum推断出来。
      vector<int> top_shape = this->data_transformer_->InferBlobShape(datum);
      this->transformed_data_.Reshape(top_shape);
      top_shape[0] = batch_size;
      batch->data_.Reshape(top_shape);
    }//Transformer提供了一个由Datum堆砌成Blob的途径

    timer.Start();
    int offset = batch->data_.offset(item_id);//根据该批次内的编号设置偏移量
    //每个Datum在Blob的偏移位置必须计算出来，只要偏移offset=Blob.offset(i)即可，i 为一个Batch内的样本数据下标

//Blob具体的shape必须提前计算出来，而且必须启动SyncedMemory自动机，分配实际内存
    Dtype* top_data = batch->data_.mutable_cpu_data();
    this->transformed_data_.set_cpu_data(top_data + offset);
    this->data_transformer_->Transform(datum, &(this->transformed_data_));

    if (this->output_labels_) {
      Dtype* top_label = batch->label_.mutable_cpu_data();
      top_label[item_id] = datum.label();
    }
    trans_time += timer.MicroSeconds();
    Next();
  }
  timer.Stop();
  batch_timer.Stop();
  DLOG(INFO) << "Prefetch batch: " << batch_timer.MilliSeconds() << " ms.";
  DLOG(INFO) << "     Read time: " << read_time / 1000 << " ms.";
  DLOG(INFO) << "Transform time: " << trans_time / 1000 << " ms.";
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123

别忘了实例化该类，以及注册层

INSTANTIATE_CLASS(DataLayer);  
REGISTER_LAYER_CLASS(Data);  

 
 
  • 1
  • 2
  • 3

四、总结
在大多数解释该模块的文章中都有datareader这个模块，整个数据层就可以描述成一个两级缓冲的系统。
第一级为从数据库中读取当个的图像文件，按照batch_size
存储在一个batch中。
第二级则是以batch为单位，使用双阻塞队列将若干batch存入prefetch_容器中。
如图可以说明问题：
这里写图片描述
但是我发现现在的版本中没有了DataReader类，而是直接从数据库中读取文件了。不过大致的流程没有改变。

第一级从数据库中将Datum文件按照Blob的格式存放到batch中，根据Blob中总结的偏移量计算得到坐标就可以对号入座了。

hqtgyj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Data_layers的实现细节代码注释
03-28
http://blog.csdn.net/xizero00/article/details/50999630#t2 配套的代码注释 caffe代码阅读8: Data_layers的实现细节（各个数据读取层的实现细节） 2016.3.25-28
caffe多标签-image_data_layer
02-01
标题"caffe多标签-image_data_layer"提示我们需要扩展Caffe的`image_data_layer`，使其能够处理这样的多标签输入。 首先，要理解多标签任务的基本概念。在多标签学习中，一个样本可以属于多个类，这与二元分类（每...
CAFFE源码学习笔记之十-data_layer
sinat_22336563的博客
04-07 1485
一、前言CAFFE在搭建CNN网络的时候，第一层就是数据层，所以本节梳理一下同样很庞大的DataLayer层。 先给一个网络结构： Layer类： 层的基类;BaseDataLayer类：数据层的基类;BasePrefetchingDataLayer类：预取层，主要是预先读取若干批次的数据，平衡CPU与GPU带宽和GPU计算速度。从继承关系可以看出，该层是多线程系统主要发挥作用的地方。
Caffe框架源码剖析(3)—数据层DataLayer
Rolin的专栏
09-13 4173
Caffe网络正向传导时，首先进行的是DataLayer数据层的传导。该层从文件读取数据，加载至它的上一层卷积层。反向传导时，因为数据层不需要反传，所以它的Backward_cpu()和Backward_gpu()都是空函数。下面看一下DataLayer类图关系。
caffe data layer
MrTeq的专栏
07-11 182
https://blog.csdn.net/u011104550/article/details/51285512   ***caffe源码学习（五） data layer https://zhuanlan.zhihu.com/p/22404295   ***Caffe源码阅读——DataLayer&amp;Data Transformer...
caffe源码分析-DataLayer
常思考->有目标->重实践->善反思
10-07 1166
DataLayer作为caffe训练时的数据层（以多线程的方式读取数据加速solver的训练过程），继承自BaseDataLayer/BasePrefetchingDataLayer。 template &amp;lt;typename Dtype&amp;gt; class BaseDataLayer : public Layer&amp;lt;Dtype&amp;gt; { public: explicit Base...
caffe多标签源码_image_data_layer
02-01
"caffe多标签源码_image_data_layer"的标题表明我们关注的是对Caffe的原始代码进行修改，以便使其`image_data_layer`能够处理多标签输入，这通常在进行回归任务时会用到。`image_data_layer`是Caffe中的一个核心组件...
caffe-master_caffe_caffe的安装包_sleepei3_
10-02
**Caffe 深度学习框架安装指南** Caffe 是一个高效的开源深度学习框架，由加州大学伯克利分校的贾扬清开发。它以C++为主，同时提供了Python和Matlab接口，使得数据科学家和研究人员能够快速构建和训练神经网络模型...
caffe-fast-rcnn_RCNN_caffe_fastrcnn_
10-03
"caffe-fast-rcnn_RCNN_caffe_fastrcnn_" 这个标题暗示了我们讨论的主题是关于Caffe框架的一个实现，具体来说是Fast R-CNN（快速区域卷积网络）算法。Fast R-CNN是目标检测领域的一个重要里程碑，它在R-CNN（区域...
caffe-windows-ms.zip_Python vc_caffe matlab编译_caffe-windows-ms_p
07-15
编译caffe框架，可拓展python接口和matlab接口以及vc接口
Caffe源码精读 - 5 - Caffe Layers之data_layer(数据层)
tecsai的博客
07-29 367
Class_4 Caffe Layers之data_layer(数据层) 1. 概述 data_layer稍微有些深， 分别是Layer->BaseDataLayer->BasePrefetchingDataLayer->DataLayer。结构图如下： 2. InternalThread InternalThread实际上是封了一层boost的thread，相对理解起来比较简单。 （1）entry entry函数是一个私有函数，不对外公开。主要是为...
【caffe源码】DataLayer
mjiansun的专栏
04-25 216
转自：https://blog.csdn.net/fangjin_kl/article/details/54124397 https://blog.csdn.net/edmond999/article/details/78500896 http://www.mamicode.com/info-detail-1252644.html 待整理
caffe之Data_Layer层代码解析
ming5432ming的博客
11-06 2726
一、 caffe的数据输入层， 根据不同的输入方式有不同的层， 因为本人最早接触的是通过lmdb数据库输入数据，而lmdb对应这DataLayer层， 其实还有一个常用的就是ImageDataLayer层， 这个层 可以直接输入图片的路径， 而不需转换。     上面这张图， 反应输入层的继承关系和不同层次关系， 可见： DataLayer层 继承自BasePrefetchingDataLa
为 Caffe 添加新的 DataLayer
章华
07-25 1992
目标复现 DeepID 用 Caffe 实现人脸识别时，网络的训练的框架往往是这样的：就是说 Image List 中的数据是按对整理好的，类内 (intra class) 类间 (inter class) 数据交替排列。这样就可以直接利用 ImageDataLayer 获得一个个均匀的 Batch。现在只要对 Loss Layer 简单做一下修改，网络已经可以正常训练了，相当简单。但简单的代价也相
【caffe】Layer解读之：Date
yuanCruise
08-16 923
Layer type: Date 头文件位置：./include/caffe/layers/data_layer.hpp CPU 执行源文件位置:./src/caffe/layers/data_layer.cpp Date层的功能：读取LevelDB，LMDB，并进行一系列前处理。 layer { name: &amp;amp;amp;amp;amp;amp;quot;cifar&amp;amp;amp;amp;amp;amp;quot; type: &amp;amp;
关系性数据库 数据存储模式_使用存储库模式的数据层
weixin_26739079的博客
08-23 515
关系性数据库 数据存储模式This article contains a description of how the data layer of an Android application can be implemented using the repository pattern. The application is MoviesPreview, which is an applicat...
base_data_layer.cpp/base_data_layer.hpp代码分析
01-15 337
base_data_layer.hpp： #ifndef CAFFE_DATA_LAYERS_HPP_ #define CAFFE_DATA_LAYERS_HPP_ #include &lt;vector&gt; #include "caffe/blob.hpp" #include "caffe/data_transformer.hpp" #include "caffe/internal_...
自己写的GeneralDatabaseLayer
andy930606的博客
07-06 73
菜鸟一个 在校大二学生 奉老师旨意写了个通用数据库层 各位大哥大姐的看过的给点意见 本人实在是没什么经验 指点指点我啊 using System; using System.Collections.Generic; using System.Text; using System.Data; using System.Data.Common; using System.Co...
Caffe BaseDataLayer.cpp BasePrefetchingDataLayer.cpp DataLayer.cpp 学习
CNV_2305
01-25 2175
本文是自己在学习Caffe源码做的笔记，结合自己的理解。但是水平有限，特别是多线程编程方面，还需要继续学习。如有错误或者疑问，欢迎指正，希望不会带来误解。后续也会即使修改更新！ 先贴几张图来说明继承关系： data_layers.hpp中定义了如下模板类：BaseDataLayer, Batch, BasePrefetchingD
unrecognized arguments: checkpoints/mask_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.38__segm_mAP-0.344_20200504_231812-0ebd1859.pth
最新发布
05-23
根据错误提示信息，似乎是你在运行一个名为checkpoints/mask_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.38__segm_mAP-0.344_20200504_231812-0ebd1859.pth的文件时出现了问题。请检查一下你的命令是否正确，并确保你...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值