bool CMulticlassLogisticRegression::train_machine(CFeatures* data)
{
if (data)
set_features((CDotFeatures*)data);
REQUIRE(m_features, "%s::train_machine(): No features attached!\n");
REQUIRE(m_labels, "%s::train_machine(): No labels attached!\n");
REQUIRE(m_labels->get_label_type()==LT_MULTICLASS, "%s::train_machine(): "
"Attached labels are no multiclass labels\n");
REQUIRE(m_multiclass_strategy, "%s::train_machine(): No multiclass strategy"
" attached!\n");
int32_t n_classes = ((CMulticlassLabels*)m_labels)->get_num_classes();
int32_t n_feats = m_features->get_dim_feature_space();
slep_options options = slep_options::default_options();
if (m_machines->get_num_elements()!=0)
{
SGMatrix<float64_t> all_w_old(n_feats, n_classes);
SGVector<float64_t> all_c_old(n_classes);
for (int32_t i=0; i<n_classes; i++)
{
CLinearMachine* machine = (CLinearMachine*)m_machines->get_element(i);
SGVector<float64_t> w = machine->get_w();
for (int32_t j=0; j<n_feats; j++)
all_w_old(j,i) = w[j];
all_c_old[i] = machine->get_bias();
SG_UNREF(machine);
}
options.last_result = new slep_result_t(all_w_old,all_c_old);
m_machines->reset_array();
}
options.tolerance = m_epsilon;
options.max_iter = m_max_iter;
slep_result_t result = slep_mc_plain_lr(m_features,(CMulticlassLabels*)m_labels,m_z,options);
SGMatrix<float64_t> all_w = result.w;
SGVector<float64_t> all_c = result.c;
for (int32_t i=0; i<n_classes; i++)
{
SGVector<float64_t> w(n_feats);
for (int32_t j=0; j<n_feats; j++)
w[j] = all_w(j,i);
float64_t c = all_c[i];
CLinearMachine* machine = new CLinearMachine();
machine->set_w(w);
machine->set_bias(c);
m_machines->push_back(machine);
}
return true;
}
int main(int argc, char ** argv)
{
init_shogun_with_defaults();
SGVector< float64_t > labs(NUM_CLASSES*NUM_SAMPLES);
SGMatrix< float64_t > feats(DIMS, NUM_CLASSES*NUM_SAMPLES);
gen_rand_data(labs, feats);
//read_data(labs, feats);
// Create train labels
CMulticlassSOLabels* labels = new CMulticlassSOLabels(labs);
CMulticlassLabels* mlabels = new CMulticlassLabels(labs);
// Create train features
CDenseFeatures< float64_t >* features = new CDenseFeatures< float64_t >(feats);
// Create structured model
CMulticlassModel* model = new CMulticlassModel(features, labels);
// Create loss function
CHingeLoss* loss = new CHingeLoss();
// Create SO-SVM
CPrimalMosekSOSVM* sosvm = new CPrimalMosekSOSVM(model, loss, labels);
CDualLibQPBMSOSVM* bundle = new CDualLibQPBMSOSVM(model, loss, labels, 1000);
bundle->set_verbose(false);
SG_REF(sosvm);
SG_REF(bundle);
CTime start;
float64_t t1;
sosvm->train();
SG_SPRINT(">>>> PrimalMosekSOSVM trained in %9.4f\n", (t1 = start.cur_time_diff(false)));
bundle->train();
SG_SPRINT(">>>> BMRM trained in %9.4f\n", start.cur_time_diff(false)-t1);
CStructuredLabels* out = CStructuredLabels::obtain_from_generic(sosvm->apply());
CStructuredLabels* bout = CStructuredLabels::obtain_from_generic(bundle->apply());
// Create liblinear svm classifier with L2-regularized L2-loss
CLibLinear* svm = new CLibLinear(L2R_L2LOSS_SVC);
// Add some configuration to the svm
svm->set_epsilon(EPSILON);
svm->set_bias_enabled(false);
// Create a multiclass svm classifier that consists of several of the previous one
CLinearMulticlassMachine* mc_svm =
new CLinearMulticlassMachine( new CMulticlassOneVsRestStrategy(),
(CDotFeatures*) features, svm, mlabels);
SG_REF(mc_svm);
// Train the multiclass machine using the data passed in the constructor
mc_svm->train();
CMulticlassLabels* mout = CMulticlassLabels::obtain_from_generic(mc_svm->apply());
SGVector< float64_t > w = sosvm->get_w();
for ( int32_t i = 0 ; i < w.vlen ; ++i )
SG_SPRINT("%10f ", w[i]);
SG_SPRINT("\n\n");
for ( int32_t i = 0 ; i < NUM_CLASSES ; ++i )
{
CLinearMachine* lm = (CLinearMachine*) mc_svm->get_machine(i);
SGVector< float64_t > mw = lm->get_w();
for ( int32_t j = 0 ; j < mw.vlen ; ++j )
SG_SPRINT("%10f ", mw[j]);
SG_UNREF(lm); // because of CLinearMulticlassMachine::get_machine()
}
SG_SPRINT("\n");
CStructuredAccuracy* structured_evaluator = new CStructuredAccuracy();
CMulticlassAccuracy* multiclass_evaluator = new CMulticlassAccuracy();
SG_REF(structured_evaluator);
SG_REF(multiclass_evaluator);
SG_SPRINT("SO-SVM: %5.2f%\n", 100.0*structured_evaluator->evaluate(out, labels));
SG_SPRINT("BMRM: %5.2f%\n", 100.0*structured_evaluator->evaluate(bout, labels));
SG_SPRINT("MC: %5.2f%\n", 100.0*multiclass_evaluator->evaluate(mout, mlabels));
// Free memory
SG_UNREF(multiclass_evaluator);
SG_UNREF(structured_evaluator);
SG_UNREF(mout);
SG_UNREF(mc_svm);
SG_UNREF(bundle);
SG_UNREF(sosvm);
SG_UNREF(bout);
SG_UNREF(out);
exit_shogun();
return 0;
}
