void load_dataset2(string &ds_name, string &data_fname, string &labels_fname) {
// file names
string classes_fname;
string scales_fname;
string classpairs_fname;
string deformpairs_fname;
// // boolean successes of files loading
// bool bdefpairs = true;
// bool bclasspairs = true;
// data files
idx<Tdata> data;
midx<Tdata> datas;
idx<Tlabel> labels;
idx<ubyte> classes;
idx<intg> scales;
idx<intg> classpairs;
idx<intg> defpairs;
// build file names
build_fname(ds_name, CLASSES_NAME, classes_fname);
build_fname(ds_name, SCALES_NAME, scales_fname);
build_fname(ds_name, CLASSPAIRS_NAME, classpairs_fname);
build_fname(ds_name, DEFORMPAIRS_NAME, deformpairs_fname);
// // check format of data file
// bool multimat = has_multiple_matrices(data_fname.c_str());
// // if size is defined, only load data and print dimensions
// if (size) {
// if (multimat) {
// datas = load_matrices<Tdata>(data_fname);
// cout << datas.dim(0) << endl;
// } else {
// data = load_matrix<Tdata>(data_fname);
// cout << data.dim(0) << endl;
// }
// return ;
// }
// // load data
// if (multimat)
// datas = load_matrices<Tdata>(data_fname);
// else
// data = load_matrix<Tdata>(data_fname);
// loading_error(labels, labels_fname);
// loading_warning(classes, classes_fname);
// loading_warning(scales, scales_fname);
// bclasspairs = loading_nowarning(classpairs, classpairs_fname);
// bdefpairs = loading_nowarning(defpairs, deformpairs_fname);
// // display only 1 channel
// if (channel >= 0) {
// if (multimat)
// eblerror("showing only 1 channel is not supported with "
// << "multimats yet (TODO)");
// if (channel >= data.dim(1)) {
// cerr << "trying to select channel " << channel
// << " but channel dimension is of size " << data.dim(0)
// << " (in " << data << ")." << endl;
// eblerror("trying to select unknown channel dimension");
// }
// data = data.select(1, channel);
// }
class_datasource<Tdata, Tdata, Tlabel> *train_ds =
new class_datasource<Tdata,Tdata,Tlabel>
(data_fname.c_str(), labels_fname.c_str(), NULL,
scales_fname.c_str(), classes_fname.c_str(), "Dataset");
// // create datasource object
// class_datasource<Tdata, Tdata, Tlabel> *train_ds = NULL;
// if (multimat)
// train_ds = new class_datasource<Tdata, Tdata, Tlabel>(datas, labels, classes, "Dataset");
// else
// train_ds = new class_datasource<Tdata, Tdata, Tlabel>(data, labels, classes, "Dataset");
// display it
#ifdef __GUI__
if (!info) { // only display if info is false
// if (bclasspairs) {
// labeled_pair_datasource<Tdata, Tdata, Tlabel>
// train_cp_ds(data, labels, classes, classpairs,
// "Class pairs (training)");
// labeled_pair_datasource_gui<Tdata, Tdata, Tlabel> dsgui_cp(true);
// dsgui_cp.display(train_cp_ds, dims.dim(0), dims.dim(1),
// 0, 0, 1, -1, NULL, false,
// (Tdata) range[0], (Tdata) range[1]);
// secsleep(1);
// }
// if (bdefpairs) {
// labeled_pair_datasource<Tdata, Tdata, Tlabel>
// train_dp_ds(data, labels, classes, defpairs,
// "Deformation pairs (training)");
// labeled_pair_datasource_gui<Tdata, Tdata, Tlabel> dsgui_dp(true);
// dsgui_dp.display(train_dp_ds, dims.dim(0), dims.dim(1),
// 0, 0, 1, -1, NULL, false,
// (Tdata) range[0], (Tdata) range[1]);
// secsleep(1);
// }
labeled_datasource_gui<Tdata, Tdata, Tlabel> dsgui(true);
dsgui.display(*train_ds, dims.dim(0), dims.dim(1), 0, 0, 1, -1, NULL, false,
(Tdata) range[0], (Tdata) range[1]);
if (font_size > 0)
set_font_size(font_size);
secsleep(1);
}
delete train_ds;
#else
cerr << "warning: QT gui libraries not available, install them and recompile"
<< endl;
#endif
}
MAIN_QTHREAD(int, argc, char**, argv) {
#else
int main(int argc, char **argv) {
#endif
// names of dataset and files to load
string ds_name;
string data_fname;
// parse arguments
if (!parse_args(argc, argv, ds_name)) {
print_usage();
return -1;
}
if (!size) {
cout <<
"___________________________________________________________________";
cout << endl << endl;
cout << " Dataset display for libeblearn library " << endl;
cout <<
"___________________________________________________________________";
cout << endl;
// print info
cout << "input parameters:" << endl;
cout << " dataset name: " << ds_name << endl;
cout << " info only: " << (info ? "yes" : "no") << endl;
cout << " size only: " << (size ? "yes" : "no") << endl;
cout << " values range: ";
for (vector<double>::iterator i = range.begin(); i != range.end(); ++i)
cout << *i << " ";
cout << endl;
cout << " display dimensions: " << dims << endl;
cout << " font size: " << font_size << endl;
cout <<
"___________________________________________________________________";
cout << endl;
}
// build file names
build_fname(ds_name, DATA_NAME, data_fname);
// select data type
try {
switch (get_matrix_type(data_fname.c_str())) {
case MAGIC_BYTE_MATRIX:
case MAGIC_UBYTE_VINCENT:
load_dataset1<ubyte>(ds_name, data_fname);
break ;
case MAGIC_INTEGER_MATRIX:
case MAGIC_INT_VINCENT:
load_dataset1<int>(ds_name, data_fname);
break ;
case MAGIC_FLOAT_MATRIX:
case MAGIC_FLOAT_VINCENT:
load_dataset1<float>(ds_name, data_fname);
break ;
case MAGIC_DOUBLE_MATRIX:
case MAGIC_DOUBLE_VINCENT:
load_dataset1<double>(ds_name, data_fname);
break ;
case MAGIC_LONG_MATRIX:
load_dataset1<long>(ds_name, data_fname);
break ;
case MAGIC_UINT_MATRIX:
load_dataset1<uint>(ds_name, data_fname);
break ;
default:
eblerror("unknown magic number in data matrix");
}
} eblcatcherror();
secsleep(20);
return 0;
}
void mpijob_manager::run_master() {
#ifdef __MPI__
time.start();
// print info
string prefix = "master: ";
cout << prefix << "world has " << jslots
<< " slots (excluding master)." << endl;
cout << prefix << jobs.size() << " jobs to process." << endl;
// ask each slave if available
boost::mpi::request *reqs = new boost::mpi::request[world.size()];
int *running = new int[world.size()];
for (int i = 1; i < world.size(); ++i) {
world.isend(i, CMD_RUNNING, 0);
running[i] = -1; // not running initially
reqs[i] = world.irecv(i, CMD_RUNNING, running[i]);
}
jinfos(running);
unstarted = jobs.size();
// loop until all jobs are finished
while (nalive || unfinished > 0) {
// if there are jobs waiting to be started, start them if possible
for (uint i = 0; i < jobs.size(); ++i) {
// check status of job i from files
jobs[i]->check_finished();
jobs[i]->check_started();
jobs[i]->check_running();
// start job if not finished and not alive
if (!jobs[i]->finished() && !jobs[i]->running()) {
for (int j = 1; j < world.size(); ++j) {
// check if this slot has answered and what its answer is
if (reqs[j].test() && running[j] == -1) { // answer and free
cout << prefix << j << " is free" << endl;
if (!assign(i, j))
cerr << "failed to assign job " << i << " to slot "
<< j << endl;
else {
cout << "master: assigned job " << i
<< " to slot " << j << endl;
running[j] = i;
// re-ask if slot j is available for when its done
world.isend(j, CMD_RUNNING, 0);
reqs[j] = world.irecv(j, CMD_RUNNING, running[j]);
jinfos(running);
break ; // move to next job
}
}
}
}
}
jobs_info();
jinfos(running);
secsleep(swait);
report();
}
stop_all();
last_report();
delete running;
// deleting reqs makes the program crash
//delete reqs;
cout << "MPI master is finished after " << time.elapsed() << endl;
exit(0);
#endif
}
