void gen_rand_data(SGVector<float64_t> lab, SGMatrix<float64_t> feat, float64_t dist) { index_t dims=feat.num_rows; index_t num=lab.vlen; for (int32_t i=0; i<num; i++) { if (i<num/2) { lab[i]=-1.0; for (int32_t j=0; j<dims; j++) feat(j, i)=CMath::random(0.0, 1.0)+dist; } else { lab[i]=1.0; for (int32_t j=0; j<dims; j++) feat(j, i)=CMath::random(0.0, 1.0)-dist; } } lab.display_vector("lab"); feat.display_matrix("feat"); }
void CMultitaskROCEvaluation::set_indices(SGVector<index_t> indices) { indices.display_vector("indices"); ASSERT(m_task_relation) set<index_t> indices_set; for (int32_t i=0; i<indices.vlen; i++) indices_set.insert(indices[i]); if (m_num_tasks>0) { SG_FREE(m_tasks_indices); } m_num_tasks = m_task_relation->get_num_tasks(); m_tasks_indices = SG_MALLOC(SGVector<index_t>, m_num_tasks); SGVector<index_t>* tasks_indices = m_task_relation->get_tasks_indices(); for (int32_t t=0; t<m_num_tasks; t++) { vector<index_t> task_indices_cut; SGVector<index_t> task_indices = tasks_indices[t]; //task_indices.display_vector("task indices"); for (int32_t i=0; i<task_indices.vlen; i++) { if (indices_set.count(task_indices[i])) { //SG_SPRINT("%d is in %d task\n",task_indices[i],t) task_indices_cut.push_back(task_indices[i]); } } SGVector<index_t> cutted(task_indices_cut.size()); for (int32_t i=0; i<cutted.vlen; i++) cutted[i] = task_indices_cut[i]; //cutted.display_vector("cutted"); m_tasks_indices[t] = cutted; } SG_FREE(tasks_indices); }
int main(int argc, char **argv) { init_shogun_with_defaults(); /* create some data and labels */ SGMatrix<float64_t> matrix = SGMatrix<float64_t>(dim_vectors, num_vectors); SGMatrix<float64_t> matrix2 = SGMatrix<float64_t>(dim_vectors, num_vectors); CRegressionLabels* labels=new CRegressionLabels(num_vectors); build_matrices(matrix2, matrix, labels); /* create training features */ CDenseFeatures<float64_t>* features=new CDenseFeatures<float64_t> (); features->set_feature_matrix(matrix); /* create testing features */ CDenseFeatures<float64_t>* features2=new CDenseFeatures<float64_t> (); features2->set_feature_matrix(matrix2); SG_REF(features); SG_REF(features2); SG_REF(labels); /*Allocate our Kernel*/ CGaussianKernel* test_kernel = new CGaussianKernel(10, 2); test_kernel->init(features, features); /*Allocate our mean function*/ CZeroMean* mean = new CZeroMean(); /*Allocate our likelihood function*/ CGaussianLikelihood* lik = new CGaussianLikelihood(); /*Allocate our inference method*/ CExactInferenceMethod* inf = new CExactInferenceMethod(test_kernel, features, mean, labels, lik); SG_REF(inf); /*Finally use these to allocate the Gaussian Process Object*/ CGaussianProcessRegression* gp = new CGaussianProcessRegression(inf, features, labels); SG_REF(gp); /*Build the parameter tree for model selection*/ CModelSelectionParameters* root = build_tree(inf, lik, test_kernel); /*Criterion for gradient search*/ CGradientCriterion* crit = new CGradientCriterion(); /*This will evaluate our inference method for its derivatives*/ CGradientEvaluation* grad=new CGradientEvaluation(gp, features, labels, crit); grad->set_function(inf); gp->print_modsel_params(); root->print_tree(); /* handles all of the above structures in memory */ CGradientModelSelection* grad_search=new CGradientModelSelection( root, grad); /* set autolocking to false to get rid of warnings */ grad->set_autolock(false); /*Search for best parameters*/ CParameterCombination* best_combination=grad_search->select_model(true); /*Output all the results and information*/ if (best_combination) { SG_SPRINT("best parameter(s):\n"); best_combination->print_tree(); best_combination->apply_to_machine(gp); } CGradientResult* result=(CGradientResult*)grad->evaluate(); if(result->get_result_type() != GRADIENTEVALUATION_RESULT) SG_SERROR("Evaluation result not a GradientEvaluationResult!"); result->print_result(); SGVector<float64_t> alpha = inf->get_alpha(); SGVector<float64_t> labe = labels->get_labels(); SGVector<float64_t> diagonal = inf->get_diagonal_vector(); SGMatrix<float64_t> cholesky = inf->get_cholesky(); gp->set_return_type(CGaussianProcessRegression::GP_RETURN_COV); CRegressionLabels* covariance = gp->apply_regression(features); gp->set_return_type(CGaussianProcessRegression::GP_RETURN_MEANS); CRegressionLabels* predictions = gp->apply_regression(); alpha.display_vector("Alpha Vector"); labe.display_vector("Labels"); diagonal.display_vector("sW Matrix"); covariance->get_labels().display_vector("Predicted Variances"); predictions->get_labels().display_vector("Mean Predictions"); cholesky.display_matrix("Cholesky Matrix L"); matrix.display_matrix("Training Features"); matrix2.display_matrix("Testing Features"); /*free memory*/ SG_UNREF(features); SG_UNREF(features2); SG_UNREF(predictions); SG_UNREF(covariance); SG_UNREF(labels); SG_UNREF(inf); SG_UNREF(gp); SG_UNREF(grad_search); SG_UNREF(best_combination); SG_UNREF(result); SG_UNREF(mean); exit_shogun(); return 0; }
int main(int argc, char **argv) { init_shogun(&print_message, &print_message, &print_message); int32_t num_vectors=4; int32_t dim_vectors=3; /* create some data and labels */ SGMatrix<float64_t> matrix = SGMatrix<float64_t>(dim_vectors, num_vectors); matrix[0] = -1; matrix[1] = -1; matrix[2] = -1; matrix[3] = 1; matrix[4] = 1; matrix[5] = 1; matrix[6] = -10; matrix[7] = -10; matrix[8] = -10; matrix[9] = 3; matrix[10] = 2; matrix[11] = 1; SGMatrix<float64_t> matrix2 = SGMatrix<float64_t>(dim_vectors, num_vectors); for (int32_t i=0; i<num_vectors*dim_vectors; i++) matrix2[i]=i*sin(i)*.96; /* create training features */ CDenseFeatures<float64_t>* features=new CDenseFeatures<float64_t> (); features->set_feature_matrix(matrix); /* create testing features */ CDenseFeatures<float64_t>* features2=new CDenseFeatures<float64_t> (); features2->set_feature_matrix(matrix2); SG_REF(features); SG_REF(features2); CRegressionLabels* labels=new CRegressionLabels(num_vectors); /* create labels, two classes */ for (index_t i=0; i<num_vectors; ++i) { if(i%2 == 0) labels->set_label(i, 1); else labels->set_label(i, -1); } SG_REF(labels); CGaussianKernel* test_kernel = new CGaussianKernel(10, 2); test_kernel->init(features, features); CZeroMean* mean = new CZeroMean(); CGaussianLikelihood* lik = new CGaussianLikelihood(); lik->set_sigma(0.01); CExactInferenceMethod* inf = new CExactInferenceMethod(test_kernel, features, mean, labels, lik); SG_REF(inf); CGaussianProcessRegression* gp = new CGaussianProcessRegression(inf, features, labels); CModelSelectionParameters* root=new CModelSelectionParameters(); CModelSelectionParameters* c1 = new CModelSelectionParameters("inference_method", inf); root->append_child(c1); CModelSelectionParameters* c2 = new CModelSelectionParameters("scale"); c1 ->append_child(c2); c2->build_values(0.01, 4.0, R_LINEAR); CModelSelectionParameters* c3 = new CModelSelectionParameters("likelihood_model", lik); c1->append_child(c3); CModelSelectionParameters* c4=new CModelSelectionParameters("sigma"); c3->append_child(c4); c4->build_values(0.001, 4.0, R_LINEAR); CModelSelectionParameters* c5 = new CModelSelectionParameters("kernel", test_kernel); c1->append_child(c5); CModelSelectionParameters* c6 = new CModelSelectionParameters("width"); c5->append_child(c6); c6->build_values(0.001, 4.0, R_LINEAR); /* cross validation class for evaluation in model selection */ SG_REF(gp); CGradientCriterion* crit = new CGradientCriterion(); CGradientEvaluation* grad=new CGradientEvaluation(gp, features, labels, crit); grad->set_function(inf); gp->print_modsel_params(); root->print_tree(); /* handles all of the above structures in memory */ CGradientModelSelection* grad_search=new CGradientModelSelection( root, grad); /* set autolocking to false to get rid of warnings */ grad->set_autolock(false); CParameterCombination* best_combination=grad_search->select_model(true); grad_search->set_max_evaluations(5); if (best_combination) { SG_SPRINT("best parameter(s):\n"); best_combination->print_tree(); best_combination->apply_to_machine(gp); } CGradientResult* result=(CGradientResult*)grad->evaluate(); if(result->get_result_type() != GRADIENTEVALUATION_RESULT) SG_SERROR("Evaluation result not a GradientEvaluationResult!"); result->print_result(); SGVector<float64_t> alpha = inf->get_alpha(); SGVector<float64_t> labe = labels->get_labels(); SGVector<float64_t> diagonal = inf->get_diagonal_vector(); SGMatrix<float64_t> cholesky = inf->get_cholesky(); gp->set_return_type(CGaussianProcessRegression::GP_RETURN_COV); CRegressionLabels* covariance = gp->apply_regression(features); gp->set_return_type(CGaussianProcessRegression::GP_RETURN_MEANS); CRegressionLabels* predictions = gp->apply_regression(); alpha.display_vector("Alpha Vector"); labe.display_vector("Labels"); diagonal.display_vector("sW Matrix"); covariance->get_labels().display_vector("Predicted Variances"); predictions->get_labels().display_vector("Mean Predictions"); cholesky.display_matrix("Cholesky Matrix L"); matrix.display_matrix("Training Features"); matrix2.display_matrix("Testing Features"); /*free memory*/ SG_UNREF(features); SG_UNREF(features2); SG_UNREF(predictions); SG_UNREF(covariance); SG_UNREF(labels); SG_UNREF(inf); SG_UNREF(gp); SG_UNREF(grad_search); SG_UNREF(best_combination); SG_UNREF(result); exit_shogun(); return 0; }
MSKrescodee CMosek::optimize(SGVector< float64_t > sol) { m_rescode = MSK_optimize(m_task); #ifdef DEBUG_MOSEK // Print a summary containing information about the solution MSK_solutionsummary(m_task, MSK_STREAM_LOG); #endif // Read the solution if ( m_rescode == MSK_RES_OK ) { // Solution status MSKsolstae solsta; // FIXME posible solutions are: // MSK_SOL_ITR: the interior solution // MSK_SOL_BAS: the basic solution // MSK_SOL_ITG: the integer solution MSK_getsolutionstatus(m_task, MSK_SOL_ITR, NULL, &solsta); switch (solsta) { case MSK_SOL_STA_OPTIMAL: case MSK_SOL_STA_NEAR_OPTIMAL: MSK_getsolutionslice(m_task, // Request the interior solution MSK_SOL_ITR, // of the optimization vector MSK_SOL_ITEM_XX, 0, sol.vlen, sol.vector); #ifdef DEBUG_SOLUTION sol.display_vector("Solution"); #endif break; case MSK_SOL_STA_DUAL_INFEAS_CER: case MSK_SOL_STA_PRIM_INFEAS_CER: case MSK_SOL_STA_NEAR_DUAL_INFEAS_CER: case MSK_SOL_STA_NEAR_PRIM_INFEAS_CER: #ifdef DEBUG_MOSEK SG_PRINT("Primal or dual infeasibility " "certificate found\n"); #endif break; case MSK_SOL_STA_UNKNOWN: #ifdef DEBUG_MOSEK SG_PRINT("Undetermined solution status\n"); #endif break; default: #ifdef DEBUG_MOSEK SG_PRINT("Other solution status\n"); #endif break; // to avoid compile error when DEBUG_MOSEK // is not defined } } // In case any error occurred, print the appropriate error message if ( m_rescode != MSK_RES_OK ) { char symname[MSK_MAX_STR_LEN]; char desc[MSK_MAX_STR_LEN]; MSK_getcodedesc(m_rescode, symname, desc); SG_PRINT("An error occurred optimizing with MOSEK\n"); SG_PRINT("ERROR %s - '%s'\n", symname, desc); } return m_rescode; }
void CCrossValidationPrintOutput::update_test_indices( SGVector<index_t> indices, const char* prefix) { indices.display_vector("test_indices", prefix); }
void CLinearTimeMMD::compute_statistic_and_variance( SGVector<float64_t>& statistic, SGVector<float64_t>& variance, bool multiple_kernels) { SG_DEBUG("entering %s::compute_statistic_and_variance()\n", get_name()) REQUIRE(m_streaming_p, "%s::compute_statistic_and_variance: streaming " "features p required!\n", get_name()); REQUIRE(m_streaming_q, "%s::compute_statistic_and_variance: streaming " "features q required!\n", get_name()); REQUIRE(m_kernel, "%s::compute_statistic_and_variance: kernel needed!\n", get_name()); /* make sure multiple_kernels flag is used only with a combined kernel */ REQUIRE(!multiple_kernels || m_kernel->get_kernel_type()==K_COMBINED, "%s::compute_statistic_and_variance: multiple kernels specified," "but underlying kernel is not of type K_COMBINED\n", get_name()); /* m is number of samples from each distribution, m_2 is half of it * using names from JLMR paper (see class documentation) */ index_t m_2=m_m/2; SG_DEBUG("m_m=%d\n", m_m) /* find out whether single or multiple kernels (cast is safe, check above) */ index_t num_kernels=1; if (multiple_kernels) { num_kernels=((CCombinedKernel*)m_kernel)->get_num_subkernels(); SG_DEBUG("computing MMD and variance for %d sub-kernels\n", num_kernels); } /* allocate memory for results if vectors are empty */ if (!statistic.vector) statistic=SGVector<float64_t>(num_kernels); if (!variance.vector) variance=SGVector<float64_t>(num_kernels); /* ensure right dimensions */ REQUIRE(statistic.vlen==num_kernels, "%s::compute_statistic_and_variance: " "statistic vector size (%d) does not match number of kernels (%d)\n", get_name(), statistic.vlen, num_kernels); REQUIRE(variance.vlen==num_kernels, "%s::compute_statistic_and_variance: " "variance vector size (%d) does not match number of kernels (%d)\n", get_name(), variance.vlen, num_kernels); /* temp variable in the algorithm */ float64_t current; float64_t delta; /* initialise statistic and variance since they are cumulative */ statistic.zero(); variance.zero(); /* needed for online mean and variance */ SGVector<index_t> term_counters(num_kernels); term_counters.set_const(1); /* term counter to compute online mean and variance */ index_t num_examples_processed=0; while (num_examples_processed<m_2) { /* number of example to look at in this iteration */ index_t num_this_run=CMath::min(m_blocksize, CMath::max(0, m_2-num_examples_processed)); SG_DEBUG("processing %d more examples. %d so far processed. Blocksize " "is %d\n", num_this_run, num_examples_processed, m_blocksize); /* stream data from both distributions */ CFeatures* p1=m_streaming_p->get_streamed_features(num_this_run); CFeatures* p2=m_streaming_p->get_streamed_features(num_this_run); CFeatures* q1=m_streaming_q->get_streamed_features(num_this_run); CFeatures* q2=m_streaming_q->get_streamed_features(num_this_run); /* check whether h0 should be simulated and permute if so */ if (m_simulate_h0) { /* create merged copy of all feature instances to permute */ CList* list=new CList(); list->append_element(p2); list->append_element(q1); list->append_element(q2); CFeatures* merged=p1->create_merged_copy(list); SG_UNREF(list); /* permute */ SGVector<index_t> inds(merged->get_num_vectors()); inds.range_fill(); inds.permute(); merged->add_subset(inds); /* copy back, replacing old features */ SG_UNREF(p1); SG_UNREF(p2); SG_UNREF(q1); SG_UNREF(q2); SGVector<index_t> copy(num_this_run); copy.range_fill(); p1=merged->copy_subset(copy); copy.add(num_this_run); p2=merged->copy_subset(copy); copy.add(num_this_run); q1=merged->copy_subset(copy); copy.add(num_this_run); q2=merged->copy_subset(copy); /* clean up and note that copy_subset does a SG_REF */ SG_UNREF(merged); } else { /* reference produced features (only if copy_subset was not used) */ SG_REF(p1); SG_REF(p2); SG_REF(q1); SG_REF(q2); } /* if multiple kernels are used, compute all of them on streamed data, * if multiple kernels flag is false, the above loop will be executed * only once */ CKernel* kernel=m_kernel; if (multiple_kernels) { SG_DEBUG("using multiple kernels\n"); } /* iterate through all kernels for this data */ for (index_t i=0; i<num_kernels; ++i) { /* if multiple kernels should be computed, set next kernel */ if (multiple_kernels) { kernel=((CCombinedKernel*)m_kernel)->get_kernel(i); } /* compute kernel matrix diagonals */ kernel->init(p1, p2); SGVector<float64_t> pp=kernel->get_kernel_diagonal(); kernel->init(q1, q2); SGVector<float64_t> qq=kernel->get_kernel_diagonal(); kernel->init(p1, q2); SGVector<float64_t> pq=kernel->get_kernel_diagonal(); kernel->init(q1, p2); SGVector<float64_t> qp=kernel->get_kernel_diagonal(); /* single variances for all kernels. Update mean and variance * using Knuth's online variance algorithm. * C.f. for example Wikipedia */ for (index_t j=0; j<num_this_run; ++j) { /* compute sum of current h terms for current kernel */ current=pp[j]+qq[j]-pq[j]-qp[j]; /* D. Knuth's online variance algorithm for current kernel */ delta=current-statistic[i]; statistic[i]+=delta/term_counters[i]++; variance[i]+=delta*(current-statistic[i]); SG_DEBUG("burst: current=%f, delta=%f, statistic=%f, " "variance=%f, kernel_idx=%d\n", current, delta, statistic[i], variance[i], i); } if (multiple_kernels) { SG_UNREF(kernel); } } /* clean up streamed data */ SG_UNREF(p1); SG_UNREF(p2); SG_UNREF(q1); SG_UNREF(q2); /* add number of processed examples for this run */ num_examples_processed+=num_this_run; } SG_DEBUG("Done compouting statistic, processed 2*%d examples.\n", num_examples_processed); /* mean of sum all traces is linear time mmd, copy entries for all kernels */ if (io->get_loglevel()==MSG_DEBUG || io->get_loglevel()==MSG_GCDEBUG) statistic.display_vector("statistics"); /* variance of terms can be computed using mean (statistic). * Note that the variance needs to be divided by m_2 in order to get * variance of null-distribution */ for (index_t i=0; i<num_kernels; ++i) variance[i]=variance[i]/(m_2-1)/m_2; if (io->get_loglevel()==MSG_DEBUG || io->get_loglevel()==MSG_GCDEBUG) variance.display_vector("variances"); SG_DEBUG("leaving %s::compute_statistic_and_variance()\n", get_name()) }
void CSubsetStack::add_subset(SGVector<index_t> subset) { /* if there are already subsets on stack, do some legality checks */ if (m_active_subsets_stack->get_num_elements()) { /* check that subsets may only be smaller or equal than existing */ CSubset* latest=(CSubset*)m_active_subsets_stack->get_last_element(); if (subset.vlen>latest->m_subset_idx.vlen) { subset.display_vector("subset"); latest->m_subset_idx.display_vector("last on stack"); SG_ERROR("%s::add_subset(): Provided index vector is " "larger than the subsets on the stubset stack!\n", get_name()); } /* check for range of indices */ index_t max_index=SGVector<index_t>::max(subset.vector, subset.vlen); if (max_index>=latest->m_subset_idx.vlen) { subset.display_vector("subset"); latest->m_subset_idx.display_vector("last on stack"); SG_ERROR("%s::add_subset(): Provided index vector contains" " indices larger than possible range!\n", get_name()); } /* clean up */ SG_UNREF(latest); } /* active subset will be changed anyway, no setting to NULL */ SG_UNREF(m_active_subset); /* two cases: stack is empty/stack is not empty */ if (m_active_subsets_stack->get_num_elements()) { /* if there are alreay subsets, we need to map given one through * existing ones */ /* get latest current subset */ CSubset* latest=(CSubset*)m_active_subsets_stack->get_last_element(); /* create new index vector */ SGVector<index_t> new_active_subset=SGVector<index_t>(subset.vlen); /* using the latest current subset, transform all indices by the latest * added subset (dynamic programming greets you) */ for (index_t i=0; i<subset.vlen; ++i) { new_active_subset.vector[i]= latest->m_subset_idx.vector[subset.vector[i]]; } /* replace active subset */ m_active_subset=new CSubset(new_active_subset); SG_REF(m_active_subset); SG_UNREF(latest); } else { /* just use plain given subset since there is nothing to map */ m_active_subset=new CSubset(subset); SG_REF(m_active_subset); } /* add current active subset on stack of active subsets in any case */ m_active_subsets_stack->append_element(m_active_subset); }