void mexFunction (int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){ double* V = mxGetPr(prhs[0]); int n = (int) mxGetScalar(prhs[1]); int k = (int) mxGetScalar(prhs[2]); double* ind = mxGetPr(prhs[3]); int nodes = (int) mxGetScalar(prhs[4]); double *X; /* set up output arguments */ plhs[0] = mxCreateDoubleMatrix(n,k,mxREAL); X = mxGetPr(plhs[0]); altra_mt(X, V, n, k, ind, nodes); }
slep_result_t slep_mc_tree_lr( CDotFeatures* features, CMulticlassLabels* labels, float64_t z, const slep_options& options) { int i,j; // obtain problem parameters int n_feats = features->get_dim_feature_space(); int n_vecs = features->get_num_vectors(); int n_classes = labels->get_num_classes(); // labels vector containing values in range (0 .. n_classes) SGVector<float64_t> labels_vector = labels->get_labels(); // initialize matrices and vectors to be used // weight vector MatrixXd w = MatrixXd::Zero(n_feats, n_classes); // intercepts (biases) VectorXd c = VectorXd::Zero(n_classes); if (options.last_result) { SGMatrix<float64_t> last_w = options.last_result->w; SGVector<float64_t> last_c = options.last_result->c; for (i=0; i<n_classes; i++) { c[i] = last_c[i]; for (j=0; j<n_feats; j++) w(j,i) = last_w(j,i); } } // iterative process matrices and vectors MatrixXd wp = w, wwp = MatrixXd::Zero(n_feats, n_classes); VectorXd cp = c, ccp = VectorXd::Zero(n_classes); // search point weight vector MatrixXd search_w = MatrixXd::Zero(n_feats, n_classes); // search point intercepts VectorXd search_c = VectorXd::Zero(n_classes); // dot products MatrixXd Aw = MatrixXd::Zero(n_vecs, n_classes); for (j=0; j<n_classes; j++) features->dense_dot_range(Aw.col(j).data(), 0, n_vecs, NULL, w.col(j).data(), n_feats, 0.0); MatrixXd As = MatrixXd::Zero(n_vecs, n_classes); MatrixXd Awp = MatrixXd::Zero(n_vecs, n_classes); // gradients MatrixXd g = MatrixXd::Zero(n_feats, n_classes); VectorXd gc = VectorXd::Zero(n_classes); // projection MatrixXd v = MatrixXd::Zero(n_feats, n_classes); // Lipschitz continuous gradient parameter for line search double L = 1.0/(n_vecs*n_classes); // coefficients for search point computation double alphap = 0, alpha = 1; // lambda regularization parameter double lambda = z; // objective values double objective = 0.0; double objective_p = 0.0; int iter = 0; bool done = false; CTime time; //internal::set_is_malloc_allowed(false); while ((!done) && (iter<options.max_iter) && (!CSignal::cancel_computations())) { double beta = (alphap-1)/alpha; // compute search points search_w = w + beta*wwp; search_c = c + beta*ccp; // update dot products with search point As = Aw + beta*(Aw-Awp); // compute objective and gradient at search point double fun_s = 0; g.setZero(); gc.setZero(); // for each vector for (i=0; i<n_vecs; i++) { // class of current vector int vec_class = labels_vector[i]; // for each class for (j=0; j<n_classes; j++) { // compute logistic loss double aa = ((vec_class == j) ? -1.0 : 1.0)*(As(i,j) + search_c(j)); double bb = aa > 0.0 ? aa : 0.0; // avoid underflow via log-sum-exp trick fun_s += CMath::log(CMath::exp(-bb) + CMath::exp(aa-bb)) + bb; double prob = 1.0/(1+CMath::exp(aa)); double b = ((vec_class == j) ? -1.0 : 1.0)*(1-prob);///(n_vecs*n_classes); // update gradient of intercepts gc[j] += b; // update gradient of weight vectors features->add_to_dense_vec(b, i, g.col(j).data(), n_feats); } } //fun_s /= (n_vecs*n_classes); wp = w; Awp = Aw; cp = c; int inner_iter = 0; double fun_x = 0; // line search process while (inner_iter<5000) { // compute line search point v = search_w - g/L; c = search_c - gc/L; // compute projection of gradient if (options.general) general_altra_mt(w.data(),v.data(),n_classes,n_feats,options.G,options.ind_t,options.n_nodes,lambda/L); else altra_mt(w.data(),v.data(),n_classes,n_feats,options.ind_t,options.n_nodes,lambda/L); v = w - search_w; // update dot products for (j=0; j<n_classes; j++) features->dense_dot_range(Aw.col(j).data(), 0, n_vecs, NULL, w.col(j).data(), n_feats, 0.0); // compute objective at search point fun_x = 0; for (i=0; i<n_vecs; i++) { int vec_class = labels_vector[i]; for (j=0; j<n_classes; j++) { double aa = ((vec_class == j) ? -1.0 : 1.0)*(Aw(i,j) + c(j)); double bb = aa > 0.0 ? aa : 0.0; fun_x += CMath::log(CMath::exp(-bb) + CMath::exp(aa-bb)) + bb; } } //fun_x /= (n_vecs*n_classes); // check for termination of line search double r_sum = (v.squaredNorm() + (c-search_c).squaredNorm())/2; double l_sum = fun_x - fun_s - v.cwiseProduct(g).sum() - (c-search_c).dot(gc); // stop if projected gradient is less than 1e-20 if (r_sum <= 1e-20) { SG_SINFO("Gradient step makes little improvement (%f)\n",r_sum) done = true; break; } if (l_sum <= r_sum*L) break; else L = CMath::max(2*L, l_sum/r_sum); inner_iter++; } // update alpha coefficients alphap = alpha; alpha = (1+CMath::sqrt(4*alpha*alpha+1))/2; // update wwp and ccp wwp = w - wp; ccp = c - cp; // update objectives objective_p = objective; objective = fun_x; // compute tree norm double tree_norm = 0.0; if (options.general) { for (i=0; i<n_classes; i++) tree_norm += general_treeNorm(w.col(i).data(),n_classes,n_feats,options.G,options.ind_t,options.n_nodes); } else { for (i=0; i<n_classes; i++) tree_norm += treeNorm(w.col(i).data(),n_classes,n_feats,options.ind_t,options.n_nodes); } // regularize objective with tree norm objective += lambda*tree_norm; //cout << "Objective = " << objective << endl; // check for termination of whole process if ((CMath::abs(objective - objective_p) < options.tolerance*CMath::abs(objective_p)) && (iter>2)) { SG_SINFO("Objective changes less than tolerance\n") done = true; } iter++; } SG_SINFO("%d iterations passed, objective = %f\n",iter,objective) //internal::set_is_malloc_allowed(true); // output computed weight vectors and intercepts SGMatrix<float64_t> r_w(n_feats,n_classes); for (j=0; j<n_classes; j++) { for (i=0; i<n_feats; i++) r_w(i,j) = w(i,j); } //r_w.display_matrix(); SGVector<float64_t> r_c(n_classes); for (j=0; j<n_classes; j++) r_c[j] = c[j]; return slep_result_t(r_w, r_c); };