TEST_F(IOTest, TestCVMatToDatumReference) {
string filename = EXAMPLES_SOURCE_DIR "images/cat.jpg";
cv::Mat cv_img = ReadImageToCVMat(filename);
Datum datum;
CVMatToDatum(cv_img, &datum);
Datum datum_ref;
ReadImageToDatumReference(filename, 0, 0, 0, true, &datum_ref);
EXPECT_EQ(datum.channels(), datum_ref.channels());
EXPECT_EQ(datum.height(), datum_ref.height());
EXPECT_EQ(datum.width(), datum_ref.width());
EXPECT_EQ(datum.data().size(), datum_ref.data().size());
const string& data = datum.data();
const string& data_ref = datum_ref.data();
for (int_tp i = 0; i < datum.data().size(); ++i) {
EXPECT_TRUE(data[i] == data_ref[i]);
}
}
TEST_F(IOTest, TestReadImageToDatumContentGray) {
string filename = EXAMPLES_SOURCE_DIR "images/cat.jpg";
Datum datum;
const bool is_color = false;
ReadImageToDatum(filename, 0, is_color, &datum);
cv::Mat cv_img = ReadImageToCVMat(filename, is_color);
EXPECT_EQ(datum.channels(), cv_img.channels());
EXPECT_EQ(datum.height(), cv_img.rows);
EXPECT_EQ(datum.width(), cv_img.cols);
const string& data = datum.data();
int_tp index = 0;
for (int_tp h = 0; h < datum.height(); ++h) {
for (int_tp w = 0; w < datum.width(); ++w) {
EXPECT_TRUE(data[index++] == static_cast<char>(cv_img.at<uchar>(h, w)));
}
}
}
TEST_F(IOTest, TestDecodeDatumNativeGray) {
string filename = EXAMPLES_SOURCE_DIR "images/cat_gray.jpg";
Datum datum;
EXPECT_TRUE(ReadFileToDatum(filename, &datum));
EXPECT_TRUE(DecodeDatumNative(&datum));
EXPECT_FALSE(DecodeDatumNative(&datum));
Datum datum_ref;
ReadImageToDatumReference(filename, 0, 0, 0, false, &datum_ref);
EXPECT_EQ(datum.channels(), datum_ref.channels());
EXPECT_EQ(datum.height(), datum_ref.height());
EXPECT_EQ(datum.width(), datum_ref.width());
EXPECT_EQ(datum.data().size(), datum_ref.data().size());
const string& data = datum.data();
const string& data_ref = datum_ref.data();
for (int i = 0; i < datum.data().size(); ++i) {
EXPECT_TRUE(data[i] == data_ref[i]);
}
}
Scope& Scope::AppendScope(const std::string& key)
{
if (key == std::string())
throw std::exception("Key cannot be an empty string.");
Scope* newScope = new Scope();
newScope->mParent = this;
// try to find entry first in this scope
Datum* d = Find(key);
if (d != nullptr)
{
if (d->GetType() != Datum::Table && d->GetType() != Datum::Unknown)
{
delete newScope;
throw std::exception("Found entry is not a table!");
}
if (d->IsExternal())
{
delete newScope;
throw std::exception("Table entry is external. Cannot modify data owned by something else.");
}
// a new scope gets added into this table datum
std::uint32_t datumSize = d->Size();
d->Set(newScope, datumSize);
return *d->GetTable(datumSize);
}
// if no entry is found, create new datum with this scope
Datum scopeDatum;
scopeDatum = newScope;
std::pair<std::string, Datum> pair(key, scopeDatum);
HashMap<std::string, Datum>::Iterator iterator = mTable.Insert(pair);
mOrder.PushBack(&(*iterator));
return *(iterator->second.GetTable());
}
void DataTransformer<Dtype>::PostTransform(const int batch_item_id,
const Datum& datum,
const Dtype* mean,
Dtype* transformed_data)
{
const string& data = datum.data();
const int channels = datum.channels();
const int height = datum.height();
const int width = datum.width();
const int size = datum.channels() * datum.height() * datum.width();
/**
* only works for uint8 data data.
* post transfrom parameters:
* int : post_random_translation_size
* string : post_ground_truth_pooling_param : [num_of_pooling] [pooling_h_1] ] [pooling_w_1] [pooling_h_2],.......
* int : post_channel_for_additional_translation
*/
const int crop_size = param_.crop_size();
const bool mirror = param_.mirror();
const Dtype scale = param_.scale();
// if(param_.has_post_random_translation_size())
// {
//
// }
// if(param_.has_post_ground_truth_pooling_param())
// {
//
// }
// if(param_.has_post_channel_for_additional_translation())
// {
//
// }
}
Datum BaseFrameListStimulus::getCurrentAnnounceDrawData() {
Datum announceData = StandardDynamicStimulus::getCurrentAnnounceDrawData();
if (stimulusGroup) {
announceData.addElement(STIMULUS_GROUP, stimulusGroup->getTag());
}
announceData.addElement(LOOP, loop->getValue());
announceData.addElement("playing", Datum(isPlaying()));
int frameNumber = getFrameNumber();
announceData.addElement("current_frame", Datum((long)frameNumber));
Datum currentStimulusAnnounceData(0L);
if ((frameNumber >= 0) && (frameNumber < getNumFrames())) {
currentStimulusAnnounceData = getStimulusForFrame(frameNumber)->getCurrentAnnounceDrawData();
}
announceData.addElement("current_stimulus", currentStimulusAnnounceData);
return announceData;
}
///////////////////
// String
///////////////////
void Lingo::b_chars(int nargs) {
Datum to = g_lingo->pop();
Datum from = g_lingo->pop();
Datum s = g_lingo->pop();
if (s.type != STRING)
error("Incorrect type for 'chars' function: %s", s.type2str());
to.toInt();
from.toInt();
int len = strlen(s.u.s->c_str());
int f = MAX(0, MIN(len, from.u.i - 1));
int t = MAX(0, MIN(len, to.u.i));
Common::String *res = new Common::String(&(s.u.s->c_str()[f]), &(s.u.s->c_str()[t]));
delete s.u.s;
s.u.s = res;
s.type = STRING;
g_lingo->push(s);
}
// this routine checks that the request is a dictionary and that it contains a name that matches the calibrator
bool Calibrator::checkRequest(Datum dictionaryData) {
Datum data; // to hold field data for checking
// check if this is a dictionary
if (!(dictionaryData.getDataType() == M_DICTIONARY)) {
mwarning(M_SYSTEM_MESSAGE_DOMAIN,
"Request sent to calibrator %s that was not expected dictionary type was ignored.", uniqueCalibratorName.c_str());
return(false);
}
// check if there is a name field and if this calibrator should respond (i.e. if it has the correct name)
if (!(dictionaryData.hasKey(R_CALIBRATOR_NAME))) {
mwarning(M_SYSTEM_MESSAGE_DOMAIN,
"Request sent to calibrator %s that did not contain name field was ignored.", uniqueCalibratorName.c_str());
return(false);
}
Datum nameData = dictionaryData.getElement(R_CALIBRATOR_NAME);
if (!(nameData.getDataType() == M_STRING)) { // check if name field is a string
mwarning(M_SYSTEM_MESSAGE_DOMAIN,
"Request sent to calibrator %s that did not contain a string in the name field was ignored.", uniqueCalibratorName.c_str());
return(false);
}
if (uniqueCalibratorName == nameData.getString()) { // check is name field matches the name of this calibrator
if (VERBOSE_EYE_CALIBRATORS) mprintf("Calibrator %s successfully received a properly named request.", uniqueCalibratorName.c_str());
}
else {
if (VERBOSE_EYE_CALIBRATORS) mprintf("Calibrator %s received a request, but name did not match.", uniqueCalibratorName.c_str());
return(false); // request not meant for this calibrator (can be normal behavior -- no warnings)
}
return true;
}
Datum Lingo::getTheCast(Datum &id1, int field) {
Datum d;
int id = 0;
if (id1.type == INT) {
id = id1.u.i;
} else {
warning("Unknown the cast id type: %s", id1.type2str());
return d;
}
if (!_vm->_currentScore) {
warning("The cast %d field %d setting over non-active score", id, field);
return d;
}
Cast *cast;
CastInfo *castInfo;
if (!_vm->_currentScore->_casts.contains(id)) {
if (field == kTheLoaded) {
d.type = INT;
d.u.i = 0;
}
return d;
} else {
warning("The cast %d found", id);
}
cast = _vm->_currentScore->_casts[id];
castInfo = _vm->_currentScore->_castsInfo[id];
d.type = INT;
switch (field) {
case kTheCastType:
d.u.i = cast->type;
break;
case kTheFilename:
d.toString();
d.u.s = &castInfo->fileName;
break;
case kTheName:
d.toString();
d.u.s = &castInfo->name;
break;
case kTheScriptText:
d.toString();
d.u.s = &castInfo->script;
break;
case kTheWidth:
d.u.i = cast->initialRect.width();
break;
case kTheHeight:
d.u.i = cast->initialRect.height();
break;
case kTheBackColor:
{
if (cast->type != kCastShape) {
warning("Field %d of cast %d not found", field, id);
d.type = VOID;
return d;
}
ShapeCast *shape = static_cast<ShapeCast *>(_vm->_currentScore->_casts[id]);
d.u.i = shape->bgCol;
}
break;
case kTheForeColor:
{
if (cast->type != kCastShape) {
warning("Field %d of cast %d not found", field, id);
d.type = VOID;
return d;
}
ShapeCast *shape = static_cast<ShapeCast *>(_vm->_currentScore->_casts[id]);
d.u.i = shape->fgCol;
}
break;
case kTheLoaded:
d.u.i = 1; //Not loaded handled above
break;
default:
warning("Unprocessed getting field %d of cast %d", field, id);
d.type = VOID;
//TODO find out about String fields
}
return d;
}
Datum Lingo::getTheEntity(int entity, Datum &id, int field) {
Datum d;
switch (entity) {
case kTheSprite:
d = getTheSprite(id, field);
break;
case kTheCast:
d = getTheCast(id, field);
break;
case kThePerFrameHook:
warning("STUB: getting the perframehook");
break;
case kTheFloatPrecision:
d.type = INT;
d.u.i = _floatPrecision;
break;
case kTheSqrt:
id.toFloat();
d.type = FLOAT;
d.u.f = sqrt(id.u.f);
break;
case kTheKey:
d.type = STRING;
d.u.s = new Common::String(_vm->_key);
break;
case kTheKeyCode:
d.type = INT;
d.u.i = _vm->_keyCode;
break;
case kTheColorQD:
d.type = INT;
d.u.i = 1;
break;
case kTheColorDepth:
// bpp. 1, 2, 4, 8, 32
d.type = INT;
d.u.i = _vm->_colorDepth;
break;
case kTheMachineType:
// 1 - Macintosh 512Ke D2
// 2 - Macintosh Plus D2
// 3 - Macintosh SE D2
// 4 - Macintosh II D2
// 5 - Macintosh IIx D2
// 6 - Macintosh IIcx D2
// 7 - Macintosh SE/30 D2
// 8 - Macintosh Portable D2
// 9 - Macintosh IIci D2
// 11 - Macintosh IIfx D3
// 15 - Macintosh Classic D3
// 16 - Macintosh IIsi D3
// 17 - Macintosh LC D3
// 18 - Macintosh Quadra 900 D3
// 19 - PowerBook 170 D3
// 20 - Macintosh Quadra 700 D3
// 21 - Classic II D3
// 22 - PowerBook 100 D3
// 23 - PowerBook 140 D3
// 24 - Macintosh Quadra 950 D4
// 25 - Macintosh LCIII D4
// 27 - PowerBook Duo 210 D4
// 28 - Macintosh Centris 650 D4
// 30 - PowerBook Duo 230 D4
// 31 - PowerBook 180 D4
// 32 - PowerBook 160 D4
// 33 - Macintosh Quadra 800 D4
// 35 - Macintosh LC II D4
// 42 - Macintosh IIvi D4
// 45 - Power Macintosh 7100/70 D5
// 46 - Macintosh IIvx D4
// 47 - Macintosh Color Classic D4
// 48 - PowerBook 165c D4
// 50 - Macintosh Centris 610 D4
// 52 - PowerBook 145 D4
// 53 - PowerComputing 8100/100 D5
// 73 - Power Macintosh 6100/60 D5
// 76 - Macintosh Quadra 840av D4
// 256 - IBM PC-type machine D3
d.type = INT;
d.u.i = _vm->_machineType;
break;
default:
warning("Unprocessed getting field %d of entity %d", field, entity);
d.type = VOID;
}
return d;
}
void DataTransformer<Dtype>::Transform(const Datum& datum,
Dtype* transformed_data) {
const string& data = datum.data();
const int datum_channels = datum.channels();
const int datum_height = datum.height();
const int datum_width = datum.width();
const int crop_size = param_.crop_size();
const Dtype scale = param_.scale();
const bool do_mirror = param_.mirror() && Rand(2);
const bool has_mean_file = param_.has_mean_file();
const bool has_uint8 = data.size() > 0;
const bool has_mean_values = mean_values_.size() > 0;
CHECK_GT(datum_channels, 0);
CHECK_GE(datum_height, crop_size);
CHECK_GE(datum_width, crop_size);
Dtype* mean = NULL;
if (has_mean_file) {
CHECK_EQ(datum_channels, data_mean_.channels());
CHECK_EQ(datum_height, data_mean_.height());
CHECK_EQ(datum_width, data_mean_.width());
mean = data_mean_.mutable_cpu_data();
}
if (has_mean_values) {
CHECK(mean_values_.size() == 1 || mean_values_.size() == datum_channels) <<
"Specify either 1 mean_value or as many as channels: " << datum_channels;
if (datum_channels > 1 && mean_values_.size() == 1) {
// Replicate the mean_value for simplicity
for (int c = 1; c < datum_channels; ++c) {
mean_values_.push_back(mean_values_[0]);
}
}
}
int height = datum_height;
int width = datum_width;
int h_off = 0;
int w_off = 0;
if (crop_size) {
height = crop_size;
width = crop_size;
// We only do random crop when we do training.
if (phase_ == TRAIN) {
h_off = Rand(datum_height - crop_size + 1);
w_off = Rand(datum_width - crop_size + 1);
} else {
h_off = (datum_height - crop_size) / 2;
w_off = (datum_width - crop_size) / 2;
}
}
Dtype datum_element;
int top_index, data_index;
for (int c = 0; c < datum_channels; ++c) {
for (int h = 0; h < height; ++h) {
for (int w = 0; w < width; ++w) {
data_index = (c * datum_height + h_off + h) * datum_width + w_off + w;
if (do_mirror) {
top_index = (c * height + h) * width + (width - 1 - w);
} else {
top_index = (c * height + h) * width + w;
}
if (has_uint8) {
datum_element =
static_cast<Dtype>(static_cast<uint8_t>(data[data_index]));
} else {
datum_element = datum.float_data(data_index);
}
if (has_mean_file) {
transformed_data[top_index] =
(datum_element - mean[data_index]) * scale;
} else {
if (has_mean_values) {
transformed_data[top_index] =
(datum_element - mean_values_[c]) * scale;
} else {
transformed_data[top_index] = datum_element * scale;
}
}
}
}
}
}
Datum MovingDots::getCurrentAnnounceDrawData() {
boost::mutex::scoped_lock locker(stim_lock);
Datum announceData = StandardDynamicStimulus::getCurrentAnnounceDrawData();
announceData.addElement(STIM_TYPE, "moving_dots");
announceData.addElement(FIELD_RADIUS, currentFieldRadius);
announceData.addElement(FIELD_CENTER_X, fieldCenterX->getValue().getFloat());
announceData.addElement(FIELD_CENTER_Y, fieldCenterY->getValue().getFloat());
announceData.addElement(DOT_DENSITY, dotDensity->getValue().getFloat());
announceData.addElement(DOT_SIZE, dotSize->getValue().getFloat());
announceData.addElement(STIM_COLOR_R, red->getValue().getFloat());
announceData.addElement(STIM_COLOR_G, green->getValue().getFloat());
announceData.addElement(STIM_COLOR_B, blue->getValue().getFloat());
announceData.addElement(ALPHA_MULTIPLIER, alpha->getValue().getFloat());
announceData.addElement(DIRECTION, direction->getValue().getFloat());
announceData.addElement(SPEED, currentSpeed);
announceData.addElement(COHERENCE, currentCoherence);
announceData.addElement(LIFETIME, currentLifetime);
announceData.addElement("num_dots", long(currentNumDots));
announceData.addElement(RAND_SEED, randSeed);
if (announceDots->getValue().getBool()) {
Datum dotsData(reinterpret_cast<char *>(&(dotPositions[0])), dotPositions.size() * sizeof(GLfloat));
announceData.addElement("dots", dotsData);
}
return announceData;
}
void DataLayer<Dtype>::DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
// Initialize DB
db_.reset(db::GetDB(this->layer_param_.data_param().backend()));
db_->Open(this->layer_param_.data_param().source(), db::READ);
cursor_.reset(db_->NewCursor());
// Check if we should randomly skip a few data points
if (this->layer_param_.data_param().rand_skip()) {
unsigned int skip = caffe_rng_rand() %
this->layer_param_.data_param().rand_skip();
LOG(INFO) << "Skipping first " << skip << " data points.";
while (skip-- > 0) {
cursor_->Next();
}
}
// Read a data point, and use it to initialize the top blob.
Datum datum;
datum.ParseFromString(cursor_->value());
bool force_color = this->layer_param_.data_param().force_encoded_color();
if ((force_color && DecodeDatum(&datum, true)) ||
DecodeDatumNative(&datum)) {
LOG(INFO) << "Decoding Datum";
}
// image
int crop_size = this->layer_param_.transform_param().crop_size();
if (crop_size > 0) {
top[0]->Reshape(this->layer_param_.data_param().batch_size(),
datum.channels(), crop_size, crop_size);
this->prefetch_data_.Reshape(this->layer_param_.data_param().batch_size(),
datum.channels(), crop_size, crop_size);
this->transformed_data_.Reshape(1, datum.channels(), crop_size, crop_size);
} else {
top[0]->Reshape(
this->layer_param_.data_param().batch_size(), datum.channels(),
datum.height(), datum.width());
this->prefetch_data_.Reshape(this->layer_param_.data_param().batch_size(),
datum.channels(), datum.height(), datum.width());
this->transformed_data_.Reshape(1, datum.channels(),
datum.height(), datum.width());
}
LOG(INFO) << "output data size: " << top[0]->num() << ","
<< top[0]->channels() << "," << top[0]->height() << ","
<< top[0]->width();
// label
printf("Go here\n");
printf("%d\n", this->layer_param_.data_param().label_size());
if (this->output_labels_) {
top[1]->Reshape(this->layer_param_.data_param().batch_size(), this->layer_param_.data_param().label_size(), 1, 1);
this->prefetch_label_.Reshape(this->layer_param_.data_param().batch_size(),
this->layer_param_.data_param().label_size(), 1, 1);
}
}
void FeatureExtractor<Dtype>::ExtractFeatures(const NetParameter& net_param) {
util::Context& context = util::Context::get_instance();
int client_id = context.get_int32("client_id");
string weights_path = context.get_string("weights");
string extract_feature_blob_names
= context.get_string("extract_feature_blob_names");
shared_ptr<Net<Dtype> > feature_extraction_net(
new Net<Dtype>(net_param, thread_id_, 0));
map<string, vector<int> >::const_iterator it
= layer_blobs_global_idx_ptr_->begin();
for (; it != layer_blobs_global_idx_ptr_->end(); ++it) {
const shared_ptr<Layer<Dtype> > layer
= feature_extraction_net->layer_by_name(it->first);
layer->SetUpBlobGlobalTable(it->second, false, false);
}
if (client_id == 0 && thread_id_ == 0) {
LOG(INFO) << "Extracting features by " << weights_path;
feature_extraction_net->CopyTrainedLayersFrom(weights_path, true);
}
petuum::PSTableGroup::GlobalBarrier();
feature_extraction_net->SyncWithPS(0);
vector<string> blob_names;
boost::split(blob_names, extract_feature_blob_names, boost::is_any_of(","));
string save_feature_leveldb_names
= context.get_string("save_feature_leveldb_names");
vector<string> leveldb_names;
boost::split(leveldb_names, save_feature_leveldb_names,
boost::is_any_of(","));
CHECK_EQ(blob_names.size(), leveldb_names.size()) <<
" the number of blob names and leveldb names must be equal";
size_t num_features = blob_names.size();
for (size_t i = 0; i < num_features; i++) {
CHECK(feature_extraction_net->has_blob(blob_names[i]))
<< "Unknown feature blob name " << blob_names[i]
<< " in the network ";
}
CHECK(feature_extraction_net->has_blob("label"))
<< "Fail to find label blob in the network ";
// Differentiate leveldb names
std::ostringstream suffix;
suffix << "_" << client_id << "_" << thread_id_;
for (size_t i = 0; i < num_features; i++) {
leveldb_names[i] = leveldb_names[i] + suffix.str();
}
leveldb::Options options;
options.error_if_exists = true;
options.create_if_missing = true;
options.write_buffer_size = 268435456;
vector<shared_ptr<leveldb::DB> > feature_dbs;
for (size_t i = 0; i < num_features; ++i) {
leveldb::DB* db;
leveldb::Status status = leveldb::DB::Open(options,
leveldb_names[i].c_str(),
&db);
CHECK(status.ok()) << "Failed to open leveldb " << leveldb_names[i];
feature_dbs.push_back(shared_ptr<leveldb::DB>(db));
}
int num_mini_batches = context.get_int32("num_mini_batches");
Datum datum;
vector<shared_ptr<leveldb::WriteBatch> > feature_batches(
num_features,
shared_ptr<leveldb::WriteBatch>(new leveldb::WriteBatch()));
const int kMaxKeyStrLength = 100;
char key_str[kMaxKeyStrLength];
vector<Blob<float>*> input_vec;
vector<int> image_indices(num_features, 0);
for (int batch_index = 0; batch_index < num_mini_batches; ++batch_index) {
feature_extraction_net->Forward(input_vec);
for (int i = 0; i < num_features; ++i) {
const shared_ptr<Blob<Dtype> > feature_blob
= feature_extraction_net->blob_by_name(blob_names[i]);
const shared_ptr<Blob<Dtype> > label_blob
= feature_extraction_net->blob_by_name("label");
const Dtype* labels = label_blob->cpu_data();
int batch_size = feature_blob->num();
int dim_features = feature_blob->count() / batch_size;
Dtype* feature_blob_data;
for (int n = 0; n < batch_size; ++n) {
datum.set_height(dim_features);
datum.set_width(1);
datum.set_channels(1);
datum.clear_data();
datum.clear_float_data();
feature_blob_data = feature_blob->mutable_cpu_data() +
feature_blob->offset(n);
for (int d = 0; d < dim_features; ++d) {
datum.add_float_data(feature_blob_data[d]);
}
datum.set_label(static_cast<int>(labels[n]));
string value;
datum.SerializeToString(&value);
snprintf(key_str, kMaxKeyStrLength, "%d", image_indices[i]);
feature_batches[i]->Put(string(key_str), value);
++image_indices[i];
if (image_indices[i] % 1000 == 0) {
feature_dbs[i]->Write(leveldb::WriteOptions(),
feature_batches[i].get());
feature_batches[i].reset(new leveldb::WriteBatch());
}
} // for (int n = 0; n < batch_size; ++n)
} // for (int i = 0; i < num_features; ++i)
} // for (int batch_index = 0; batch_index < num_mini_batches; ++batch_index)
// write the last batch
for (int i = 0; i < num_features; ++i) {
if (image_indices[i] % 1000 != 0) {
feature_dbs[i]->Write(leveldb::WriteOptions(), feature_batches[i].get());
}
}
}
int main(int argc, char** argv) {
::google::InitGoogleLogging(argv[0]);
if (argc < 5) {
printf(
"Convert a set of images to the leveldb format used\n"
"as input for Caffe.\n"
"Usage:\n"
" convert_imageset ROOTFOLDER/ ANNOTATION DB_NAME"
" MODE[0-train, 1-val, 2-test] RANDOM_SHUFFLE_DATA[0 or 1, default 1] RESIZE_WIDTH[default 256] RESIZE_HEIGHT[default 256](0 indicates no resize)\n"
"The ImageNet dataset for the training demo is at\n"
" http://www.image-net.org/download-images\n");
return 0;
}
std::ifstream infile(argv[2]);
string root_folder(argv[1]);
string coarse_folder(argv[8]);
string local_folder(argv[9]);
string van_folder(argv[10]);
string edge_folder(argv[11]);
string layout_folder(argv[12]);
std::vector<Seg_Anno> annos;
std::set<string> fNames;
string filename;
float prop;
int cc = 0;
while (infile >> filename)
{
if (cc % 1000 == 0)
LOG(INFO)<<filename;
cc ++;
Seg_Anno seg_Anno;
seg_Anno.filename_ = filename;
int x,y;
infile >> x >> y;
for (int i = 0; i < LABEL_LEN; i++)
{
//infile >> prop;
if(!(prop < 1000000 && prop > -1000000))
{
printf("123");
}
seg_Anno.pos_.push_back(0);
}
//string labelFile = filename;
//labelFile[labelFile.size() - 1] = 't';
//labelFile[labelFile.size() - 2] = 'x';
//labelFile[labelFile.size() - 3] = 't';
//labelFile = coarse_folder + "/" + labelFile;
//FILE * tf = fopen(labelFile.c_str(), "rb");
//if(tf == NULL) continue;
//fclose(tf);
if (fNames.find(filename)== fNames.end())
{
fNames.insert(filename);
annos.push_back(seg_Anno);
}
//debug
//if(annos.size() == 10)
// break;
}
if (argc < 6 || argv[5][0] != '0') {
// randomly shuffle data
LOG(INFO)<< "Shuffling data";
std::random_shuffle(annos.begin(), annos.end());
}
LOG(INFO)<< "A total of " << annos.size() << " images.";
leveldb::DB* db;
leveldb::Options options;
options.error_if_exists = true;
options.create_if_missing = true;
options.write_buffer_size = 268435456;
LOG(INFO)<< "Opening leveldb " << argv[3];
leveldb::Status status = leveldb::DB::Open(options, argv[3], &db);
CHECK(status.ok()) << "Failed to open leveldb " << argv[3];
Datum datum;
int count = 0;
const int maxKeyLength = 256;
char key_cstr[maxKeyLength];
leveldb::WriteBatch* batch = new leveldb::WriteBatch();
int data_size;
bool data_size_initialized = false;
// resize to height * width
int width = RESIZE_LEN;
int height = RESIZE_LEN;
if (argc > 6) width = atoi(argv[6]);
if (argc > 7) height = atoi(argv[7]);
if (width == 0 || height == 0)
LOG(INFO) << "NO RESIZE SHOULD BE DONE";
else
LOG(INFO) << "RESIZE DIM: " << width << "*" << height;
for (int anno_id = 0; anno_id < annos.size(); ++anno_id)
{
string labelFile = annos[anno_id].filename_;
labelFile[labelFile.size() - 1] = 't';
labelFile[labelFile.size() - 2] = 'x';
labelFile[labelFile.size() - 3] = 't';
if (!MyReadImageToDatum(root_folder + "/" + annos[anno_id].filename_, coarse_folder + "/" + labelFile, local_folder + "/" + labelFile, van_folder + "/" + labelFile,
edge_folder + '/' + labelFile, layout_folder + '/' + labelFile , annos[anno_id].pos_, height, width, &datum))
{
continue;
}
if (!data_size_initialized)
{
data_size = datum.channels() * datum.height() * datum.width() ;
data_size_initialized = true;
}
else
{
int dataLen = datum.float_data_size();
CHECK_EQ(dataLen, data_size)<< "Incorrect data field size " << dataLen;
}
// sequential
snprintf(key_cstr, maxKeyLength, "%07d_%s", anno_id, annos[anno_id].filename_.c_str());
string value;
// get the value
datum.SerializeToString(&value);
batch->Put(string(key_cstr), value);
if (++count % 1000 == 0)
{
db->Write(leveldb::WriteOptions(), batch);
LOG(ERROR)<< "Processed " << count << " files.";
delete batch;
batch = new leveldb::WriteBatch();
}
}
// write the last batch
if (count % 1000 != 0) {
db->Write(leveldb::WriteOptions(), batch);
LOG(ERROR)<< "Processed " << count << " files.";
}
delete batch;
delete db;
return 0;
}
int main(int argc, char** argv) {
::google::InitGoogleLogging(argv[0]);
if (argc != 3) {
LOG(ERROR) << "Usage: compute_image_mean input_leveldb output_file";
return 1;
}
leveldb::DB* db;
leveldb::Options options;
options.create_if_missing = false;
LOG(INFO) << "Opening leveldb " << argv[1];
leveldb::Status status = leveldb::DB::Open(
options, argv[1], &db);
CHECK(status.ok()) << "Failed to open leveldb " << argv[1];
leveldb::ReadOptions read_options;
read_options.fill_cache = false;
leveldb::Iterator* it = db->NewIterator(read_options);
it->SeekToFirst();
Datum datum;
BlobProto sum_blob;
int count = 0;
datum.ParseFromString(it->value().ToString());
sum_blob.set_num(1);
sum_blob.set_channels(datum.channels());
sum_blob.set_height(datum.height());
sum_blob.set_width(datum.width());
const int data_size = datum.channels() * datum.height() * datum.width();
int size_in_datum = std::max<int>(datum.data().size(),
datum.float_data_size());
for (int i = 0; i < size_in_datum; ++i) {
sum_blob.add_data(0.);
}
LOG(INFO) << "Starting Iteration";
for (it->SeekToFirst(); it->Valid(); it->Next()) {
// just a dummy operation
datum.ParseFromString(it->value().ToString());
const string& data = datum.data();
size_in_datum = std::max<int>(datum.data().size(), datum.float_data_size());
CHECK_EQ(size_in_datum, data_size) << "Incorrect data field size " <<
size_in_datum;
if (data.size() != 0) {
for (int i = 0; i < size_in_datum; ++i) {
sum_blob.set_data(i, sum_blob.data(i) + (uint8_t)data[i]);
}
} else {
for (int i = 0; i < size_in_datum; ++i) {
sum_blob.set_data(i, sum_blob.data(i) +
static_cast<float>(datum.float_data(i)));
}
}
++count;
if (count % 10000 == 0) {
LOG(ERROR) << "Processed " << count << " files.";
}
}
if (count % 10000 != 0) {
LOG(ERROR) << "Processed " << count << " files.";
}
for (int i = 0; i < sum_blob.data_size(); ++i) {
sum_blob.set_data(i, sum_blob.data(i) / count);
}
// Write to disk
LOG(INFO) << "Write to " << argv[2];
WriteProtoToBinaryFile(sum_blob, argv[2]);
delete db;
return 0;
}
void VideoDataLayer<Dtype>:: DataLayerSetUp(const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top){
const int new_height = this->layer_param_.video_data_param().new_height();
const int new_width = this->layer_param_.video_data_param().new_width();
const int new_length = this->layer_param_.video_data_param().new_length();
//const int num_segments = this->layer_param_.video_data_param().num_segments();
const string& source = this->layer_param_.video_data_param().source();
string root_folder = this->layer_param_.video_data_param().root_folder();
const bool flow_is_color = this->layer_param_.video_data_param().flow_is_color();
LOG(INFO) << "Opening file: " << source;
std:: ifstream infile(source.c_str());
string filename;
int label;
int length;
while (infile >> filename >> length >> label){
lines_.push_back(std::make_pair(filename,label));
lines_duration_.push_back(length);
}
if (this->layer_param_.video_data_param().shuffle()){
const unsigned int prefectch_rng_seed = caffe_rng_rand();
prefetch_rng_1_.reset(new Caffe::RNG(prefectch_rng_seed));
prefetch_rng_2_.reset(new Caffe::RNG(prefectch_rng_seed));
ShuffleVideos();
}
LOG(INFO) << "A total of " << lines_.size() << " videos.";
//lines_id_ = 0;
const int thread_id = Caffe::getThreadId();
const int thread_num = Caffe::getThreadNum();
lines_id_ = lines_.size() / thread_num * thread_id;
Datum datum;
const unsigned int frame_prefectch_rng_seed = caffe_rng_rand();
frame_prefetch_rng_.reset(new Caffe::RNG(frame_prefectch_rng_seed));
const int len_vid = int(lines_duration_[lines_id_]);
CHECK_GE(len_vid, new_length);
//int average_duration = (int) lines_duration_[lines_id_]/num_segments;
vector<int> offsets(1,0);
if (this->layer_param_.video_data_param().modality() == VideoDataParameter_Modality_FLOW)
CHECK(ReadSegmentFlowToDatum(root_folder + lines_[lines_id_].first, lines_[lines_id_].second, offsets, new_height, new_width, new_length, &datum, flow_is_color));
else
CHECK(ReadSegmentRGBToDatum(root_folder + lines_[lines_id_].first, lines_[lines_id_].second, offsets, new_height, new_width, new_length, &datum, true));
const int crop_size = this->layer_param_.transform_param().crop_size();
int batch_size = this->layer_param_.video_data_param().batch_size();
if (this->phase_==TEST)
CHECK(batch_size % thread_num == 0) << "batch_size % thread_num != 0";
batch_size /= thread_num;
if (crop_size > 0){
top[0]->Reshape(batch_size, datum.channels(), crop_size, crop_size);
this->prefetch_data_.Reshape(batch_size, datum.channels(), crop_size, crop_size);
} else {
top[0]->Reshape(batch_size, datum.channels(), datum.height(), datum.width());
this->prefetch_data_.Reshape(batch_size, datum.channels(), datum.height(), datum.width());
}
LOG(INFO) << "output data size: " << top[0]->num() << "," << top[0]->channels() << "," << top[0]->height() << "," << top[0]->width();
top[1]->Reshape(batch_size, 1, 1, 1);
this->prefetch_label_.Reshape(batch_size, 1, 1, 1);
vector<int> top_shape = this->data_transformer_->InferBlobShape(datum);
this->transformed_data_.Reshape(top_shape);
}
void DataLayer<Dtype>::InternalThreadEntry() {
CPUTimer batch_timer;
batch_timer.Start();
double read_time = 0;
double trans_time = 0;
CPUTimer timer;
CHECK(this->prefetch_data_.count());
CHECK(this->transformed_data_.count());
// Reshape on single input batches for inputs of varying dimension.
const int batch_size = this->layer_param_.data_param().batch_size();
const int crop_size = this->layer_param_.transform_param().crop_size();
if (batch_size == 1 && crop_size == 0) {
Datum datum;
datum.ParseFromString(cursor_->value());
this->prefetch_data_.Reshape(1, datum.channels(),
datum.height(), datum.width());
this->transformed_data_.Reshape(1, datum.channels(),
datum.height(), datum.width());
}
Dtype* top_data = this->prefetch_data_.mutable_cpu_data();
Dtype* top_label = NULL; // suppress warnings about uninitialized variables
if (this->output_labels_) {
top_label = this->prefetch_label_.mutable_cpu_data();
}
bool force_color = this->layer_param_.data_param().force_encoded_color();
for (int item_id = 0; item_id < batch_size; ++item_id) {
timer.Start();
// get a blob
Datum datum;
datum.ParseFromString(cursor_->value());
cv::Mat cv_img;
if (datum.encoded()) {
if (force_color) {
cv_img = DecodeDatumToCVMat(datum, true);
} else {
cv_img = DecodeDatumToCVMatNative(datum);
}
if (cv_img.channels() != this->transformed_data_.channels()) {
LOG(WARNING) << "Your dataset contains encoded images with mixed "
<< "channel sizes. Consider adding a 'force_color' flag to the "
<< "model definition, or rebuild your dataset using "
<< "convert_imageset.";
}
}
read_time += timer.MicroSeconds();
timer.Start();
// Apply data transformations (mirror, scale, crop...)
int offset = this->prefetch_data_.offset(item_id);
this->transformed_data_.set_cpu_data(top_data + offset);
if (datum.encoded()) {
this->data_transformer_->Transform(cv_img, &(this->transformed_data_));
} else {
this->data_transformer_->Transform(datum, &(this->transformed_data_));
}
if (this->output_labels_) {
for (int label_i = 0; label_i < datum.label_size(); ++label_i){
top_label[item_id * datum.label_size() + label_i] = datum.label(label_i);
}
//top_label[item_id] = datum.label();
}
trans_time += timer.MicroSeconds();
// go to the next iter
cursor_->Next();
if (!cursor_->valid()) {
DLOG(INFO) << "Restarting data prefetching from start.";
cursor_->SeekToFirst();
}
}
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.";
}
// this routine handles both "requests" and loading of private data (stored params)
// if a request, then priuvate values are probably in need of update
// if a load of private, then private values are OK, but I can check this.
void EyeCalibrator::tryToUseDataToSetParameters(Datum dictionaryData) {
// check if this is a dictionary
if (!(dictionaryData.getDataType() == M_DICTIONARY)) {
mwarning(M_SYSTEM_MESSAGE_DOMAIN,
"Data processed by calibrator %s that was not expected dictionary type was ignored.", uniqueCalibratorName.c_str());
return;
}
// try to perform the requested action
bool paramsChanged = false;
Datum paramData;
// if appropriate param fields are present and have expected length, then use the data
// to try to update the parameters
// H params ================================================
if (!(dictionaryData.hasKey(R_CALIBRATOR_PARAMS_H))) {
mwarning(M_SYSTEM_MESSAGE_DOMAIN,
"Data processed to update params of calibrator %s without proper params filed was ignored.", uniqueCalibratorName.c_str());
return;
}
paramData = dictionaryData.getElement(R_CALIBRATOR_PARAMS_H);
// check if vector and correct length
if (paramData.getDataType() != M_LIST) {
mwarning(M_SYSTEM_MESSAGE_DOMAIN,
"Data processed to update params of calibrator %s that did not contain vector in params field was ignored.", uniqueCalibratorName.c_str());
return;
}
Datum paramsH = paramData;
if (paramsH.getNElements() != (fitableFunctions->getElement(HfunctionIndex))->getNumParameters() ) {
mwarning(M_SYSTEM_MESSAGE_DOMAIN,
"Data processed to update params of calibrator %s that did not contain expected number of params was ignored.", uniqueCalibratorName.c_str());
return;
}
bool noErr = (fitableFunctions->getElement(HfunctionIndex))->setParameters(paramsH);
if (noErr) paramsChanged = true; // params have been updated
// V params ================================================
if (!(dictionaryData.hasKey(R_CALIBRATOR_PARAMS_V))) {
mwarning(M_SYSTEM_MESSAGE_DOMAIN,
"Data processed to update params of calibrator %s without proper params filed was ignored.", uniqueCalibratorName.c_str());
return;
}
paramData = dictionaryData.getElement(R_CALIBRATOR_PARAMS_V);
// check if vector and correct length
if (paramData.getDataType() != M_LIST) {
mwarning(M_SYSTEM_MESSAGE_DOMAIN,
"Data processed to update params of calibrator %s that did not contain vector in params field was ignored.", uniqueCalibratorName.c_str());
return;
}
Datum paramsV = paramData;
if (paramsV.getNElements() != (fitableFunctions->getElement(VfunctionIndex))->getNumParameters() ) {
mwarning(M_SYSTEM_MESSAGE_DOMAIN,
"Data processed to update params of calibrator %s that did not contain expected number of params was ignored.", uniqueCalibratorName.c_str());
return;
}
noErr = (fitableFunctions->getElement(VfunctionIndex))->setParameters(paramsV);
if (noErr) paramsChanged = true; // params have been updated
// if any params were updated, announce the full set of current parameters
// if this change was triggered by an external change to the private variable, then we do not need to update that private variable (and we cannot anyway -- it is locked)
if (paramsChanged) reportParameterUpdate();
}
int main(int argc, char** argv) {
::google::InitGoogleLogging(argv[0]);
if (argc < 4) {
printf("Convert a set of images to the leveldb format used\n"
"as input for Caffe.\n"
"Usage:\n"
" convert_imageset ROOTFOLDER/ LISTFILE NUM_LABELS DB_NAME"
" RANDOM_SHUFFLE_DATA[0 or 1]\n");
return 0;
}
//Arguments to our program
std::ifstream infile(argv[2]);
int numLabels = atoi(argv[3]);
// Each line is constituted of the path to the file and the vector of
// labels
std::vector<std::pair<string, std::vector<float> > > lines;
// --------
string filename;
std::vector<float> labels(numLabels);
while (infile >> filename) {
for(int l=0; l<numLabels; l++)
infile >> (labels[l]);
lines.push_back(std::make_pair(filename, labels));
/*
LOG(ERROR) << "filepath: " << lines[lines.size()-1].first;
LOG(ERROR) << "values: " << lines[lines.size()-1].second[0]
<< "," << lines[lines.size()-1].second[5]
<< "," << lines[lines.size()-1].second[8];
* */
}
if (argc == 5 && argv[5][0] == '1') {
// randomly shuffle data
LOG(ERROR) << "Shuffling data";
std::random_shuffle(lines.begin(), lines.end());
}
LOG(ERROR) << "A total of " << lines.size() << " images.";
leveldb::DB* db;
leveldb::Options options;
options.error_if_exists = true;
options.create_if_missing = true;
options.write_buffer_size = 268435456;
LOG(ERROR) << "Opening leveldb " << argv[4];
leveldb::Status status = leveldb::DB::Open(
options, argv[4], &db);
CHECK(status.ok()) << "Failed to open leveldb " << argv[4];
string root_folder(argv[1]);
Datum datum;
int count = 0;
const int maxKeyLength = 256;
char key_cstr[maxKeyLength];
leveldb::WriteBatch* batch = new leveldb::WriteBatch();
int data_size;
bool data_size_initialized = false;
for (int line_id = 0; line_id < lines.size(); ++line_id) {
if (!ReadImageWithLabelVectorToDatum(root_folder + lines[line_id].first, lines[line_id].second,
&datum)) {
continue;
};
if (!data_size_initialized) {
data_size = datum.channels() * datum.height() * datum.width();
} else {
const string& data = datum.data();
CHECK_EQ(data.size(), data_size) << "Incorrect data field size " << data.size();
}
// sequential
snprintf(key_cstr, maxKeyLength, "%08d_%s", line_id, lines[line_id].first.c_str());
string value;
// get the value
datum.SerializeToString(&value);
batch->Put(string(key_cstr), value);
if (++count % 1000 == 0) {
db->Write(leveldb::WriteOptions(), batch);
LOG(ERROR) << "Processed " << count << " files.";
delete batch;
batch = new leveldb::WriteBatch();
}
}
// write the last batch
if (count % 1000 != 0) {
db->Write(leveldb::WriteOptions(), batch);
LOG(ERROR) << "Processed " << count << " files.";
}
delete batch;
delete db;
return 0;
}
void DataReader::Body::read_one(db::Cursor* cursor, db::Transaction* dblt, QueuePair* qp) {
Datum* datum = qp->free_.pop();
// TODO deserialize in-place instead of copy?
datum->ParseFromString(cursor->value());
if (dblt != NULL) {
string labels;
CHECK_EQ(dblt->Get(cursor->key(), labels), 0);
Datum labelDatum;
labelDatum.ParseFromString(labels);
// datum->MergeFrom(labelDatum);
datum->set_channels(datum->channels() + labelDatum.channels());
datum->mutable_float_data()->MergeFrom(labelDatum.float_data());
datum->mutable_data()->append(labelDatum.data());
}
qp->full_.push(datum);
// go to the next iter
cursor->Next();
if (!cursor->valid()) {
DLOG(INFO) << "Restarting data prefetching from start.";
cursor->SeekToFirst();
}
}
int main(int argc, char** argv) {
#ifdef USE_OPENCV
::google::InitGoogleLogging(argv[0]);
// Print output to stderr (while still logging)
FLAGS_alsologtostderr = 1;
#ifndef GFLAGS_GFLAGS_H_
namespace gflags = google;
#endif
gflags::SetUsageMessage("Convert a set of images to the leveldb/lmdb\n"
"format used as input for Caffe.\n"
"Usage:\n"
" convert_imageset [FLAGS] ROOTFOLDER/ LISTFILE DB_NAME");
gflags::ParseCommandLineFlags(&argc, &argv, true);
if (argc < 4) {
gflags::ShowUsageWithFlagsRestrict(argv[0], "convert_imageset");
return 1;
}
const bool is_color = !FLAGS_gray;
const bool check_size = FLAGS_check_size;
const bool encoded = FLAGS_encoded;
const string encode_type = FLAGS_encode_type;
std::ifstream infile(argv[2]);
std::vector<std::pair<std::string, int> > lines;
std::string filename;
int label;
while (infile >> filename >> label) {
lines.push_back(std::make_pair(filename, label));
}
if (FLAGS_shuffle) {
// randomly shuffle data
LOG(INFO) << "Shuffling data";
shuffle(lines.begin(), lines.end());
}
LOG(INFO) << "A total of " << lines.size() << " images.";
if (encode_type.size() && !encoded)
LOG(INFO) << "encode_type specified, assuming encoded=true.";
int resize_height = std::max<int>(0, FLAGS_resize_height);
int resize_width = std::max<int>(0, FLAGS_resize_width);
// Create new DB
scoped_ptr<db::DB> db(db::GetDB(FLAGS_backend));
db->Open(argv[3], db::NEW);
scoped_ptr<db::Transaction> txn(db->NewTransaction());
// Storing to db
std::string root_folder(argv[1]);
Datum datum;
int count = 0;
int data_size = 0;
bool data_size_initialized = false;
for (int line_id = 0; line_id < lines.size(); ++line_id) {
bool status;
std::string enc = encode_type;
if (encoded && !enc.size()) {
// Guess the encoding type from the file name
string fn = lines[line_id].first;
size_t p = fn.rfind('.');
if ( p == fn.npos )
LOG(WARNING) << "Failed to guess the encoding of '" << fn << "'";
enc = fn.substr(p);
std::transform(enc.begin(), enc.end(), enc.begin(), ::tolower);
}
status = ReadImageToDatum(root_folder + lines[line_id].first,
lines[line_id].second, resize_height, resize_width, is_color,
enc, &datum);
if (status == false) continue;
if (check_size) {
if (!data_size_initialized) {
data_size = datum.channels() * datum.height() * datum.width();
data_size_initialized = true;
} else {
const std::string& data = datum.data();
CHECK_EQ(data.size(), data_size) << "Incorrect data field size "
<< data.size();
}
}
// sequential
string key_str = caffe::format_int(line_id, 8) + "_" + lines[line_id].first;
// Put in db
string out;
CHECK(datum.SerializeToString(&out));
txn->Put(key_str, out);
if (++count % 1000 == 0) {
// Commit db
txn->Commit();
txn.reset(db->NewTransaction());
LOG(INFO) << "Processed " << count << " files.";
}
}
// write the last batch
if (count % 1000 != 0) {
txn->Commit();
LOG(INFO) << "Processed " << count << " files.";
}
#else
LOG(FATAL) << "This tool requires OpenCV; compile with USE_OPENCV.";
#endif // USE_OPENCV
return 0;
}
int feature_extraction_pipeline(int argc, char** argv) {
::google::InitGoogleLogging(argv[0]);
const int num_required_args = 7;
if (argc < num_required_args) {
LOG(ERROR)<<
"This program takes in a trained network and an input data layer, and then"
" extract features of the input data produced by the net.\n"
"Usage: extract_features pretrained_net_param"
" feature_extraction_proto_file extract_feature_blob_name1[,name2,...]"
" save_feature_dataset_name1[,name2,...] num_mini_batches db_type"
" [CPU/GPU] [DEVICE_ID=0]\n"
"Note: you can extract multiple features in one pass by specifying"
" multiple feature blob names and dataset names seperated by ','."
" The names cannot contain white space characters and the number of blobs"
" and datasets must be equal.";
return 1;
}
int arg_pos = num_required_args;
arg_pos = num_required_args;
if (argc > arg_pos && strcmp(argv[arg_pos], "GPU") == 0) {
LOG(ERROR)<< "Using GPU";
uint device_id = 0;
if (argc > arg_pos + 1) {
device_id = atoi(argv[arg_pos + 1]);
CHECK_GE(device_id, 0);
}
LOG(ERROR) << "Using Device_id=" << device_id;
Caffe::SetDevice(device_id);
Caffe::set_mode(Caffe::GPU);
} else {
LOG(ERROR) << "Using CPU";
Caffe::set_mode(Caffe::CPU);
}
arg_pos = 0; // the name of the executable
std::string pretrained_binary_proto(argv[++arg_pos]);
// Expected prototxt contains at least one data layer such as
// the layer data_layer_name and one feature blob such as the
// fc7 top blob to extract features.
/*
layers {
name: "data_layer_name"
type: DATA
data_param {
source: "/path/to/your/images/to/extract/feature/images_leveldb"
mean_file: "/path/to/your/image_mean.binaryproto"
batch_size: 128
crop_size: 227
mirror: false
}
top: "data_blob_name"
top: "label_blob_name"
}
layers {
name: "drop7"
type: DROPOUT
dropout_param {
dropout_ratio: 0.5
}
bottom: "fc7"
top: "fc7"
}
*/
std::string feature_extraction_proto(argv[++arg_pos]);
shared_ptr<Net<Dtype> > feature_extraction_net(
new Net<Dtype>(feature_extraction_proto, caffe::TEST));
feature_extraction_net->CopyTrainedLayersFrom(pretrained_binary_proto);
std::string extract_feature_blob_names(argv[++arg_pos]);
std::vector<std::string> blob_names;
boost::split(blob_names, extract_feature_blob_names, boost::is_any_of(","));
std::string save_feature_dataset_names(argv[++arg_pos]);
std::vector<std::string> dataset_names;
boost::split(dataset_names, save_feature_dataset_names,
boost::is_any_of(","));
CHECK_EQ(blob_names.size(), dataset_names.size()) <<
" the number of blob names and dataset names must be equal";
size_t num_features = blob_names.size();
for (size_t i = 0; i < num_features; i++) {
CHECK(feature_extraction_net->has_blob(blob_names[i]))
<< "Unknown feature blob name " << blob_names[i]
<< " in the network " << feature_extraction_proto;
}
int num_mini_batches = atoi(argv[++arg_pos]);
std::vector<shared_ptr<db::DB> > feature_dbs;
std::vector<shared_ptr<db::Transaction> > txns;
const char* db_type = argv[++arg_pos];
for (size_t i = 0; i < num_features; ++i) {
LOG(INFO)<< "Opening dataset " << dataset_names[i];
shared_ptr<db::DB> db(db::GetDB(db_type));
db->Open(dataset_names.at(i), db::NEW);
feature_dbs.push_back(db);
shared_ptr<db::Transaction> txn(db->NewTransaction());
txns.push_back(txn);
}
LOG(ERROR)<< "Extacting Features";
Datum datum;
const int kMaxKeyStrLength = 100;
char key_str[kMaxKeyStrLength];
std::vector<Blob<float>*> input_vec;
std::vector<int> image_indices(num_features, 0);
for (int batch_index = 0; batch_index < num_mini_batches; ++batch_index) {
feature_extraction_net->Forward(input_vec);
for (int i = 0; i < num_features; ++i) {
const shared_ptr<Blob<Dtype> > feature_blob = feature_extraction_net
->blob_by_name(blob_names[i]);
int batch_size = feature_blob->num();
int dim_features = feature_blob->count() / batch_size;
const Dtype* feature_blob_data;
for (int n = 0; n < batch_size; ++n) {
datum.set_height(feature_blob->height());
datum.set_width(feature_blob->width());
datum.set_channels(feature_blob->channels());
datum.clear_data();
datum.clear_float_data();
feature_blob_data = feature_blob->cpu_data() +
feature_blob->offset(n);
for (int d = 0; d < dim_features; ++d) {
datum.add_float_data(feature_blob_data[d]);
}
// int length = snprintf(key_str, kMaxKeyStrLength, "%08d",
int length = snprintf(key_str, kMaxKeyStrLength, "%010d",
image_indices[i]);
string out;
CHECK(datum.SerializeToString(&out));
txns.at(i)->Put(std::string(key_str, length), out);
++image_indices[i];
if (image_indices[i] % 1000 == 0) {
txns.at(i)->Commit();
txns.at(i).reset(feature_dbs.at(i)->NewTransaction());
LOG(ERROR)<< "Extracted features of " << image_indices[i] <<
" query images for feature blob " << blob_names[i];
}
} // for (int n = 0; n < batch_size; ++n)
} // for (int i = 0; i < num_features; ++i)
} // for (int batch_index = 0; batch_index < num_mini_batches; ++batch_index)
// write the last batch
for (int i = 0; i < num_features; ++i) {
if (image_indices[i] % 1000 != 0) {
txns.at(i)->Commit();
}
LOG(ERROR)<< "Extracted features of " << image_indices[i] <<
" query images for feature blob " << blob_names[i];
feature_dbs.at(i)->Close();
}
LOG(ERROR)<< "Successfully extracted the features!";
return 0;
}
int main(int argc, char** argv) {
::google::InitGoogleLogging(argv[0]);
#ifndef GFLAGS_GFLAGS_H_
namespace gflags = google;
#endif
gflags::SetUsageMessage("Convert a set of images to the leveldb/lmdb\n"
"format used as input for Caffe.\n"
"Usage:\n"
" convert_imageset [FLAGS] ROOTFOLDER/ LISTFILE DB_NAME\n"
"The ImageNet dataset for the training demo is at\n"
" http://www.image-net.org/download-images\n");
gflags::ParseCommandLineFlags(&argc, &argv, true);
if (argc < 4) {
gflags::ShowUsageWithFlagsRestrict(argv[0], "tools/convert_imageset");
return 1;
}
const bool is_color = !FLAGS_gray;
const bool check_size = FLAGS_check_size;
const bool encoded = FLAGS_encoded;
std::ifstream infile(argv[2]);
std::vector<std::pair<std::string, int> > lines;
std::string filename;
int label;
while (infile >> filename >> label) {
lines.push_back(std::make_pair(filename, label));
}
if (FLAGS_shuffle) {
// randomly shuffle data
LOG(INFO) << "Shuffling data";
shuffle(lines.begin(), lines.end());
}
LOG(INFO) << "A total of " << lines.size() << " images.";
if (encoded) {
CHECK_EQ(FLAGS_resize_height, 0) << "With encoded don't resize images";
CHECK_EQ(FLAGS_resize_width, 0) << "With encoded don't resize images";
CHECK(!check_size) << "With encoded cannot check_size";
}
int resize_height = std::max<int>(0, FLAGS_resize_height);
int resize_width = std::max<int>(0, FLAGS_resize_width);
// Create new DB
scoped_ptr<db::DB> db(db::GetDB(FLAGS_backend));
db->Open(argv[3], db::NEW);
scoped_ptr<db::Transaction> txn(db->NewTransaction());
// Storing to db
std::string root_folder(argv[1]);
Datum datum;
int count = 0;
const int kMaxKeyLength = 256;
char key_cstr[kMaxKeyLength];
int data_size;
bool data_size_initialized = false;
for (int line_id = 0; line_id < lines.size(); ++line_id) {
bool status;
if (encoded) {
status = ReadFileToDatum(root_folder + lines[line_id].first,
lines[line_id].second, &datum);
} else {
status = ReadImageToDatum(root_folder + lines[line_id].first,
lines[line_id].second, resize_height, resize_width, is_color, &datum);
}
if (status == false) continue;
if (check_size) {
if (!data_size_initialized) {
data_size = datum.channels() * datum.height() * datum.width();
data_size_initialized = true;
} else {
const std::string& data = datum.data();
CHECK_EQ(data.size(), data_size) << "Incorrect data field size "
<< data.size();
}
}
// sequential
int length = snprintf(key_cstr, kMaxKeyLength, "%08d_%s", line_id,
lines[line_id].first.c_str());
// Put in db
string out;
CHECK(datum.SerializeToString(&out));
txn->Put(string(key_cstr, length), out);
if (++count % 1000 == 0) {
// Commit db
txn->Commit();
txn.reset(db->NewTransaction());
LOG(ERROR) << "Processed " << count << " files.";
}
}
// write the last batch
if (count % 1000 != 0) {
txn->Commit();
LOG(ERROR) << "Processed " << count << " files.";
}
return 0;
}
void Lingo::setTheSprite(Datum &id1, int field, Datum &d) {
int id = 0;
if (id1.type == INT) {
id = id1.u.i;
} else {
warning("Unknown the sprite id type: %s", id1.type2str());
return;
}
d.toInt(); // Enforce Integer
if (!_vm->_currentScore) {
warning("The sprite %d field %d setting over non-active score", id, field);
return;
}
Sprite *sprite = _vm->_currentScore->getSpriteById(id);
if (!sprite)
return;
switch (field) {
case kTheCastNum:
if (_vm->_currentScore->_casts.contains(d.u.i)) {
sprite->_cast = _vm->_currentScore->_casts[d.u.i];
sprite->_castId = d.u.i;
}
break;
case kTheWidth:
sprite->_width = d.u.i;
break;
case kTheHeight:
sprite->_height = d.u.i;
break;
case kTheTrails:
sprite->_trails = d.u.i;
break;
case kTheInk:
sprite->_ink = static_cast<InkType>(d.u.i);
break;
case kTheLocH:
sprite->_startPoint.x = d.u.i;
break;
case kTheLocV:
sprite->_startPoint.y = d.u.i;
break;
case kTheConstraint:
sprite->_constraint = d.u.i;
break;
case kTheMoveable:
sprite->_moveable = d.u.i;
break;
case kTheBackColor:
sprite->_backColor = d.u.i;
break;
case kTheForeColor:
sprite->_foreColor = d.u.i;
break;
case kTheLeft:
sprite->_left = d.u.i;
break;
case kTheRight:
sprite->_right = d.u.i;
break;
case kTheTop:
sprite->_top = d.u.i;
break;
case kTheBottom:
sprite->_bottom = d.u.i;
break;
case kTheBlend:
sprite->_blend = d.u.i;
break;
case kTheVisible:
sprite->_visible = (d.u.i == 0 ? false : true);
break;
case kTheType:
sprite->_type = static_cast<SpriteType>(d.u.i);
break;
case kTheMovieRate:
sprite->_movieRate = d.u.i;
break;
case kTheMovieTime:
sprite->_movieTime = d.u.i;
break;
case kTheStopTime:
sprite->_stopTime = d.u.i;
break;
case kTheStartTime:
sprite->_startTime = d.u.i;
break;
case kTheStretch:
sprite->_stretch = d.u.i;
break;
case kTheVolume:
sprite->_volume = d.u.i;
break;
case kTheLineSize:
sprite->_lineSize = d.u.i;
break;
case kTheEditableText:
sprite->_editableText = *d.toString();
break;
default:
warning("Unprocessed setting field %d of sprite", field);
}
}
void DataLstmTrainHistLayer<Dtype>::InternalThreadEntry() {
CPUTimer batch_timer;
batch_timer.Start();
double read_time = 0;
double trans_time = 0;
CPUTimer timer;
CHECK(this->prefetch_data_.count());
Datum datum;
Dtype* top_data = this->prefetch_data_.mutable_cpu_data();
Dtype* top_label = this->prefetch_label_.mutable_cpu_data();
Dtype* top_hist = this->prefetch_hist_.mutable_cpu_data();
Dtype* top_marker = this->prefetch_marker_.mutable_cpu_data();
// datum scales
const int size = resize_height*resize_width*3;
const Dtype* mean = this->data_mean_.mutable_cpu_data();
string value;
const int kMaxKeyLength = 256;
char key_cstr[kMaxKeyLength];
int key;
const int sequence_size = this->layer_param_.data_lstm_train_hist_param().sequence_size();
const int ind_seq_num=this->layer_param_.data_lstm_train_hist_param().sequence_num();
const int interval=this->layer_param_.data_lstm_train_hist_param().interval();
int item_id;
for (int time_id = 0; time_id < sequence_size; ++time_id) {
for (int seq_id = 0; seq_id < ind_seq_num; ++seq_id) {
item_id=time_id*ind_seq_num+seq_id;
timer.Start();
// get a blob
key=buffer_key[seq_id]; // MUST be changed according to the size of the training set
snprintf(key_cstr, kMaxKeyLength, "%08d", key);
db_->Get(leveldb::ReadOptions(), string(key_cstr), &value);
datum.ParseFromString(value);
const string& data = datum.data();
read_time += timer.MicroSeconds();
timer.Start();
for (int j = 0; j < size; ++j) {
Dtype datum_element = static_cast<Dtype>(static_cast<uint8_t>(data[j]));
top_data[item_id * size + j] = (datum_element - mean[j]);
}
for (int j = 0; j < para_dim; ++j) {
top_label[item_id * para_dim + j] = datum.float_data(j);
}
top_marker[item_id] = datum.float_data(para_dim);
if (buffer_marker[seq_id] == 0) {
top_marker[item_id] = 0;
buffer_marker[seq_id] = 1;
}
//////////////////////////////////// for hist
if (top_marker[item_id] < 0.5) {
for (int j = 0; j < para_dim; ++j)
top_hist[item_id * para_dim + j] = 0;
} else {
if (time_id == 0) {
top_hist[item_id * para_dim + 0] = hist_blob[seq_id * para_dim + 0]/1.1+0.5;
top_hist[item_id * para_dim + 1] = hist_blob[seq_id * para_dim + 1]*0.17778+1.34445;
top_hist[item_id * para_dim + 2] = hist_blob[seq_id * para_dim + 2]*0.14545+0.39091;
top_hist[item_id * para_dim + 3] = hist_blob[seq_id * para_dim + 3]*0.17778-0.34445;
top_hist[item_id * para_dim + 4] = hist_blob[seq_id * para_dim + 4]/95.0+0.12;
top_hist[item_id * para_dim + 5] = hist_blob[seq_id * para_dim + 5]/95.0+0.12;
top_hist[item_id * para_dim + 6] = hist_blob[seq_id * para_dim + 6]*0.14545+1.48181;
top_hist[item_id * para_dim + 7] = hist_blob[seq_id * para_dim + 7]*0.16+0.98;
top_hist[item_id * para_dim + 8] = hist_blob[seq_id * para_dim + 8]*0.16+0.02;
top_hist[item_id * para_dim + 9] = hist_blob[seq_id * para_dim + 9]*0.14545-0.48181;
top_hist[item_id * para_dim + 10] = hist_blob[seq_id * para_dim + 10]/95.0+0.12;
top_hist[item_id * para_dim + 11] = hist_blob[seq_id * para_dim + 11]/95.0+0.12;
top_hist[item_id * para_dim + 12] = hist_blob[seq_id * para_dim + 12]/95.0+0.12;
top_hist[item_id * para_dim + 13] = hist_blob[seq_id * para_dim + 13]*0.6+0.2;
} else {
int pre_id=(time_id-1)*ind_seq_num+seq_id;
top_hist[item_id * para_dim + 0] = top_label[pre_id * para_dim + 0]/1.1+0.5;
top_hist[item_id * para_dim + 1] = top_label[pre_id * para_dim + 1]*0.17778+1.34445;
top_hist[item_id * para_dim + 2] = top_label[pre_id * para_dim + 2]*0.14545+0.39091;
top_hist[item_id * para_dim + 3] = top_label[pre_id * para_dim + 3]*0.17778-0.34445;
top_hist[item_id * para_dim + 4] = top_label[pre_id * para_dim + 4]/95.0+0.12;
top_hist[item_id * para_dim + 5] = top_label[pre_id * para_dim + 5]/95.0+0.12;
top_hist[item_id * para_dim + 6] = top_label[pre_id * para_dim + 6]*0.14545+1.48181;
top_hist[item_id * para_dim + 7] = top_label[pre_id * para_dim + 7]*0.16+0.98;
top_hist[item_id * para_dim + 8] = top_label[pre_id * para_dim + 8]*0.16+0.02;
top_hist[item_id * para_dim + 9] = top_label[pre_id * para_dim + 9]*0.14545-0.48181;
top_hist[item_id * para_dim + 10] = top_label[pre_id * para_dim + 10]/95.0+0.12;
top_hist[item_id * para_dim + 11] = top_label[pre_id * para_dim + 11]/95.0+0.12;
top_hist[item_id * para_dim + 12] = top_label[pre_id * para_dim + 12]/95.0+0.12;
top_hist[item_id * para_dim + 13] = top_label[pre_id * para_dim + 13]*0.6+0.2;
}
}
//////////////////////////////////// for hist
trans_time += timer.MicroSeconds();
buffer_key[seq_id]++;
buffer_total[seq_id]++;
if (buffer_key[seq_id]>total_frames || buffer_total[seq_id]>interval) {
buffer_key[seq_id]=random(total_frames)+1;
buffer_marker[seq_id]=0;
buffer_total[seq_id]=0;
}
//////////////////////////////////// for hist
if (time_id==sequence_size-1) {
for (int j = 0; j < para_dim; ++j)
hist_blob[seq_id * para_dim + j] = datum.float_data(j);
}
//////////////////////////////////// for hist
/*
if (seq_id == 0) {
for (int h = 0; h < resize_height; ++h) {
for (int w = 0; w < resize_width; ++w) {
leveldbTrain->imageData[(h*resize_width+w)*3+0]=(uint8_t)data[h*resize_width+w];
leveldbTrain->imageData[(h*resize_width+w)*3+1]=(uint8_t)data[resize_height*resize_width+h*resize_width+w];
leveldbTrain->imageData[(h*resize_width+w)*3+2]=(uint8_t)data[resize_height*resize_width*2+h*resize_width+w];
//leveldbTrain->imageData[(h*resize_width+w)*3+0]=(uint8_t)top_data[item_id * size+h*resize_width+w];
//leveldbTrain->imageData[(h*resize_width+w)*3+1]=(uint8_t)top_data[item_id * size+resize_height*resize_width+h*resize_width+w];
//leveldbTrain->imageData[(h*resize_width+w)*3+2]=(uint8_t)top_data[item_id * size+resize_height*resize_width*2+h*resize_width+w];
}
}
cvShowImage("Image from leveldb", leveldbTrain);
cvWaitKey( 1 );
}
*/
}
}
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.";
}
Datum Lingo::getTheSprite(Datum &id1, int field) {
Datum d;
int id = 0;
if (id1.type == INT) {
id = id1.u.i;
} else {
warning("Unknown the sprite id type: %s", id1.type2str());
return d;
}
if (!_vm->_currentScore) {
warning("The sprite %d field %d setting over non-active score", id, field);
return d;
}
Sprite *sprite = _vm->_currentScore->getSpriteById(id);
if (!sprite)
return d;
d.type = INT;
switch (field) {
case kTheCastNum:
d.u.i = sprite->_castId;
break;
case kTheWidth:
d.u.i = sprite->_width;
break;
case kTheHeight:
d.u.i = sprite->_height;
break;
case kTheTrails:
d.u.i = sprite->_trails;
break;
case kTheInk:
d.u.i = sprite->_ink;
break;
case kTheLocH:
d.u.i = sprite->_startPoint.x;
break;
case kTheLocV:
d.u.i = sprite->_startPoint.y;
break;
case kTheConstraint:
d.u.i = sprite->_constraint;
break;
case kTheMoveable:
d.u.i = sprite->_moveable;
break;
case kTheBackColor:
d.u.i = sprite->_backColor;
break;
case kTheForeColor:
d.u.i = sprite->_foreColor;
break;
case kTheLeft:
d.u.i = sprite->_left;
break;
case kTheRight:
d.u.i = sprite->_right;
break;
case kTheBottom:
d.u.i = sprite->_bottom;
break;
case kTheTop:
d.u.i = sprite->_top;
break;
case kTheBlend:
d.u.i = sprite->_blend;
break;
case kTheVisible:
d.u.i = (sprite->_visible ? 1 : 0);
break;
case kTheType:
d.u.i = sprite->_type;
break;
case kTheMovieRate:
d.u.i = sprite->_movieRate;
break;
case kTheMovieTime:
d.u.i = sprite->_movieTime;
break;
case kTheStopTime:
d.u.i = sprite->_stopTime;
break;
case kTheStartTime:
d.u.i = sprite->_startTime;
break;
case kTheVolume:
d.u.i = sprite->_volume;
break;
case kTheStretch:
d.u.i = sprite->_stretch;
break;
case kTheLineSize:
d.u.i = sprite->_lineSize;
break;
case kTheEditableText:
d.toString();
d.u.s = &sprite->_editableText;
break;
default:
warning("Unprocessed getting field %d of sprite", field);
d.type = VOID;
}
return d;
}
void DataLstmTrainHistLayer<Dtype>::DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
// Initialize DB
leveldb::DB* db_temp;
leveldb::Options options;
options.max_open_files = 100;
options.create_if_missing = false;
LOG(INFO) << "Opening leveldb " << this->layer_param_.data_lstm_train_hist_param().source();
leveldb::Status status = leveldb::DB::Open(
options, this->layer_param_.data_lstm_train_hist_param().source(), &db_temp);
CHECK(status.ok()) << "Failed to open leveldb "
<< this->layer_param_.data_lstm_train_hist_param().source() << std::endl
<< status.ToString();
db_.reset(db_temp);
// Read a data point, to initialize the prefetch and top blobs.
string value;
const int kMaxKeyLength = 256;
char key_cstr[kMaxKeyLength];
srand((int)time(0));
snprintf(key_cstr, kMaxKeyLength, "%08d", 1);
db_->Get(leveldb::ReadOptions(), string(key_cstr), &value);
Datum datum;
datum.ParseFromString(value);
const int ind_seq_num=this->layer_param_.data_lstm_train_hist_param().sequence_num();
buffer_key.clear();
buffer_marker.clear();
buffer_total.clear();
hist_blob.clear();
for (int i=0;i<ind_seq_num;i++) {
int tmp=random(total_frames)+1;
buffer_key.push_back(tmp);
buffer_marker.push_back(0);
buffer_total.push_back(0);
for (int j = 0; j < para_dim; ++j)
hist_blob.push_back(0);
}
int batch_size=this->layer_param_.data_lstm_train_hist_param().sequence_size()*ind_seq_num;
// image
top[0]->Reshape(batch_size, datum.channels(), datum.height(), datum.width());
this->prefetch_data_.Reshape(batch_size, datum.channels(), datum.height(), datum.width());
LOG(INFO) << "output data size: " << top[0]->num() << ","
<< top[0]->channels() << "," << top[0]->height() << ","
<< top[0]->width();
// label
top[1]->Reshape(batch_size, 1, 1, para_dim);
this->prefetch_label_.Reshape(batch_size, 1, 1, para_dim);
// hist
top[2]->Reshape(batch_size, 1, 1, para_dim);
this->prefetch_hist_.Reshape(batch_size, 1, 1, para_dim);
// marker
top[3]->Reshape(batch_size, 1, 1, 1);
this->prefetch_marker_.Reshape(batch_size, 1, 1, 1);
const string& mean_file = this->layer_param_.data_lstm_train_hist_param().mean_file();
LOG(INFO) << "Loading mean file from: " << mean_file;
BlobProto blob_proto;
ReadProtoFromBinaryFileOrDie(mean_file.c_str(), &blob_proto);
data_mean_.FromProto(blob_proto);
}
void Lingo::setTheCast(Datum &id1, int field, Datum &d) {
int id = 0;
if (id1.type == INT) {
id = id1.u.i;
} else {
warning("Unknown the cast id type: %s", id1.type2str());
return;
}
if (!_vm->_currentScore) {
warning("The cast %d field %d setting over non-active score", id, field);
return;
}
Cast *cast = _vm->_currentScore->_casts[id];
CastInfo *castInfo = _vm->_currentScore->_castsInfo[id];
if (!cast) {
warning("The cast %d found", id);
return;
}
switch (field) {
case kTheCastType:
cast->type = static_cast<CastType>(d.u.i);
cast->modified = 1;
break;
case kTheFilename:
castInfo->fileName = *d.u.s;
break;
case kTheName:
castInfo->name = *d.u.s;
break;
case kTheScriptText:
castInfo->script = *d.u.s;
break;
case kTheWidth:
cast->initialRect.setWidth(d.u.i);
cast->modified = 1;
break;
case kTheHeight:
cast->initialRect.setHeight(d.u.i);
cast->modified = 1;
break;
case kTheBackColor:
{
if (cast->type != kCastShape) {
warning("Field %d of cast %d not found", field, id);
}
ShapeCast *shape = static_cast<ShapeCast *>(_vm->_currentScore->_casts[id]);
shape->bgCol = d.u.i;
shape->modified = 1;
}
break;
case kTheForeColor:
{
if (cast->type != kCastShape) {
warning("Field %d of cast %d not found", field, id);
return;
}
ShapeCast *shape = static_cast<ShapeCast *>(_vm->_currentScore->_casts[id]);
shape->fgCol = d.u.i;
shape->modified = 1;
}
break;
default:
warning("Unprocessed getting field %d of cast %d", field, id);
}
}
void VideoDataLayer<Dtype>:: DataLayerSetUp(const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
const int new_height = this->layer_param_.video_data_param().new_height();
const int new_width = this->layer_param_.video_data_param().new_width();
const int new_length = this->layer_param_.video_data_param().new_length();
const int num_segments = this->layer_param_.video_data_param().num_segments();
const string& source = this->layer_param_.video_data_param().source();
LOG(INFO) << "Opening file: " << source;
std:: ifstream infile(source.c_str());
string filename;
int label;
int length;
while (infile >> filename >> length >> label) {
lines_.push_back(std::make_pair(filename,label));
lines_duration_.push_back(length);
}
if (this->layer_param_.video_data_param().shuffle()) {
const unsigned int prefectch_rng_seed = caffe_rng_rand();
prefetch_rng_1_.reset(new Caffe::RNG(prefectch_rng_seed));
prefetch_rng_2_.reset(new Caffe::RNG(prefectch_rng_seed));
ShuffleVideos();
}
LOG(INFO) << "A total of " << lines_.size() << " videos.";
lines_id_ = 0;
Datum datum;
const unsigned int frame_prefectch_rng_seed = caffe_rng_rand();
frame_prefetch_rng_.reset(new Caffe::RNG(frame_prefectch_rng_seed));
int average_duration = (int) lines_duration_[lines_id_]/num_segments;
vector<int> offsets;
for (int i = 0; i < num_segments; ++i) {
caffe::rng_t* frame_rng = static_cast<caffe::rng_t*>(frame_prefetch_rng_->generator());
int offset = (*frame_rng)() % (average_duration - new_length + 1);
offsets.push_back(offset+i*average_duration);
}
if (this->layer_param_.video_data_param().modality() == VideoDataParameter_Modality_FLOW)
CHECK(ReadSegmentFlowToDatum(lines_[lines_id_].first, lines_[lines_id_].second, offsets, new_height, new_width, new_length, &datum));
else
CHECK(ReadSegmentRGBToDatum(lines_[lines_id_].first, lines_[lines_id_].second, offsets, new_height, new_width, new_length, &datum, true));
const int crop_size = this->layer_param_.transform_param().crop_size();
const int batch_size = this->layer_param_.video_data_param().batch_size();
if (crop_size > 0) {
top[0]->Reshape(batch_size, datum.channels(), crop_size, crop_size);
//this->prefetch_data_.Reshape(batch_size, datum.channels(), crop_size, crop_size);
for (int i = 0; i < this->PREFETCH_COUNT; ++i) {
this->prefetch_[i].data_.Reshape(batch_size, datum.channels(),
crop_size, crop_size);
}
} else {
top[0]->Reshape(batch_size, datum.channels(), datum.height(), datum.width());
//this->prefetch_data_.Reshape(batch_size, datum.channels(), datum.height(), datum.width());
for (int i = 0; i < this->PREFETCH_COUNT; ++i) {
this->prefetch_[i].data_.Reshape(batch_size, datum.channels(),
crop_size, crop_size);
}
}
LOG(INFO) << "output data size: " << top[0]->num() << "," << top[0]->channels() << "," << top[0]->height() << "," << top[0]->width();
top[1]->Reshape(batch_size, 1, 1, 1);
//this->prefetch_label_.Reshape(batch_size, 1, 1, 1);
for (int i = 0; i < this->PREFETCH_COUNT; ++i) {
this->prefetch_[i].label_.Reshape(batch_size, 1, 1, 1);
}
//vector<int> top_shape = this->data_transformer_->InferBlobShape(datum);
// JFMOD
// the old data transformer doesn't suppoer the infer bolobfcn
//int crop_size = 224;
// vector<int> top_shape(4);
// top_shape[0] = 1;
// top_shape[1] = datum.channels();
// top_shape[2] = (crop_size)? crop_size: datum.height();
// top_shape[3] = (crop_size)? crop_size: datum.width();
//this->transformed_data_.Reshape(top_shape);
this->transformed_data_.Reshape(1, datum.channels(),
crop_size, crop_size);
}
