}
}
+ void TestReshape(DataParameter_DB backend) {
+ const int num_inputs = 5;
+ // Save data of varying shapes.
+ LOG(INFO) << "Using temporary dataset " << *filename_;
+ scoped_ptr<db::DB> db(db::GetDB(backend));
+ db->Open(*filename_, db::NEW);
+ scoped_ptr<db::Transaction> txn(db->NewTransaction());
+ for (int i = 0; i < num_inputs; ++i) {
+ Datum datum;
+ datum.set_label(i);
+ datum.set_channels(2);
+ datum.set_height(i % 2 + 1);
+ datum.set_width(i % 4 + 1);
+ std::string* data = datum.mutable_data();
+ const int data_size = datum.channels() * datum.height() * datum.width();
+ for (int j = 0; j < data_size; ++j) {
+ data->push_back(static_cast<uint8_t>(j));
+ }
+ stringstream ss;
+ ss << i;
+ string out;
+ CHECK(datum.SerializeToString(&out));
+ txn->Put(ss.str(), out);
+ }
+ txn->Commit();
+ db->Close();
+
+ // Load and check data of various shapes.
+ LayerParameter param;
+ DataParameter* data_param = param.mutable_data_param();
+ data_param->set_batch_size(1);
+ data_param->set_source(filename_->c_str());
+ data_param->set_backend(backend);
+
+ DataLayer<Dtype> layer(param);
+ layer.SetUp(blob_bottom_vec_, blob_top_vec_);
+ EXPECT_EQ(blob_top_data_->num(), 1);
+ EXPECT_EQ(blob_top_data_->channels(), 2);
+ EXPECT_EQ(blob_top_label_->num(), 1);
+ EXPECT_EQ(blob_top_label_->channels(), 1);
+ EXPECT_EQ(blob_top_label_->height(), 1);
+ EXPECT_EQ(blob_top_label_->width(), 1);
+
+ for (int iter = 0; iter < num_inputs; ++iter) {
+ layer.Forward(blob_bottom_vec_, blob_top_vec_);
+ EXPECT_EQ(blob_top_data_->height(), iter % 2 + 1);
+ EXPECT_EQ(blob_top_data_->width(), iter % 4 + 1);
+ EXPECT_EQ(iter, blob_top_label_->cpu_data()[0]);
+ const int channels = blob_top_data_->channels();
+ const int height = blob_top_data_->height();
+ const int width = blob_top_data_->width();
+ for (int c = 0; c < channels; ++c) {
+ for (int h = 0; h < height; ++h) {
+ for (int w = 0; w < width; ++w) {
+ const int idx = (c * height + h) * width + w;
+ EXPECT_EQ(idx, static_cast<int>(blob_top_data_->cpu_data()[idx]))
+ << "debug: iter " << iter << " c " << c
+ << " h " << h << " w " << w;
+ }
+ }
+ }
+ }
+ }
+
void TestReadCrop() {
const Dtype scale = 3;
LayerParameter param;
this->TestRead();
}
+TYPED_TEST(DataLayerTest, TestReshapeLevelDB) {
+ this->TestReshape(DataParameter_DB_LEVELDB);
+}
+
TYPED_TEST(DataLayerTest, TestReadCropTrainLevelDB) {
Caffe::set_phase(Caffe::TRAIN);
const bool unique_pixels = true; // all images the same; pixels different
this->TestRead();
}
+TYPED_TEST(DataLayerTest, TestReshapeLMDB) {
+ this->TestReshape(DataParameter_DB_LMDB);
+}
+
TYPED_TEST(DataLayerTest, TestReadCropTrainLMDB) {
Caffe::set_phase(Caffe::TRAIN);
const bool unique_pixels = true; // all images the same; pixels different
blob_top_data_(new Blob<Dtype>()),
blob_top_label_(new Blob<Dtype>()) {}
virtual void SetUp() {
- MakeTempFilename(&filename_);
blob_top_vec_.push_back(blob_top_data_);
blob_top_vec_.push_back(blob_top_label_);
Caffe::set_random_seed(seed_);
- // Create a Vector of files with labels
+ // Create test input file.
+ MakeTempFilename(&filename_);
std::ofstream outfile(filename_.c_str(), std::ofstream::out);
LOG(INFO) << "Using temporary file " << filename_;
for (int i = 0; i < 5; ++i) {
outfile << EXAMPLES_SOURCE_DIR "images/cat.jpg " << i;
}
outfile.close();
+ // Create test input file for images of distinct sizes.
+ MakeTempFilename(&filename_reshape_);
+ std::ofstream reshapefile(filename_reshape_.c_str(), std::ofstream::out);
+ LOG(INFO) << "Using temporary file " << filename_reshape_;
+ reshapefile << EXAMPLES_SOURCE_DIR "images/cat.jpg " << 0;
+ reshapefile << EXAMPLES_SOURCE_DIR "images/fish-bike.jpg " << 1;
+ reshapefile.close();
}
virtual ~ImageDataLayerTest() {
int seed_;
string filename_;
+ string filename_reshape_;
Blob<Dtype>* const blob_top_data_;
Blob<Dtype>* const blob_top_label_;
vector<Blob<Dtype>*> blob_bottom_vec_;
}
}
+TYPED_TEST(ImageDataLayerTest, TestReshape) {
+ typedef typename TypeParam::Dtype Dtype;
+ LayerParameter param;
+ ImageDataParameter* image_data_param = param.mutable_image_data_param();
+ image_data_param->set_batch_size(1);
+ image_data_param->set_source(this->filename_reshape_.c_str());
+ image_data_param->set_shuffle(false);
+ ImageDataLayer<Dtype> layer(param);
+ layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_);
+ EXPECT_EQ(this->blob_top_label_->num(), 1);
+ EXPECT_EQ(this->blob_top_label_->channels(), 1);
+ EXPECT_EQ(this->blob_top_label_->height(), 1);
+ EXPECT_EQ(this->blob_top_label_->width(), 1);
+ // cat.jpg
+ layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_);
+ EXPECT_EQ(this->blob_top_data_->num(), 1);
+ EXPECT_EQ(this->blob_top_data_->channels(), 3);
+ EXPECT_EQ(this->blob_top_data_->height(), 360);
+ EXPECT_EQ(this->blob_top_data_->width(), 480);
+ // fish-bike.jpg
+ layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_);
+ EXPECT_EQ(this->blob_top_data_->num(), 1);
+ EXPECT_EQ(this->blob_top_data_->channels(), 3);
+ EXPECT_EQ(this->blob_top_data_->height(), 323);
+ EXPECT_EQ(this->blob_top_data_->width(), 481);
+}
+
TYPED_TEST(ImageDataLayerTest, TestShuffle) {
typedef typename TypeParam::Dtype Dtype;
LayerParameter param;