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