caffe之Data_Layer层代码解析
一、 caffe的数据输入层， 根据不同的输入方式有不同的层， 因为本人最早接触的是通过lmdb数据库输入数据，而lmdb对应这DataLayer层， 其实还有一个常用的就是ImageDataLayer层， 这个层 可以直接输入图片的路径， 而不需转换。
上面这张图， 反应输入层的继承关系和不同层次关系， 可见： DataLayer层 继承自BasePrefetchingDataLayer层，继承BaseDataLayer层，继承Layer层。
DataLayer.hpp： 其实这个层只做了一件事情， 那就是reshape之后，从lmdb数据库中读取数据， 然后将读到的数据指针输出给top， 如果有标签，也会输出标签。
ImageDataLayer.cpp： 这个层也只做了一件事情， 那就是reshape之后，从文件列表中读取数据， 然后将读到的数据指针输出给top， 如果有标签，也会输出标签
如果只是使用， 那么参考我的另一篇微博 http://blog.csdn.net/ming5432ming/article/details/78458916 ， 没有必要往下看。
如想了解下具体实现，请往下走。
二、 下面是DataLayer.hpp
先说结论： 其实这个层只做了一件事情， 那就是reshape之后，从lmdb数据库中读取数据， 然后将读到的数据指针输出给top， 如果有标签，也会输出标签。
#ifndef CAFFE_DATA_LAYER_HPP_
#define CAFFE_DATA_LAYER_HPP_
#include
#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/db.hpp"
namespace caffe {
template
class DataLayer : public BasePrefetchingDataLayer {
public:
explicit DataLayer(const LayerParameter& param);
virtual ~DataLayer();
virtual void DataLayerSetUp(const vector*>& bottom,
const vector*>& top);
virtual inline const char* type() const { return "Data"; } //名字是Data， 这个对应这prototxt文件中的type变量。
virtual inline int ExactNumBottomBlobs() const { return 0; } //data层没有输入bottom层
virtual inline int MinTopBlobs() const { return 1; }
virtual inline int MaxTopBlobs() const { return 2; }
protected:
void Next();
bool Skip();
virtual void load_batch(Batch* batch);
shared_ptr db_; //lmdb数据库操作的指针。
shared_ptr cursor_;
uint64_t offset_;
};
} // namespace caffe
#endif // CAFFE_DATA_LAYER_HPP_ 下面是DataLayer.cpp
#ifdef USE_OPENCV
#include
#endif // USE_OPENCV
#include
#include
#include "caffe/data_transformer.hpp"
#include "caffe/layers/data_layer.hpp"
#include "caffe/util/benchmark.hpp"
namespace caffe {
template
DataLayer::DataLayer(const LayerParameter& param) // 打开数据库
: BasePrefetchingDataLayer(param),
offset_() {
db_.reset(db::GetDB(param.data_param().backend()));
db_->Open(param.data_param().source(), db::READ);
cursor_.reset(db_->NewCursor());
}
template
DataLayer::~DataLayer() {
this->StopInternalThread();
}
template
void DataLayer::DataLayerSetUp(const vector*>& bottom,
const vector*>& top) {
const int batch_size = this->layer_param_.data_param().batch_size(); //从配置文件中读取批处理大小；
// Read a data point, and use it to initialize the top blob.
Datum datum;
datum.ParseFromString(cursor_->value()); //读取一个数据，并存放在datum中， datum是在caffe.proto中定义的数据结构。 里面包括channel、height、和width
// Use data_transformer to infer the expected blob shape from datum.
vector top_shape = this->data_transformer_->InferBlobShape(datum); //用读到的数据初始化top_shape结构。
this->transformed_data_.Reshape(top_shape);
// Reshape top[0] and prefetch_data according to the batch_size.
top_shape[0] = batch_size; //因为datum中没有批处理的信息，所以在这补充。
top[0]->Reshape(top_shape);
for (int i = 0; i < this->prefetch_.size(); ++i) {
this->prefetch_[i]->data_.Reshape(top_shape); //reshape每一个险种中的prefetch_
}
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 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
bool DataLayer::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
void DataLayer::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
void DataLayer::load_batch(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) {
// Reshape according to the first datum of each batch
// on single input batches allows for inputs of varying dimension.
// Use data_transformer to infer the expected blob shape from datum.
vector top_shape = this->data_transformer_->InferBlobShape(datum);
this->transformed_data_.Reshape(top_shape);
// Reshape batch according to the batch_size.
top_shape[0] = batch_size;
batch->data_.Reshape(top_shape); //批处理batch的 reshape
}
// Apply data transformations (mirror, scale, crop...)
timer.Start();
int offset = batch->data_.offset(item_id); //在一个批次中的偏移量；
Dtype* top_data = batch->data_.mutable_cpu_data(); //读取cpu的指针，并赋值给top_data；
this->transformed_data_.set_cpu_data(top_data + offset);
this->data_transformer_->Transform(datum, &(this->transformed_data_)); //设置cpu的data指针。
// Copy label.
if (this->output_labels_) { //设置label数据。
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.";
}
INSTANTIATE_CLASS(DataLayer);
REGISTER_LAYER_CLASS(Data);
} // namespace caffe
总结： 其实这个层只做了一件事情， 那就是reshape之后，从数据库中读取数据， 然后将读到的数据指针输出给top。
三、 既然到了这，顺便说一下ImageDataLayer层。
下面是ImageDataLayer.hpp
#ifndef CAFFE_IMAGE_DATA_LAYER_HPP_
#define CAFFE_IMAGE_DATA_LAYER_HPP_
#include
#include
#include
#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"
namespace caffe {
/**
* @brief Provides data to the Net from image files.
*
* TODO(dox): thorough documentation for Forward and proto params.
*/
template
class ImageDataLayer : public BasePrefetchingDataLayer {
public:
explicit ImageDataLayer(const LayerParameter& param)
: BasePrefetchingDataLayer(param) {}
virtual ~ImageDataLayer();
virtual void DataLayerSetUp(const vector*>& bottom,
const vector*>& top);
virtual inline const char* type() const { return "ImageData"; } //这是prototxt中 的type
virtual inline int ExactNumBottomBlobs() const { return 0; }
virtual inline int ExactNumTopBlobs() const { return 2; }
protected:
shared_ptr prefetch_rng_;
virtual void ShuffleImages();
virtual void load_batch(Batch* batch);
vector > lines_;
int lines_id_;
};
} // namespace caffe
#endif // CAFFE_IMAGE_DATA_LAYER_HPP_ 下面是ImageDataLayer.cpp
#ifdef USE_OPENCV
#include
#include // NOLINT(readability/streams)
#include // NOLINT(readability/streams)
#include
#include
#include
#include "caffe/data_transformer.hpp"
#include "caffe/layers/base_data_layer.hpp"
#include "caffe/layers/image_data_layer.hpp"
#include "caffe/util/benchmark.hpp"
#include "caffe/util/io.hpp"
#include "caffe/util/math_functions.hpp"
#include "caffe/util/rng.hpp"
namespace caffe {
template
ImageDataLayer::~ImageDataLayer() {
this->StopInternalThread();
}
template
void ImageDataLayer::DataLayerSetUp(const vector*>& bottom,
const vector*>& top) {
const int new_height = this->layer_param_.image_data_param().new_height(); //从网络文件中读取参数；
const int new_width = this->layer_param_.image_data_param().new_width();
const bool is_color = this->layer_param_.image_data_param().is_color();
string root_folder = this->layer_param_.image_data_param().root_folder();
CHECK((new_height == 0 && new_width == 0) ||
(new_height > 0 && new_width > 0)) << "Current implementation requires "
"new_height and new_width to be set at the same time.";
// Read the file with filenames and labels
const string& source = this->layer_param_.image_data_param().source();
LOG(INFO) << "Opening file " << source;
std::ifstream infile(source.c_str()); // 打开网络文件中的文件列表。
string line;
size_t pos;
int label;
while (std::getline(infile, line)) {
pos = line.find_last_of(' '); //图片路径与标签用空格隔开
label = atoi(line.substr(pos + 1).c_str());
lines_.push_back(std::make_pair(line.substr(0, pos), label)); //读出一行的图片路径和标签
}
CHECK(!lines_.empty()) << "File is empty";
if (this->layer_param_.image_data_param().shuffle()) {
// randomly shuffle data
LOG(INFO) << "Shuffling data";
const unsigned int prefetch_rng_seed = caffe_rng_rand();
prefetch_rng_.reset(new Caffe::RNG(prefetch_rng_seed));
ShuffleImages();
} else {
if (this->phase_ == TRAIN && Caffe::solver_rank() > 0 &&
this->layer_param_.image_data_param().rand_skip() == 0) {
LOG(WARNING) << "Shuffling or skipping recommended for multi-GPU";
}
}
LOG(INFO) << "A total of " << lines_.size() << " images.";
lines_id_ = 0;
// Check if we would need to randomly skip a few data points
if (this->layer_param_.image_data_param().rand_skip()) {
unsigned int skip = caffe_rng_rand() %
this->layer_param_.image_data_param().rand_skip();
LOG(INFO) << "Skipping first " << skip << " data points.";
CHECK_GT(lines_.size(), skip) << "Not enough points to skip";
lines_id_ = skip;
}
// Read an image, and use it to initialize the top blob.
cv::Mat cv_img = ReadImageToCVMat(root_folder + lines_[lines_id_].first, //读取图片数据
new_height, new_width, is_color);
CHECK(cv_img.data) << "Could not load " << lines_[lines_id_].first;
// Use data_transformer to infer the expected blob shape from a cv_image.
vector top_shape = this->data_transformer_->InferBlobShape(cv_img);
this->transformed_data_.Reshape(top_shape);
// Reshape prefetch_data and top[0] according to the batch_size.
const int batch_size = this->layer_param_.image_data_param().batch_size();
CHECK_GT(batch_size, 0) << "Positive batch size required";
top_shape[0] = batch_size;
for (int i = 0; i < this->prefetch_.size(); ++i) {
this->prefetch_[i]->data_.Reshape(top_shape); //reshape prefetch参数的结构
}
top[0]->Reshape(top_shape);
LOG(INFO) << "output data size: " << top[0]->num() << ","
<< top[0]->channels() << "," << top[0]->height() << ","
<< top[0]->width();
// label
vector label_shape(1, batch_size); //标签的reshape
top[1]->Reshape(label_shape);
for (int i = 0; i < this->prefetch_.size(); ++i) {
this->prefetch_[i]->label_.Reshape(label_shape);
}
}
template
void ImageDataLayer::ShuffleImages() {
caffe::rng_t* prefetch_rng =
static_cast(prefetch_rng_->generator());
shuffle(lines_.begin(), lines_.end(), prefetch_rng);
}
// This function is called on prefetch thread
template
void ImageDataLayer::load_batch(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());
ImageDataParameter image_data_param = this->layer_param_.image_data_param();
const int batch_size = image_data_param.batch_size();
const int new_height = image_data_param.new_height();
const int new_width = image_data_param.new_width();
const bool is_color = image_data_param.is_color();
string root_folder = image_data_param.root_folder();
// Reshape according to the first image of each batch
// on single input batches allows for inputs of varying dimension.
cv::Mat cv_img = ReadImageToCVMat(root_folder + lines_[lines_id_].first,
new_height, new_width, is_color);
CHECK(cv_img.data) << "Could not load " << lines_[lines_id_].first;
// Use data_transformer to infer the expected blob shape from a cv_img.
vector top_shape = this->data_transformer_->InferBlobShape(cv_img);
this->transformed_data_.Reshape(top_shape);
// Reshape batch according to the batch_size.
top_shape[0] = batch_size;
batch->data_.Reshape(top_shape);
Dtype* prefetch_data = batch->data_.mutable_cpu_data();
Dtype* prefetch_label = batch->label_.mutable_cpu_data();
// datum scales
const int lines_size = lines_.size();
for (int item_id = 0; item_id < batch_size; ++item_id) {
// get a blob
timer.Start();
CHECK_GT(lines_size, lines_id_);
cv::Mat cv_img = ReadImageToCVMat(root_folder + lines_[lines_id_].first,
new_height, new_width, is_color);
CHECK(cv_img.data) << "Could not load " << lines_[lines_id_].first;
read_time += timer.MicroSeconds();
timer.Start();
// Apply transformations (mirror, crop...) to the image
int offset = batch->data_.offset(item_id);
this->transformed_data_.set_cpu_data(prefetch_data + offset);
this->data_transformer_->Transform(cv_img, &(this->transformed_data_));
trans_time += timer.MicroSeconds();
prefetch_label[item_id] = lines_[lines_id_].second;
// go to the next iter
lines_id_++;
if (lines_id_ >= lines_size) {
// We have reached the end. Restart from the first.
DLOG(INFO) << "Restarting data prefetching from start.";
lines_id_ = 0;
if (this->layer_param_.image_data_param().shuffle()) {
ShuffleImages();
}
}
}
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(ImageDataLayer);
REGISTER_LAYER_CLASS(ImageData);
} // namespace caffe
#endif // USE_OPENCV 总结： 会发现这个cpp的机构和Data_layer.cpp是类似的， 作用就是从文件列表中读取文件，并送给top结构。