void CShareBoost::compute_pred(const float64_t *W)
{
int32_t w_len = m_activeset.vlen;
for (int32_t i=0; i < m_multiclass_strategy->get_num_classes(); ++i)
{
CLinearMachine *machine = dynamic_cast<CLinearMachine *>(m_machines->get_element(i));
SGVector<float64_t> w(w_len);
std::copy(W + i*w_len, W + (i+1)*w_len, w.vector);
machine->set_w(w);
SG_UNREF(machine);
}
compute_pred();
}
void CShareBoost::compute_pred()
{
CDenseFeatures<float64_t> *fea = dynamic_cast<CDenseFeatures<float64_t> *>(m_features);
CDenseSubsetFeatures<float64_t> *subset_fea = new CDenseSubsetFeatures<float64_t>(fea, m_activeset);
SG_REF(subset_fea);
for (int32_t i=0; i < m_multiclass_strategy->get_num_classes(); ++i)
{
CLinearMachine *machine = dynamic_cast<CLinearMachine *>(m_machines->get_element(i));
CRegressionLabels *lab = machine->apply_regression(subset_fea);
SGVector<float64_t> lab_raw = lab->get_labels();
std::copy(lab_raw.vector, lab_raw.vector + lab_raw.vlen, m_pred.get_column_vector(i));
SG_UNREF(machine);
SG_UNREF(lab);
}
SG_UNREF(subset_fea);
}
bool CMulticlassLibLinear::train_machine(CFeatures* data)
{
if (data)
set_features((CDotFeatures*)data);
int32_t num_vectors = m_features->get_num_vectors();
int32_t num_classes = labels->get_num_classes();
problem mc_problem;
mc_problem.l = num_vectors;
mc_problem.n = m_features->get_dim_feature_space();
mc_problem.y = SG_MALLOC(int32_t, mc_problem.l);
for (int32_t i=0; i<num_vectors; i++)
mc_problem.y[i] = labels->get_int_label(i);
mc_problem.x = m_features;
mc_problem.use_bias = true;
float64_t* w = SG_MALLOC(float64_t, mc_problem.n*num_classes);
float64_t* C = SG_MALLOC(float64_t, num_vectors);
for (int32_t i=0; i<num_vectors; i++)
C[i] = m_C;
Solver_MCSVM_CS solver(&mc_problem,num_classes,C,m_epsilon,m_max_iter);
solver.Solve(w);
m_machines.destroy_vector();
m_machines = SGVector<CMachine*>(num_classes);
for (int32_t i=0; i<num_classes; i++)
{
CLinearMachine* machine = new CLinearMachine();
SGVector<float64_t> cw(mc_problem.n);
for (int32_t j=0; j<mc_problem.n; j++)
cw[j] = w[j*num_classes+i];
machine->set_w(cw);
m_machines[i] = machine;
}
SG_FREE(C);
SG_FREE(w);
SG_FREE(mc_problem.y);
return true;
}
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;
}
bool CMulticlassOCAS::train_machine(CFeatures* data)
{
if (data)
set_features((CDotFeatures*)data);
ASSERT(m_features)
ASSERT(m_labels)
ASSERT(m_multiclass_strategy)
int32_t num_vectors = m_features->get_num_vectors();
int32_t num_classes = m_multiclass_strategy->get_num_classes();
int32_t num_features = m_features->get_dim_feature_space();
float64_t C = m_C;
SGVector<float64_t> labels = ((CMulticlassLabels*) m_labels)->get_labels();
uint32_t nY = num_classes;
uint32_t nData = num_vectors;
float64_t TolRel = m_epsilon;
float64_t TolAbs = 0.0;
float64_t QPBound = 0.0;
float64_t MaxTime = m_max_train_time;
uint32_t BufSize = m_buf_size;
uint8_t Method = m_method;
mocas_data user_data;
user_data.features = m_features;
user_data.W = SG_CALLOC(float64_t, (int64_t)num_features*num_classes);
user_data.oldW = SG_CALLOC(float64_t, (int64_t)num_features*num_classes);
user_data.new_a = SG_CALLOC(float64_t, (int64_t)num_features*num_classes);
user_data.full_A = SG_CALLOC(float64_t, (int64_t)num_features*num_classes*m_buf_size);
user_data.output_values = SG_CALLOC(float64_t, num_vectors);
user_data.data_y = labels.vector;
user_data.nY = num_classes;
user_data.nDim = num_features;
user_data.nData = num_vectors;
ocas_return_value_T value =
msvm_ocas_solver(C, labels.vector, nY, nData, TolRel, TolAbs,
QPBound, MaxTime, BufSize, Method,
&CMulticlassOCAS::msvm_full_compute_W,
&CMulticlassOCAS::msvm_update_W,
&CMulticlassOCAS::msvm_full_add_new_cut,
&CMulticlassOCAS::msvm_full_compute_output,
&CMulticlassOCAS::msvm_sort_data,
&CMulticlassOCAS::msvm_print,
&user_data);
SG_DEBUG("Number of iterations [nIter] = %d \n",value.nIter)
SG_DEBUG("Number of cutting planes [nCutPlanes] = %d \n",value.nCutPlanes)
SG_DEBUG("Number of non-zero alphas [nNZAlpha] = %d \n",value.nNZAlpha)
SG_DEBUG("Number of training errors [trn_err] = %d \n",value.trn_err)
SG_DEBUG("Primal objective value [Q_P] = %f \n",value.Q_P)
SG_DEBUG("Dual objective value [Q_D] = %f \n",value.Q_D)
SG_DEBUG("Output time [output_time] = %f \n",value.output_time)
SG_DEBUG("Sort time [sort_time] = %f \n",value.sort_time)
SG_DEBUG("Add time [add_time] = %f \n",value.add_time)
SG_DEBUG("W time [w_time] = %f \n",value.w_time)
SG_DEBUG("QP solver time [qp_solver_time] = %f \n",value.qp_solver_time)
SG_DEBUG("OCAS time [ocas_time] = %f \n",value.ocas_time)
SG_DEBUG("Print time [print_time] = %f \n",value.print_time)
SG_DEBUG("QP exit flag [qp_exitflag] = %d \n",value.qp_exitflag)
SG_DEBUG("Exit flag [exitflag] = %d \n",value.exitflag)
m_machines->reset_array();
for (int32_t i=0; i<num_classes; i++)
{
CLinearMachine* machine = new CLinearMachine();
machine->set_w(SGVector<float64_t>(&user_data.W[i*num_features],num_features,false).clone());
m_machines->push_back(machine);
}
SG_FREE(user_data.W);
SG_FREE(user_data.oldW);
SG_FREE(user_data.new_a);
SG_FREE(user_data.full_A);
SG_FREE(user_data.output_values);
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;
}
