caffe源码学习（五） data layer

最新推荐文章于 2020-08-08 10:49:58 发布
最新推荐文章于 2020-08-08 10:49:58 发布
阅读量7.7k 收藏 6
点赞数 2
分类专栏： caffe源码学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011104550/article/details/51285512
版权

通过前面的学习，了解了protobuf，blob，cpu和gpu数据管理，基类Layer。在使用caffe时，我们首先在prototxt文件中定义数据层，可以参考官网教程。这样我们就可以通过数据层来读取和预处理我们指定格式的数据，并将其送入网络。接下来学习的目的：了解caffe是怎样实现这样的数据层的，对于自己的特殊数据能够写出自己的数据层。

参考官网列出的各类继承关系，逐一学习它们的作用。

1.源码
根据继承关系，首先来读BaseDataLayer类的源码。

base_data_layer.hpp

#ifndef CAFFE_DATA_LAYERS_HPP_
#define CAFFE_DATA_LAYERS_HPP_

#include <vector>

#include "caffe/blob.hpp"
// DataTransformer类实现了一些常用的数据预处理操作，如尺度变换，减均值，镜像变换等
#include "caffe/data_transformer.hpp" 
// 涉及多线程
#include "caffe/internal_thread.hpp"
#include "caffe/layer.hpp"
#include "caffe/proto/caffe.pb.h"
// 与多线程有关
#include "caffe/util/blocking_queue.hpp"

namespace caffe {

/**
 * @brief Provides base for data layers that feed blobs to the Net.
 *
 * TODO(dox): thorough documentation for Forward and proto params.
 */
 // 这个类是data layers将blobs送入网络的基础
template <typename Dtype>
class BaseDataLayer : public Layer<Dtype> {
 public:
  // 构造函数，参数是在caffe.proto中定义的LayerParameter类的引用
  explicit BaseDataLayer(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 except by the BasePrefetchingDataLayer.
  // 虚函数，实现了一般data layer的设置功能，并调用DataLayerSetUp来完成具体data layer的设置，
  // 该方法除了BasePrefetchingDataLayer可以不被重写。
  virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);
  // Data layers should be shared by multiple solvers in parallel
  // 数据层应该被分享
  virtual inline bool ShareInParallel() const { return true; }
  // 具体的data layer应该重写这个函数来完成特定层的设置
  virtual void DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {}
  // Data layers have no bottoms, so reshaping is trivial.
  // data layer没有bottoms，所以reshaping是不必要的
  virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {}

  // 由于这也是个基类，具体实现留给其子类
  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) {}

 protected:
  // 在caffe.proto中定义的参数类
  TransformationParameter transform_param_;
  // DataTransformer类的指针
  shared_ptr<DataTransformer<Dtype> > data_transformer_;
  // 是否有labels
  bool output_labels_;
};

// Batch类，类里面是两个Blob类的变量data_和label_
template <typename Dtype>
class Batch {
 public:
  Blob<Dtype> data_, label_;
};

//BasePrefetchingDataLayer类，继承了BaseDataLayer和InternalThread
template <typename Dtype>
class BasePrefetchingDataLayer :
    public BaseDataLayer<Dtype>, public InternalThread {
 public:
 // 构造函数，参数是在caffe.proto中定义的LayerParameter类的引用
  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.
  // 虚函数，实现了一般data layer的设置功能，并调用DataLayerSetUp来完成具体data layer的设置，
  // 该方法可以不被重写。
  void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);

  // Forward_cpu和Forward_gpu
  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);

  // Prefetches batches (asynchronously if to GPU memory)
  // 提前获取batch的数量
  static const int PREFETCH_COUNT = 3;

 protected:
  // 有关多线程
  virtual void InternalThreadEntry();
  // 纯虚函数，load batch，参数是Batch类指针
  virtual void load_batch(Batch<Dtype>* batch) = 0;

  // 成员变量，Batch类数组
  Batch<Dtype> prefetch_[PREFETCH_COUNT];
  // 有关多线程
  BlockingQueue<Batch<Dtype>*> prefetch_free_;
  BlockingQueue<Batch<Dtype>*> prefetch_full_;

  // 转换过的Blob数据
  Blob<Dtype> transformed_data_;
};

}  // namespace caffe

#endif  // CAFFE_DATA_LAYERS_HPP_

base_data_layer.cpp

#include <boost/thread.hpp>
#include <vector>

#include "caffe/blob.hpp"
#include "caffe/data_transformer.hpp"
#include "caffe/internal_thread.hpp"
#include "caffe/layer.hpp"
#include "caffe/layers/base_data_layer.hpp"
#include "caffe/proto/caffe.pb.h"
#include "caffe/util/blocking_queue.hpp"

namespace caffe {

// 构造函数初始化，先用LayerParameter& param初始化父类Layer，
// 再用param.transform_param()初始化transform_param_
// 在caffe.proto中可以看到LayerParameter中的成员中有TransformationParameter
template <typename Dtype>
BaseDataLayer<Dtype>::BaseDataLayer(const LayerParameter& param)
    : Layer<Dtype>(param),
      transform_param_(param.transform_param()) {
}

// 根据层中的bottom和top来设置层
template <typename Dtype>
void BaseDataLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  // 获取是否有label
  if (top.size() == 1) {
    output_labels_ = false;
  } else {
    output_labels_ = true;
  }
  // 新建DataTransformer类的shared_ptr指针，
  // 用来预处理数据
  data_transformer_.reset(
      new DataTransformer<Dtype>(transform_param_, this->phase_));
  data_transformer_->InitRand();
  // The subclasses should setup the size of bottom and top
  // 子类应该设置bottom和top的size
  DataLayerSetUp(bottom, top);
}

// BasePrefetchingDataLayer构造函数，
// 应该是初始化PREFETCH_COUNT个线程
template <typename Dtype>
BasePrefetchingDataLayer<Dtype>::BasePrefetchingDataLayer(
    const LayerParameter& param)
    : BaseDataLayer<Dtype>(param),
      prefetch_free_(), prefetch_full_() {
  for (int i = 0; i < PREFETCH_COUNT; ++i) {
    prefetch_free_.push(&prefetch_[i]);
  }
}

template <typename Dtype>
void BasePrefetchingDataLayer<Dtype>::LayerSetUp(
    const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  // 先调用父类BaseDataLayer的LayerSetUp
  BaseDataLayer<Dtype>::LayerSetUp(bottom, top);
  // Before starting the prefetch thread, we make cpu_data and gpu_data
  // calls so that the prefetch thread does not accidentally make simultaneous
  // cudaMalloc calls when the main thread is running. In some GPUs this
  // seems to cause failures if we do not so.
  // 在开启prefetch线程之前，调用cpu_data和gpu_data，
  // 这样主线程正在运行时，prefetch线程避免同时调用cudaMalloc，
  // 这样做避免了某些gpu上出现错误
  for (int i = 0; i < PREFETCH_COUNT; ++i) {
    prefetch_[i].data_.mutable_cpu_data();
    if (this->output_labels_) {
      prefetch_[i].label_.mutable_cpu_data();
    }
  }
#ifndef CPU_ONLY
  if (Caffe::mode() == Caffe::GPU) {
    for (int i = 0; i < PREFETCH_COUNT; ++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();
  DLOG(INFO) << "Prefetch initialized.";
}

// 如果有空闲线程，让该线程load data
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();
      load_batch(batch);
#ifndef CPU_ONLY
      if (Caffe::mode() == Caffe::GPU) {
        batch->data_.data().get()->async_gpu_push(stream);
        CUDA_CHECK(cudaStreamSynchronize(stream));
      }
#endif
      prefetch_full_.push(batch);
    }
  } catch (boost::thread_interrupted&) {
    // Interrupted exception is expected on shutdown
  }
#ifndef CPU_ONLY
  if (Caffe::mode() == Caffe::GPU) {
    CUDA_CHECK(cudaStreamDestroy(stream));
  }
#endif
}

// 将预处理过的batch，送到top
template <typename Dtype>
void BasePrefetchingDataLayer<Dtype>::Forward_cpu(
    const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  Batch<Dtype>* batch = prefetch_full_.pop("Data layer prefetch queue empty");
  // Reshape to loaded data.
  top[0]->ReshapeLike(batch->data_);
  // Copy the data
  caffe_copy(batch->data_.count(), batch->data_.cpu_data(),
             top[0]->mutable_cpu_data());
  DLOG(INFO) << "Prefetch copied";
  if (this->output_labels_) {
    // Reshape to loaded labels.
    top[1]->ReshapeLike(batch->label_);
    // Copy the labels.
    caffe_copy(batch->label_.count(), batch->label_.cpu_data(),
        top[1]->mutable_cpu_data());
  }

  prefetch_free_.push(batch);
}

#ifdef CPU_ONLY
STUB_GPU_FORWARD(BasePrefetchingDataLayer, Forward);
#endif

INSTANTIATE_CLASS(BaseDataLayer);
INSTANTIATE_CLASS(BasePrefetchingDataLayer);

}  // namespace caffe

记下来是DataLayer类

data_layer.hpp

#ifndef CAFFE_DATA_LAYER_HPP_
#define CAFFE_DATA_LAYER_HPP_

#include <vector>

#include "caffe/blob.hpp"
#include "caffe/data_reader.hpp"
#include "caffe/data_transformer.hpp"
#include "caffe/internal_thread.hpp"
#include "caffe/layer.hpp"
#include "caffe/layers/base_data_layer.hpp"
#include "caffe/proto/caffe.pb.h"
#include "caffe/util/db.hpp"

namespace caffe {

// 继承了BasePrefetchingDataLayer
template <typename Dtype>
class DataLayer : public BasePrefetchingDataLayer<Dtype> {
 public:
  // 构造函数
  explicit DataLayer(const LayerParameter& param);
  // 析构函数
  virtual ~DataLayer();
  // setup函数
  virtual void DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);
  // DataLayer uses DataReader instead for sharing for parallelism
  // DataLayer类不用共享而是用DataReader来实现并行
  virtual inline bool ShareInParallel() const { return false; }
  // 返回层的类型
  virtual inline const char* type() const { return "Data"; }
  // 返回bottom blobs的数量为0
  virtual inline int ExactNumBottomBlobs() const { return 0; }
  // 返回最小top blobs的数量为1
  virtual inline int MinTopBlobs() const { return 1; }
  // 返回最大top blobs的数量为2
  virtual inline int MaxTopBlobs() const { return 2; }

 protected:
  // load batch
  virtual void load_batch(Batch<Dtype>* batch);

  // 读数据DataReader类
  DataReader reader_;
};

}  // namespace caffe

#endif  // CAFFE_DATA_LAYER_HPP_

data_layer.cpp

#ifdef USE_OPENCV
#include <opencv2/core/core.hpp>
#endif  // USE_OPENCV
#include <stdint.h>

#include <vector>

#include "caffe/data_transformer.hpp"
#include "caffe/layers/data_layer.hpp"
#include "caffe/util/benchmark.hpp"

namespace caffe {

// 用LayerParameter& param初始化DataReader reader_，LayerParameter中有一个optional DataParameter data_param = 107;
// 所以DataReader类需要DataParameter信息来读数据的
// DataReader为读数据的类
template <typename Dtype>
DataLayer<Dtype>::DataLayer(const LayerParameter& param)
  : BasePrefetchingDataLayer<Dtype>(param),
    reader_(param) {
}

template <typename Dtype>
DataLayer<Dtype>::~DataLayer() {
  this->StopInternalThread();
}

// 在DataLayer类中实现了DataLayerSetUp来完成特定的设置
// 如前面所述主要完成top blobs的shape size设定
template <typename Dtype>
void DataLayer<Dtype>::DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top) {
  // 获取batchsize
  const int batch_size = this->layer_param_.data_param().batch_size();
  // Read a data point, and use it to initialize the top blob.
  // 获取读的数据指针，然后用它初始化top blob
  // Datum是在caffe.prototxt中定义的，DataReader用LayerParameter初始化后（内含有DataParameter），
  // 可以获取要读的数据信息，并返回Datum，后面在根据Datum来reshape
  Datum& datum = *(reader_.full().peek());

  // Use data_transformer to infer the expected blob shape from datum.
  // 从datum中推断出top blob shape
  vector<int> top_shape = this->data_transformer_->InferBlobShape(datum);
  // tansformed_data_ reshape成top_shape
  this->transformed_data_.Reshape(top_shape);
  // Reshape top[0] and prefetch_data according to the batch_size.
  // 更新top_shape中的batchsize，之前的到的vector<int> top_shape = this->data_transformer_->InferBlobShape(datum)
  // 应该是1，这样得到一个batch的top blob shape，然将top[0]即存数据的blob reshape
  top_shape[0] = batch_size;
  top[0]->Reshape(top_shape);
  // reshape每个线程的prefetch data
  for (int i = 0; i < this->PREFETCH_COUNT; ++i) {
    this->prefetch_[i].data_.Reshape(top_shape);
  }
  LOG(INFO) << "output data size: " << top[0]->num() << ","
      << top[0]->channels() << "," << top[0]->height() << ","
      << top[0]->width();
  // label
  // 如果存在labels，reshape
  if (this->output_labels_) {
    vector<int> label_shape(1, batch_size);
    top[1]->Reshape(label_shape);
    for (int i = 0; i < this->PREFETCH_COUNT; ++i) {
      this->prefetch_[i].label_.Reshape(label_shape);
    }
  }
}

// This function is called on prefetch thread
// load_batch由prefetch thread调用
template<typename Dtype>
void DataLayer<Dtype>::load_batch(Batch<Dtype>* 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());

  // Reshape according to the first datum of each batch
  // on single input batches allows for inputs of varying dimension.
  // 不太理解。。。
  // 根据每个batch的第一个基准（datum）来reshape
  // 不同batch允许不同的输入维数？？？
  const int batch_size = this->layer_param_.data_param().batch_size();
  Datum& datum = *(reader_.full().peek());
  // Use data_transformer to infer the expected blob shape from datum.
  // 用data_transformer从datum中推断blob shape
  vector<int> top_shape = this->data_transformer_->InferBlobShape(datum);
  // reshape transformed_data_
  this->transformed_data_.Reshape(top_shape);
  // Reshape batch according to the batch_size.
  // 与上面类似，reshape batch
  top_shape[0] = batch_size;
  batch->data_.Reshape(top_shape);

  // 得到batch中blobs的mutable指针top_data和top_label
  Dtype* top_data = batch->data_.mutable_cpu_data();
  Dtype* top_label = NULL;  // suppress warnings about uninitialized variables

  if (this->output_labels_) {
    top_label = batch->label_.mutable_cpu_data();
  }
  // 下面load并处理一个batch数据
  for (int item_id = 0; item_id < batch_size; ++item_id) {
    timer.Start();
    // get a datum
    Datum& datum = *(reader_.full().pop("Waiting for data"));
    read_time += timer.MicroSeconds();
    timer.Start();
    // Apply data transformations (mirror, scale, crop...)
    int offset = batch->data_.offset(item_id);
    this->transformed_data_.set_cpu_data(top_data + offset);
    this->data_transformer_->Transform(datum, &(this->transformed_data_));
    // Copy label.
    if (this->output_labels_) {
      top_label[item_id] = datum.label();
    }
    trans_time += timer.MicroSeconds();

    reader_.free().push(const_cast<Datum*>(&datum));
  }
  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.";
}

INSTANTIATE_CLASS(DataLayer);
REGISTER_LAYER_CLASS(Data);

}  // namespace caffe

2.总结

到这里，已经基本了解caffe是怎样通过DataLayer来获取数据的了，接下来通过有关数据获取类的继承关系图简答总结一下。

inheritance relationship among data classes

目前，我们已经读完了图中最左边分支上的四类，其中，Layer是所有层的基类；BaseDataLayer继承了Layer的特性，又定义了有关获取数据的新的特性，是获取各种具体类型数据的基类；BasePrefetchingDataLayer是被多线程调用，并行的从磁盘中读数据，它又被具体类型的数据层所继承；DataLayer类获取的时lmdb或leveldb类型的数据，从caffe.proto定义中可以得知。那么剩下的类：MemoryDataLayer是从内存中获取数据，ImageDataLayer是从图像文件中获取数据，WindowDataLayer是在图像文件上滑窗获取数据。这样，后面需要时在去看剩下有关数据获取的几个类。

个人理解，如有错误，请指正。

牛闯
关注
专栏目录
caffe源码分析-layer
常思考->有目标->重实践->善反思
10-07 1403
本文主要分析caffe layer层，主要内容如下： 从整体上说明下caffe的layer层的类别，以及作用 通过proto定义与类Layer简要说明下Layer的核心成员变量; Layer类的核心成员函数 1. 类Layer overview caffe中的Layer主要分为如下几个模块： 输入层Data Layers Data Layers定义了caffe中网络的输入，依...
caffe多标签源码_image_data_layer
02-01
"caffe多标签源码_image_data_layer"的标题表明我们关注的是对Caffe的原始代码进行修改，以便使其`image_data_layer`能够处理多标签输入，这通常在进行回归任务时会用到。`image_data_layer`是Caffe中的一个核心组件...
Caffe框架源码剖析(3)—数据层DataLayer
Rolin的专栏
09-13 4209
Caffe网络正向传导时，首先进行的是DataLayer数据层的传导。该层从文件读取数据，加载至它的上一层卷积层。反向传导时，因为数据层不需要反传，所以它的Backward_cpu()和Backward_gpu()都是空函数。下面看一下DataLayer类图关系。
caffe data layer
MrTeq的专栏
07-11 188
https://blog.csdn.net/u011104550/article/details/51285512   ***caffe源码学习（五） data layer https://zhuanlan.zhihu.com/p/22404295   ***Caffe源码阅读——DataLayer&amp;Data Transformer...
caffe源码分析--data_layer.cpp
热门推荐
linger(心怀梦想，活在当下，知乎ID：linger liu)
05-31 1万+
// Copyright 2013 Yangqing Jia #include #include #include #include #include #include "caffe/layer.hpp" #include "caffe/util/io.hpp" #include "caffe/vision_layers.hpp" using std::string; name
【caffe源码】DataLayer
mjiansun的专栏
04-25 225
转自：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源码(８)－video_data_layer.cpp
冬后晚晴的博客
01-30 1824
video_data_layer层是在caffe里面新添加的一个DataLayer,该层允许caffe的输入data层数据为视频。由于视频是由一帧一帧的图像组成，因此该层的定义主要参考image_data_layer层。 同样遵循：VideoData层参数定义－>VideoData数据层声明－>VideoData数据层实现的顺序，介绍如下： 一.caffe.proto层参数定义 层参数定
caffe 源码解析部分
07-06
**深度学习框架Caffe源码解析** Caffe（Convolutional Architecture for Fast Feature Embedding）是由Berkeley Vision and Learning Center（BVLC）开发的一款高效、开源的深度学习框架，广泛应用于计算机视觉领域...
caffe源码——深度学习框架
06-27
数据层是Caffe处理输入数据的关键部分，包括如ImageDataLayer、HDF5DataLayer等，它们负责加载和预处理数据。源码中的这些层类定义了如何从硬盘读取数据，进行预处理（如归一化、随机扰动等）并送入网络进行计算。 ...
Caffe源码深入解析
10-26
### Caffe源码深入解析 #### 一、概述 ##### 1.1 Caffe的优缺点 **优点：** - **高效性能：**Caffe基于Google Protocol Buffer数据标准设计，这种标准化的数据处理方式大大提升了其运行效率。尤其在深度学习模型...
为 Caffe 添加新的 DataLayer
章华
07-25 2000
目标复现 DeepID 用 Caffe 实现人脸识别时，网络的训练的框架往往是这样的：就是说 Image List 中的数据是按对整理好的，类内 (intra class) 类间 (inter class) 数据交替排列。这样就可以直接利用 ImageDataLayer 获得一个个均匀的 Batch。现在只要对 Loss Layer 简单做一下修改，网络已经可以正常训练了，相当简单。但简单的代价也相
caffe学习-代码阅读DataLayer
Meihuashan_HUST的博客
05-05 432
以下摘录自《深度学习轻松学》冯超 为 了能够尽可能地提高训练速度， DataLayer 采用了异步准备数据的形式，数据 读人的工作和模型训练的工作在各自的线程中进行，相互独立并不依赖 。 当模型 需要数据时，只需要将数据复制到指定的内存中即可。 从lmdb数据库中，Cusror逐一获取数据，然后构成batch，经过transform变换后，是实际训练用的data. 最上面的虚线框是DataRea...
caffe之Data_Layer层代码解析
ming5432ming的博客
11-06 2736
一、 caffe的数据输入层， 根据不同的输入方式有不同的层， 因为本人最早接触的是通过lmdb数据库输入数据，而lmdb对应这DataLayer层， 其实还有一个常用的就是ImageDataLayer层， 这个层 可以直接输入图片的路径， 而不需转换。     上面这张图， 反应输入层的继承关系和不同层次关系， 可见： DataLayer层 继承自BasePrefetchingDataLa
Caffe(学习1)--Data layer 详解
起点的专刊
05-25 2426
在开始Caffe的学习之前，希望你已经准备好了caffe环境，并且学习了Pytorch系列。CNN对我们来说不再是一个黑匣子，我们可以用自己的数据训练一个diy模型，但在实际生产中考虑到嵌入式应用和测试需要，通常将pth模型转成caffe.model进行集成，接下来我会通过Pytorch和Caffe的对比，来介绍Caffe的细节。 在Pytorch中我们可以定义一个自己的类...
caffe 添加DataLayer
龙猫的博客
08-08 1282
Caffe DataLayer类型层添加说明及数据流说明： 一、数据流  Layer->DataLayer->BaseDataLayer->BasePrefectingDataLayer->ImageDimPreFecfchingDataLayer->你的类 其中： Layer层：（layer.hpp） 主要定义了之后层的各种虚函数，包括：LayerSetUp、Res
Caffe: Data layer prefetch queue empty
PlusTang
02-14 1万+
我是利用ImageDataLayer直接从图片读入进行训练，开始训练时连续出现这个，虽然不影响训练，好奇就查了一下问题描述:训练过程中出现blocking_queue.cpp:50] Data layer prefetch queue empty**原因:**CPU数据读入慢于GPU计算，导致GPU处于空闲，使得计算速度下降，迭代时间间隔扩大。nvidia-smi显示为：GPU功率不断大幅度变化，G
SSD出现Caffe: Data layer prefetch queue empty的问题？
CPFelix的博客
08-08 309
参考： https://www.zhihu.com/question/263929129 已解决.20200808
caffe代码阅读8: Data_layers的实现细节（各个数据读取层的实现细节） 2016.3.25-28
一亩半分地
03-28 1万+
Caffe中Layer类是所有神经网络层的基类，BaseDataLayer继承自该类，BasePrefetchingDataLayer继承自BaseDataLayer，DataLayer继承自BasePrefetchingDataLayer。 有了上述几个基础的类之后，其他的类都是从这几个类进行派生。 比如DummyDataLayer，HDF5Layer和HDF5OutputLayer都是直接继承自Layer。 MemoryDataLayer则是继承自BaseDataLayer 凡是涉及到直接读取数据文
Caffe深度学习框架源码剖析：Blob与架构解析
"本文主要解析Caffe深度学习框架的源码，包括其核心组件：Blob、Solver、Net、Layer和Proto。Caffe架构中的Solver管理网络训练，包含训练和测试网络，而网络由多个Layer组成，Blob作为数据存储单元。Proto基于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值