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