SGVector< float64_t > CFactorGraphModel::get_joint_feature_vector(int32_t feat_idx, CStructuredData* y)
{
// factor graph instance
CFactorGraphFeatures* mf = CFactorGraphFeatures::obtain_from_generic(m_features);
CFactorGraph* fg = mf->get_sample(feat_idx);
// ground truth states
CFactorGraphObservation* fg_states = CFactorGraphObservation::obtain_from_generic(y);
SGVector<int32_t> states = fg_states->get_data();
// initialize psi
SGVector<float64_t> psi(get_dim());
psi.zero();
// construct unnormalized psi
CDynamicObjectArray* facs = fg->get_factors();
for (int32_t fi = 0; fi < facs->get_num_elements(); ++fi)
{
CFactor* fac = dynamic_cast<CFactor*>(facs->get_element(fi));
CTableFactorType* ftype = fac->get_factor_type();
int32_t id = ftype->get_type_id();
SGVector<int32_t> w_map = get_params_mapping(id);
ASSERT(w_map.size() == ftype->get_w_dim());
SGVector<float64_t> dat = fac->get_data();
int32_t dat_size = dat.size();
ASSERT(w_map.size() == dat_size * ftype->get_num_assignments());
int32_t ei = ftype->index_from_universe_assignment(states, fac->get_variables());
for (int32_t di = 0; di < dat_size; di++)
psi[w_map[ei*dat_size + di]] += dat[di];
SG_UNREF(ftype);
SG_UNREF(fac);
}
// negation (-E(x,y) = <w,phi(x,y)>)
psi.scale(-1.0);
SG_UNREF(facs);
SG_UNREF(fg);
return psi;
}
CAutoencoder::CAutoencoder(int32_t num_inputs, CNeuralLayer* hidden_layer,
CNeuralLayer* decoding_layer, float64_t sigma) : CNeuralNetwork()
{
init();
if (decoding_layer==NULL)
decoding_layer = new CNeuralLinearLayer(num_inputs);
CDynamicObjectArray* layers = new CDynamicObjectArray();
layers->append_element(new CNeuralInputLayer(num_inputs));
layers->append_element(hidden_layer);
layers->append_element(decoding_layer);
set_layers(layers);
quick_connect();
hidden_layer->autoencoder_position = NLAP_ENCODING;
decoding_layer->autoencoder_position = NLAP_DECODING;
initialize_neural_network(sigma);
}
CAutoencoder::CAutoencoder(
int32_t input_width, int32_t input_height, int32_t input_num_channels,
CNeuralConvolutionalLayer* hidden_layer,
CNeuralConvolutionalLayer* decoding_layer,
float64_t sigma)
: CNeuralNetwork()
{
init();
CDynamicObjectArray* layers = new CDynamicObjectArray();
layers->append_element(new CNeuralInputLayer(input_width, input_height, input_num_channels));
layers->append_element(hidden_layer);
layers->append_element(decoding_layer);
set_layers(layers);
quick_connect();
hidden_layer->autoencoder_position = NLAP_ENCODING;
decoding_layer->autoencoder_position = NLAP_DECODING;
initialize_neural_network(sigma);
}
void test_leaf_sets_multiplication()
{
SG_SPRINT("shogun\ntest_leaf_sets_multiplication()\n");
SGVector<float64_t> param_vector(6);
SGVector<float64_t>::range_fill_vector(param_vector.vector, param_vector.vlen);
CDynamicObjectArray sets;
CParameterCombination* new_root=new CParameterCombination();
SG_REF(new_root);
CDynamicObjectArray* current=new CDynamicObjectArray();
sets.append_element(current);
Parameter* p=new Parameter();
p->add(¶m_vector.vector[0], "0");
CParameterCombination* pc=new CParameterCombination(p);
current->append_element(pc);
p=new Parameter();
p->add(¶m_vector.vector[1], "1");
pc=new CParameterCombination(p);
current->append_element(pc);
/* first case: one element */
CDynamicObjectArray* result_simple=
CParameterCombination::leaf_sets_multiplication(sets, new_root);
SG_SPRINT("one set\n");
for (index_t i=0; i<result_simple->get_num_elements(); ++i)
{
CParameterCombination* tpc=(CParameterCombination*)
result_simple->get_element(i);
tpc->print_tree();
SG_UNREF(tpc);
}
SG_UNREF(result_simple);
/* now more elements are created */
current=new CDynamicObjectArray();
sets.append_element(current);
p=new Parameter();
p->add(¶m_vector.vector[2], "2");
pc=new CParameterCombination(p);
current->append_element(pc);
p=new Parameter();
p->add(¶m_vector.vector[3], "3");
pc=new CParameterCombination(p);
current->append_element(pc);
current=new CDynamicObjectArray();
sets.append_element(current);
p=new Parameter();
p->add(¶m_vector.vector[4], "4");
pc=new CParameterCombination(p);
current->append_element(pc);
p=new Parameter();
p->add(¶m_vector.vector[5], "5");
pc=new CParameterCombination(p);
current->append_element(pc);
/* second case: more element */
CDynamicObjectArray* result_complex=
CParameterCombination::leaf_sets_multiplication(sets, new_root);
SG_SPRINT("more sets\n");
for (index_t i=0; i<result_complex->get_num_elements(); ++i)
{
CParameterCombination* tpc=(CParameterCombination*)
result_complex->get_element(i);
tpc->print_tree();
SG_UNREF(tpc);
}
SG_UNREF(result_complex);
SG_UNREF(new_root);
}
bool CPrimalMosekSOSVM::train_machine(CFeatures* data)
{
SG_DEBUG("Entering CPrimalMosekSOSVM::train_machine.\n");
if (data)
set_features(data);
CFeatures* model_features = get_features();
// Initialize the model for training
m_model->init_training();
// Check that the scenary is correct to start with training
m_model->check_training_setup();
SG_DEBUG("The training setup is correct.\n");
// Dimensionality of the joint feature space
int32_t M = m_model->get_dim();
// Number of auxiliary variables in the optimization vector
int32_t num_aux = m_model->get_num_aux();
// Number of auxiliary constraints
int32_t num_aux_con = m_model->get_num_aux_con();
// Number of training examples
int32_t N = model_features->get_num_vectors();
SG_DEBUG("M=%d, N =%d, num_aux=%d, num_aux_con=%d.\n", M, N, num_aux, num_aux_con);
// Interface with MOSEK
CMosek* mosek = new CMosek(0, M+num_aux+N);
SG_REF(mosek);
REQUIRE(mosek->get_rescode() == MSK_RES_OK, "Mosek object could not be properly created in PrimalMosekSOSVM training.\n");
// Initialize the terms of the optimization problem
SGMatrix< float64_t > A, B, C;
SGVector< float64_t > a, b, lb, ub;
m_model->init_primal_opt(m_regularization, A, a, B, b, lb, ub, C);
SG_DEBUG("Regularization used in PrimalMosekSOSVM equal to %.2f.\n", m_regularization);
// Input terms of the problem that do not change between iterations
REQUIRE(mosek->init_sosvm(M, N, num_aux, num_aux_con, C, lb, ub, A, b) == MSK_RES_OK,
"Mosek error in PrimalMosekSOSVM initializing SO-SVM.\n")
// Initialize the weight vector
m_w = SGVector< float64_t >(M);
m_w.zero();
m_slacks = SGVector< float64_t >(N);
m_slacks.zero();
// Initialize the list of constraints
// Each element in results is a list of CResultSet with the constraints
// associated to each training example
CDynamicObjectArray* results = new CDynamicObjectArray(N);
SG_REF(results);
for ( int32_t i = 0 ; i < N ; ++i )
{
CList* list = new CList(true);
results->push_back(list);
}
// Initialize variables used in the loop
int32_t num_con = num_aux_con; // number of constraints
int32_t old_num_con = num_con;
bool exception = false;
index_t iteration = 0;
SGVector< float64_t > sol(M+num_aux+N);
sol.zero();
SGVector< float64_t > aux(num_aux);
do
{
SG_DEBUG("Iteration #%d: Cutting plane training with num_con=%d and old_num_con=%d.\n",
iteration, num_con, old_num_con);
old_num_con = num_con;
for ( int32_t i = 0 ; i < N ; ++i )
{
// Predict the result of the ith training example (loss-aug)
CResultSet* result = m_model->argmax(m_w, i);
// Compute the loss associated with the prediction (surrogate loss, max(0, \tilde{H}))
float64_t slack = CHingeLoss().loss( compute_loss_arg(result) );
CList* cur_list = (CList*) results->get_element(i);
// Update the list of constraints
if ( cur_list->get_num_elements() > 0 )
{
// Find the maximum loss within the elements of
// the list of constraints
CResultSet* cur_res = (CResultSet*) cur_list->get_first_element();
float64_t max_slack = -CMath::INFTY;
while ( cur_res != NULL )
{
max_slack = CMath::max(max_slack, CHingeLoss().loss( compute_loss_arg(cur_res) ));
SG_UNREF(cur_res);
cur_res = (CResultSet*) cur_list->get_next_element();
}
if ( slack > max_slack + m_epsilon )
{
// The current training example is a
// violated constraint
if ( ! insert_result(cur_list, result) )
{
exception = true;
break;
}
add_constraint(mosek, result, num_con, i);
++num_con;
}
}
else
{
// First iteration of do ... while, add constraint
if ( ! insert_result(cur_list, result) )
{
exception = true;
break;
}
add_constraint(mosek, result, num_con, i);
++num_con;
}
SG_UNREF(cur_list);
SG_UNREF(result);
}
// Solve the QP
SG_DEBUG("Entering Mosek QP solver.\n");
mosek->optimize(sol);
for ( int32_t i = 0 ; i < M+num_aux+N ; ++i )
{
if ( i < M )
m_w[i] = sol[i];
else if ( i < M+num_aux )
aux[i-M] = sol[i];
else
m_slacks[i-M-num_aux] = sol[i];
}
SG_DEBUG("QP solved. The primal objective value is %.4f.\n", mosek->get_primal_objective_value());
++iteration;
} while ( old_num_con != num_con && ! exception );
po_value = mosek->get_primal_objective_value();
// Free resources
SG_UNREF(results);
SG_UNREF(mosek);
SG_UNREF(model_features);
return true;
}
SGMatrix<float64_t> CLogDetEstimator::sample_without_averaging(
index_t num_estimates)
{
SG_DEBUG("Entering...\n")
REQUIRE(m_operator_log, "Operator function is NULL\n");
// call the precompute of operator function to compute all prerequisites
m_operator_log->precompute();
REQUIRE(m_trace_sampler, "Trace sampler is NULL\n");
// call the precompute of the sampler
m_trace_sampler->precompute();
// for storing the aggregators that submit_jobs return
CDynamicObjectArray aggregators;
index_t num_trace_samples=m_trace_sampler->get_num_samples();
for (index_t i=0; i<num_estimates; ++i)
{
for (index_t j=0; j<num_trace_samples; ++j)
{
// get the trace sampler vector
SGVector<float64_t> s=m_trace_sampler->sample(j);
// create jobs with the sample vector and store the aggregator
CJobResultAggregator* agg=m_operator_log->submit_jobs(s);
aggregators.append_element(agg);
SG_UNREF(agg);
}
}
REQUIRE(m_computation_engine, "Computation engine is NULL\n");
// wait for all the jobs to be completed
m_computation_engine->wait_for_all();
// the samples matrix which stores the estimates without averaging
// dimension: number of trace samples x number of log-det estimates
SGMatrix<float64_t> samples(num_trace_samples, num_estimates);
// use the aggregators to find the final result
int32_t num_aggregates=aggregators.get_num_elements();
for (int32_t i=0; i<num_aggregates; ++i)
{
CJobResultAggregator* agg=dynamic_cast<CJobResultAggregator*>
(aggregators.get_element(i));
if (!agg)
SG_ERROR("Element is not CJobResultAggregator type!\n");
// call finalize on all the aggregators
agg->finalize();
CScalarResult<float64_t>* r=dynamic_cast<CScalarResult<float64_t>*>
(agg->get_final_result());
if (!r)
SG_ERROR("Result is not CScalarResult type!\n");
// its important that we don't just unref the result here
index_t idx_row=i%num_trace_samples;
index_t idx_col=i/num_trace_samples;
samples(idx_row, idx_col)=r->get_result();
SG_UNREF(agg);
}
// clear all aggregators
aggregators.clear_array();
SG_DEBUG("Leaving\n")
return samples;
}
bool CPrimalMosekSOSVM::train_machine(CFeatures* data)
{
if (data)
set_features(data);
CFeatures* model_features = get_features();
// Check that the scenary is correct to start with training
m_model->check_training_setup();
// Dimensionality of the joint feature space
int32_t M = m_model->get_dim();
// Number of auxiliary variables in the optimization vector
int32_t num_aux = m_model->get_num_aux();
// Number of auxiliary constraints
int32_t num_aux_con = m_model->get_num_aux_con();
// Number of training examples
int32_t N = m_model->get_features()->get_num_vectors();
// Interface with MOSEK
CMosek* mosek = new CMosek(0, M+num_aux+N);
SG_REF(mosek);
if ( mosek->get_rescode() != MSK_RES_OK )
{
SG_PRINT("Mosek object could not be properly created..."
"aborting training of PrimalMosekSOSVM\n");
return false;
}
// Initialize the terms of the optimization problem
SGMatrix< float64_t > A, B, C;
SGVector< float64_t > a, b, lb, ub;
m_model->init_opt(A, a, B, b, lb, ub, C);
// Input terms of the problem that do not change between iterations
if ( mosek->init_sosvm(M, N, num_aux, num_aux_con, C, lb, ub, A, b) != MSK_RES_OK )
{
// MOSEK error took place
return false;
}
// Initialize the weight vector
m_w = SGVector< float64_t >(M);
m_w.zero();
m_slacks = SGVector< float64_t >(N);
m_slacks.zero();
// Initialize the list of constraints
// Each element in results is a list of CResultSet with the constraints
// associated to each training example
CDynamicObjectArray* results = new CDynamicObjectArray(N);
SG_REF(results);
for ( int32_t i = 0 ; i < N ; ++i )
{
CList* list = new CList(true);
results->push_back(list);
}
// Initialize variables used in the loop
int32_t num_con = num_aux_con; // number of constraints
int32_t old_num_con = num_con;
float64_t slack = 0.0;
float64_t max_slack = 0.0;
CResultSet* result = NULL;
CResultSet* cur_res = NULL;
CList* cur_list = NULL;
bool exception = false;
SGVector< float64_t > sol(M+num_aux+N);
sol.zero();
SGVector< float64_t > aux(num_aux);
do
{
old_num_con = num_con;
for ( int32_t i = 0 ; i < N ; ++i )
{
// Predict the result of the ith training example
result = m_model->argmax(m_w, i);
//SG_PRINT("loss %f %f\n", compute_loss_arg(result), m_loss->loss( compute_loss_arg(result)) );
// Compute the loss associated with the prediction
slack = m_loss->loss( compute_loss_arg(result) );
cur_list = (CList*) results->get_element(i);
// Update the list of constraints
if ( cur_list->get_num_elements() > 0 )
{
// Find the maximum loss within the elements of
// the list of constraints
cur_res = (CResultSet*) cur_list->get_first_element();
max_slack = -CMath::INFTY;
while ( cur_res != NULL )
{
max_slack = CMath::max(max_slack,
m_loss->loss( compute_loss_arg(cur_res) ));
SG_UNREF(cur_res);
cur_res = (CResultSet*) cur_list->get_next_element();
}
if ( slack > max_slack )
{
// The current training example is a
// violated constraint
if ( ! insert_result(cur_list, result) )
{
exception = true;
break;
}
add_constraint(mosek, result, num_con, i);
++num_con;
}
}
else
{
// First iteration of do ... while, add constraint
if ( ! insert_result(cur_list, result) )
{
exception = true;
break;
}
add_constraint(mosek, result, num_con, i);
++num_con;
}
SG_UNREF(cur_list);
SG_UNREF(result);
}
// Solve the QP
mosek->optimize(sol);
for ( int32_t i = 0 ; i < M+num_aux+N ; ++i )
{
if ( i < M )
m_w[i] = sol[i];
else if ( i < M+num_aux )
aux[i-M] = sol[i];
else
m_slacks[i-M-num_aux] = sol[i];
}
} while ( old_num_con != num_con && ! exception );
po_value = mosek->get_primal_objective_value();
// Free resources
SG_UNREF(results);
SG_UNREF(mosek);
SG_UNREF(model_features);
return true;
}