/** The matrices for each combination could be explicitly expanded instead of using matrix multiplication. */ void Matrix4x4::FromEuler(float x, float y, float z, order_t order) { float xrad = x / 180.0f * 3.1415927f; float sx = sinf(xrad); float cx = cosf(xrad); Matrix4x4 xMat(1.0, 0.0, 0.0, 0.0, 0.0, cx, -sx, 0.0, 0.0, sx, cx, 0.0, 0.0, 0.0, 0.0, 1.0); float yrad = y / 180.0f * 3.1415927f; float sy = sinf(yrad); float cy = cosf(yrad); Matrix4x4 yMat( cy, 0.0, sy, 0.0, 0.0, 1.0, 0.0, 0.0, -sy, 0.0, cy, 0.0, 0.0, 0.0, 0.0, 1.0); float zrad = z / 180.0f * 3.1415927f; float sz = sinf(zrad); float cz = cosf(zrad); Matrix4x4 zMat( cz, -sz, 0.0, 0.0, sz, cz, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0); switch(order) { case kXYZ: *this = zMat * (yMat * xMat); break; case kYXZ: *this = zMat * (xMat * yMat); break; case kYZX: *this = xMat * (zMat * yMat); break; case kXZY: *this = yMat * (zMat * xMat); break; case kZYX: *this = xMat * (yMat * zMat); break; case kZXY: *this = yMat * (xMat * zMat); break; default: *this = xMat * (yMat * zMat); break; } }
void perceptron::trainRegression(double a, double *x, double *y, int k, int max) { // Prepare y matrix Eigen::MatrixXd yMat(k, 1); for(int i = 0; i < k; i++) yMat(i, 0) = y[i]; // Prepare x matrix (unfold the provided array) Eigen::MatrixXd xMat(k, n + 1); for(int i = 0; i < k; i++) { xMat(i, 0) = 1.0; for(int j = 0; j < n; j++) { xMat(i, j + 1) = x[n * i + j]; } } Eigen::MatrixXd xMatT = xMat.transpose(); Eigen::MatrixXd wMat = ((xMatT * xMat).inverse() * xMatT) * yMat; // W = ((Xt * X)^-1 * Xt) * Y // Map back to w Eigen::Map<Eigen::MatrixXd>(w, n + 1, 1) = wMat; }
// Coordinate descent for gaussian models (no active cycling) RcppExport SEXP cdfit_gaussian_nac(SEXP X_, SEXP y_, SEXP row_idx_, SEXP lambda_, SEXP nlambda_, SEXP lam_scale_, SEXP lambda_min_, SEXP alpha_, SEXP user_, SEXP eps_, SEXP max_iter_, SEXP multiplier_, SEXP dfmax_, SEXP ncore_, SEXP verbose_) { XPtr<BigMatrix> xMat(X_); double *y = REAL(y_); int *row_idx = INTEGER(row_idx_); double lambda_min = REAL(lambda_min_)[0]; double alpha = REAL(alpha_)[0]; int n = Rf_length(row_idx_); // number of observations used for fitting model int p = xMat->ncol(); int L = INTEGER(nlambda_)[0]; int lam_scale = INTEGER(lam_scale_)[0]; int user = INTEGER(user_)[0]; int verbose = INTEGER(verbose_)[0]; double eps = REAL(eps_)[0]; int max_iter = INTEGER(max_iter_)[0]; double *m = REAL(multiplier_); int dfmax = INTEGER(dfmax_)[0]; NumericVector lambda(L); NumericVector center(p); NumericVector scale(p); int p_keep = 0; int *p_keep_ptr = &p_keep; vector<int> col_idx; vector<double> z; double lambda_max = 0.0; double *lambda_max_ptr = &lambda_max; int xmax_idx = 0; int *xmax_ptr = &xmax_idx; // set up omp int useCores = INTEGER(ncore_)[0]; #ifdef BIGLASSO_OMP_H_ int haveCores = omp_get_num_procs(); if(useCores < 1) { useCores = haveCores; } omp_set_dynamic(0); omp_set_num_threads(useCores); #endif if (verbose) { char buff1[100]; time_t now1 = time (0); strftime (buff1, 100, "%Y-%m-%d %H:%M:%S.000", localtime (&now1)); Rprintf("\nPreprocessing start: %s\n", buff1); } // standardize: get center, scale; get p_keep_ptr, col_idx; get z, lambda_max, xmax_idx; standardize_and_get_residual(center, scale, p_keep_ptr, col_idx, z, lambda_max_ptr, xmax_ptr, xMat, y, row_idx, lambda_min, alpha, n, p); p = p_keep; // set p = p_keep, only loop over columns whose scale > 1e-6 if (verbose) { char buff1[100]; time_t now1 = time (0); strftime (buff1, 100, "%Y-%m-%d %H:%M:%S.000", localtime (&now1)); Rprintf("Preprocessing end: %s\n", buff1); Rprintf("\n-----------------------------------------------\n"); } // Objects to be returned to R arma::sp_mat beta = arma::sp_mat(p, L); // beta double *a = Calloc(p, double); //Beta from previous iteration NumericVector loss(L); IntegerVector iter(L); IntegerVector n_reject(L); double l1, l2, shift; double max_update, update, thresh; // for convergence check int i, j, jj, l, lstart; double *r = Calloc(n, double); for (i = 0; i < n; i++) r[i] = y[i]; double sumResid = sum(r, n); loss[0] = gLoss(r,n); thresh = eps * loss[0] / n; // set up lambda if (user == 0) { if (lam_scale) { // set up lambda, equally spaced on log scale double log_lambda_max = log(lambda_max); double log_lambda_min = log(lambda_min*lambda_max); double delta = (log_lambda_max - log_lambda_min) / (L-1); for (l = 0; l < L; l++) { lambda[l] = exp(log_lambda_max - l * delta); } } else { // equally spaced on linear scale double delta = (lambda_max - lambda_min*lambda_max) / (L-1); for (l = 0; l < L; l++) { lambda[l] = lambda_max - l * delta; } } lstart = 1; } else { lstart = 0; lambda = Rcpp::as<NumericVector>(lambda_); } // Path for (l = lstart; l < L; l++) { if(verbose) { // output time char buff[100]; time_t now = time (0); strftime (buff, 100, "%Y-%m-%d %H:%M:%S.000", localtime (&now)); Rprintf("Lambda %d. Now time: %s\n", l, buff); } if (l != 0) { // Check dfmax int nv = 0; for (j = 0; j < p; j++) { if (a[j] != 0) nv++; } if (nv > dfmax) { for (int ll=l; ll<L; ll++) iter[ll] = NA_INTEGER; Free_memo_nac(a, r); return List::create(beta, center, scale, lambda, loss, iter, n_reject, Rcpp::wrap(col_idx)); } } while(iter[l] < max_iter) { iter[l]++; max_update = 0.0; for (j = 0; j < p; j++) { jj = col_idx[j]; z[j] = crossprod_resid(xMat, r, sumResid, row_idx, center[jj], scale[jj], n, jj) / n + a[j]; l1 = lambda[l] * m[jj] * alpha; l2 = lambda[l] * m[jj] * (1-alpha); beta(j, l) = lasso(z[j], l1, l2, 1); shift = beta(j, l) - a[j]; if (shift !=0) { // compute objective update for checking convergence //update = z[j] * shift - 0.5 * (1 + l2) * (pow(beta(j, l), 2) - pow(a[j], 2)) - l1 * (fabs(beta(j, l)) - fabs(a[j])); update = pow(beta(j, l) - a[j], 2); if (update > max_update) { max_update = update; } update_resid(xMat, r, shift, row_idx, center[jj], scale[jj], n, jj); // update r sumResid = sum(r, n); //update sum of residual a[j] = beta(j, l); //update a } } // Check for convergence if (max_update < thresh) { loss[l] = gLoss(r, n); break; } } } Free_memo_nac(a, r); return List::create(beta, center, scale, lambda, loss, iter, n_reject, Rcpp::wrap(col_idx)); }
// Coordinate descent for logistic models (no active set cycling) RcppExport SEXP cdfit_binomial_hsr_slores_nac(SEXP X_, SEXP y_, SEXP n_pos_, SEXP ylab_, SEXP row_idx_, SEXP lambda_, SEXP nlambda_, SEXP lam_scale_, SEXP lambda_min_, SEXP alpha_, SEXP user_, SEXP eps_, SEXP max_iter_, SEXP multiplier_, SEXP dfmax_, SEXP ncore_, SEXP warn_, SEXP safe_thresh_, SEXP verbose_) { XPtr<BigMatrix> xMat(X_); double *y = REAL(y_); int n_pos = INTEGER(n_pos_)[0]; IntegerVector ylabel = Rcpp::as<IntegerVector>(ylab_); // label vector of {-1, 1} int *row_idx = INTEGER(row_idx_); double lambda_min = REAL(lambda_min_)[0]; double alpha = REAL(alpha_)[0]; int n = Rf_length(row_idx_); // number of observations used for fitting model int p = xMat->ncol(); int L = INTEGER(nlambda_)[0]; int lam_scale = INTEGER(lam_scale_)[0]; double eps = REAL(eps_)[0]; int max_iter = INTEGER(max_iter_)[0]; double *m = REAL(multiplier_); int dfmax = INTEGER(dfmax_)[0]; int warn = INTEGER(warn_)[0]; int user = INTEGER(user_)[0]; double slores_thresh = REAL(safe_thresh_)[0]; // threshold for safe test int verbose = INTEGER(verbose_)[0]; NumericVector lambda(L); NumericVector Dev(L); IntegerVector iter(L); IntegerVector n_reject(L); // number of total rejections; IntegerVector n_slores_reject(L); // number of safe rejections; NumericVector beta0(L); NumericVector center(p); NumericVector scale(p); int p_keep = 0; // keep columns whose scale > 1e-6 int *p_keep_ptr = &p_keep; vector<int> col_idx; vector<double> z; double lambda_max = 0.0; double *lambda_max_ptr = &lambda_max; int xmax_idx = 0; int *xmax_ptr = &xmax_idx; // set up omp int useCores = INTEGER(ncore_)[0]; #ifdef BIGLASSO_OMP_H_ int haveCores = omp_get_num_procs(); if(useCores < 1) { useCores = haveCores; } omp_set_dynamic(0); omp_set_num_threads(useCores); #endif if (verbose) { char buff1[100]; time_t now1 = time (0); strftime (buff1, 100, "%Y-%m-%d %H:%M:%S.000", localtime (&now1)); Rprintf("\nPreprocessing start: %s\n", buff1); } // standardize: get center, scale; get p_keep_ptr, col_idx; get z, lambda_max, xmax_idx; standardize_and_get_residual(center, scale, p_keep_ptr, col_idx, z, lambda_max_ptr, xmax_ptr, xMat, y, row_idx, lambda_min, alpha, n, p); p = p_keep; // set p = p_keep, only loop over columns whose scale > 1e-6 if (verbose) { char buff1[100]; time_t now1 = time (0); strftime (buff1, 100, "%Y-%m-%d %H:%M:%S.000", localtime (&now1)); Rprintf("Preprocessing end: %s\n", buff1); Rprintf("\n-----------------------------------------------\n"); } arma::sp_mat beta = arma::sp_mat(p, L); //beta double *a = Calloc(p, double); //Beta from previous iteration double a0 = 0.0; //beta0 from previousiteration double *w = Calloc(n, double); double *s = Calloc(n, double); //y_i - pi_i double *eta = Calloc(n, double); // int *e1 = Calloc(p, int); //ever-active set int *e2 = Calloc(p, int); //strong set double xwr, xwx, pi, u, v, cutoff, l1, l2, shift, si; double max_update, update, thresh; // for convergence check int i, j, jj, l, violations, lstart; double ybar = sum(y, n) / n; a0 = beta0[0] = log(ybar / (1-ybar)); double nullDev = 0; double *r = Calloc(n, double); for (i = 0; i < n; i++) { r[i] = y[i]; nullDev = nullDev - y[i]*log(ybar) - (1-y[i])*log(1-ybar); s[i] = y[i] - ybar; eta[i] = a0; } thresh = eps * nullDev / n; double sumS = sum(s, n); // temp result sum of s double sumWResid = 0.0; // temp result: sum of w * r // set up lambda if (user == 0) { if (lam_scale) { // set up lambda, equally spaced on log scale double log_lambda_max = log(lambda_max); double log_lambda_min = log(lambda_min*lambda_max); double delta = (log_lambda_max - log_lambda_min) / (L-1); for (l = 0; l < L; l++) { lambda[l] = exp(log_lambda_max - l * delta); } } else { // equally spaced on linear scale double delta = (lambda_max - lambda_min*lambda_max) / (L-1); for (l = 0; l < L; l++) { lambda[l] = lambda_max - l * delta; } } Dev[0] = nullDev; lstart = 1; n_reject[0] = p; } else { lstart = 0; lambda = Rcpp::as<NumericVector>(lambda_); } // Slores variables vector<double> theta_lam; double g_theta_lam = 0.0; double prod_deriv_theta_lam = 0.0; double *g_theta_lam_ptr = &g_theta_lam; double *prod_deriv_theta_lam_ptr = &prod_deriv_theta_lam; vector<double> X_theta_lam_xi_pos; vector<double> prod_PX_Pxmax_xi_pos; vector<double> cutoff_xi_pos; int *slores_reject = Calloc(p, int); int *slores_reject_old = Calloc(p, int); for (int j = 0; j < p; j++) slores_reject_old[j] = 1; int slores; // if 0, don't perform Slores rule if (slores_thresh < 1) { slores = 1; // turn on slores theta_lam.resize(n); X_theta_lam_xi_pos.resize(p); prod_PX_Pxmax_xi_pos.resize(p); cutoff_xi_pos.resize(p); slores_init(theta_lam, g_theta_lam_ptr, prod_deriv_theta_lam_ptr, cutoff_xi_pos, X_theta_lam_xi_pos, prod_PX_Pxmax_xi_pos, xMat, y, z, xmax_idx, row_idx, col_idx, center, scale, ylabel, n_pos, n, p); } else { slores = 0; } if (slores == 1 && user == 0) n_slores_reject[0] = p; for (l = lstart; l < L; l++) { if(verbose) { // output time char buff[100]; time_t now = time (0); strftime (buff, 100, "%Y-%m-%d %H:%M:%S.000", localtime (&now)); Rprintf("Lambda %d. Now time: %s\n", l, buff); } if (l != 0) { // Check dfmax int nv = 0; for (j = 0; j < p; j++) { if (a[j] != 0) { nv++; } } if (nv > dfmax) { for (int ll=l; ll<L; ll++) iter[ll] = NA_INTEGER; Free(slores_reject); Free(slores_reject_old); Free_memo_bin_hsr_nac(s, w, a, r, e2, eta); return List::create(beta0, beta, center, scale, lambda, Dev, iter, n_reject, Rcpp::wrap(col_idx)); } cutoff = 2*lambda[l] - lambda[l-1]; } else { cutoff = 2*lambda[l] - lambda_max; } if (slores) { slores_screen(slores_reject, theta_lam, g_theta_lam, prod_deriv_theta_lam, X_theta_lam_xi_pos, prod_PX_Pxmax_xi_pos, cutoff_xi_pos, row_idx, col_idx, center, scale, xmax_idx, ylabel, lambda[l], lambda_max, n_pos, n, p); n_slores_reject[l] = sum(slores_reject, p); // update z[j] for features which are rejected at previous lambda but accepted at current one. update_zj(z, slores_reject, slores_reject_old, xMat, row_idx, col_idx, center, scale, sumS, s, m, n, p); #pragma omp parallel for private(j) schedule(static) for (j = 0; j < p; j++) { slores_reject_old[j] = slores_reject[j]; // hsr screening // if (slores_reject[j] == 0 && (fabs(z[j]) > (cutoff * alpha * m[col_idx[j]]))) { if (fabs(z[j]) > (cutoff * alpha * m[col_idx[j]])) { e2[j] = 1; } else { e2[j] = 0; } } } else { n_slores_reject[l] = 0; // hsr screening over all #pragma omp parallel for private(j) schedule(static) for (j = 0; j < p; j++) { if (fabs(z[j]) > (cutoff * alpha * m[col_idx[j]])) { e2[j] = 1; } else { e2[j] = 0; } } } n_reject[l] = p - sum(e2, p); while (iter[l] < max_iter) { while (iter[l] < max_iter) { while (iter[l] < max_iter) { iter[l]++; Dev[l] = 0.0; for (i = 0; i < n; i++) { if (eta[i] > 10) { pi = 1; w[i] = .0001; } else if (eta[i] < -10) { pi = 0; w[i] = .0001; } else { pi = exp(eta[i]) / (1 + exp(eta[i])); w[i] = pi * (1 - pi); } s[i] = y[i] - pi; r[i] = s[i] / w[i]; if (y[i] == 1) { Dev[l] = Dev[l] - log(pi); } else { Dev[l] = Dev[l] - log(1-pi); } } if (Dev[l] / nullDev < .01) { if (warn) warning("Model saturated; exiting..."); for (int ll=l; ll<L; ll++) iter[ll] = NA_INTEGER; Free(slores_reject); Free(slores_reject_old); Free_memo_bin_hsr_nac(s, w, a, r, e2, eta); return List::create(beta0, beta, center, scale, lambda, Dev, iter, n_reject, n_slores_reject, Rcpp::wrap(col_idx)); } // Intercept xwr = crossprod(w, r, n, 0); xwx = sum(w, n); beta0[l] = xwr / xwx + a0; si = beta0[l] - a0; if (si != 0) { a0 = beta0[l]; for (i = 0; i < n; i++) { r[i] -= si; //update r eta[i] += si; //update eta } } sumWResid = wsum(r, w, n); // update temp result: sum of w * r, used for computing xwr; max_update = 0.0; for (j = 0; j < p; j++) { if (e2[j]) { jj = col_idx[j]; xwr = wcrossprod_resid(xMat, r, sumWResid, row_idx, center[jj], scale[jj], w, n, jj); v = wsqsum_bm(xMat, w, row_idx, center[jj], scale[jj], n, jj) / n; u = xwr/n + v * a[j]; l1 = lambda[l] * m[jj] * alpha; l2 = lambda[l] * m[jj] * (1-alpha); beta(j, l) = lasso(u, l1, l2, v); shift = beta(j, l) - a[j]; if (shift != 0) { // update change of objective function // update = - u * shift + (0.5 * v + 0.5 * l2) * (pow(beta(j, l), 2) - pow(a[j], 2)) + l1 * (fabs(beta(j, l)) - fabs(a[j])); update = pow(beta(j, l) - a[j], 2) * v; if (update > max_update) max_update = update; update_resid_eta(r, eta, xMat, shift, row_idx, center[jj], scale[jj], n, jj); // update r sumWResid = wsum(r, w, n); // update temp result w * r, used for computing xwr; a[j] = beta(j, l); // update a } } } // Check for convergence if (max_update < thresh) break; } } // Scan for violations in rest if (slores) { violations = check_rest_set_hsr_slores_nac(e2, slores_reject, z, xMat, row_idx, col_idx, center, scale, a, lambda[l], sumS, alpha, s, m, n, p); } else { violations = check_rest_set_bin_nac(e2, z, xMat, row_idx, col_idx, center, scale, a, lambda[l], sumS, alpha, s, m, n, p); } if (violations == 0) break; if (n_slores_reject[l] <= p * slores_thresh) { slores = 0; // turn off slores screening for next iteration if not efficient } } } Free(slores_reject); Free(slores_reject_old); Free_memo_bin_hsr_nac(s, w, a, r, e2, eta); return List::create(beta0, beta, center, scale, lambda, Dev, iter, n_reject, n_slores_reject, Rcpp::wrap(col_idx)); }