probably working continuous X

Author: Kieran Elmes

R/pint.R

@@ -12,6 +12,8 @@
 val_to_list_name <- function(val, X) {
     range <- ncol(X)
     names <- colnames(X)
+    print(sprintf("val: %s", val))
+    print(sprintf("range: %s", range))
     if (val < range) {
         return(names[val + 1])
     } else if (val < range * range) {
@@ -29,8 +31,8 @@ val_to_list_name <- function(val, X) {
 process_result <- function(X, result) {
     i <- colnames(X)[result[[1]]]
     strength <- result[[2]]
-    equiv_list = c()
-    if (length(result[[3]]) > 0) {
+    equiv_list <- c()
+    if (length(result[[3]][0]) > 0) {
         equiv_list <- lapply(result[[3]], val_to_list_name, X)
         names(equiv_list) <- i
     }
@@ -39,8 +41,8 @@ process_result <- function(X, result) {
     i <- colnames(X)[result[[4]]]
     j <- colnames(X)[result[[5]]]
     strength <- result[[6]]
-    equiv_list = c()
-    if (length(result[[7]]) > 0) {
+    equiv_list <- c()
+    if (length(result[[7]][0]) > 0) {
         equiv_list <- lapply(result[[7]], val_to_list_name, X)
         names(equiv_list) <- paste0(i, ",", j)
     }
@@ -49,8 +51,8 @@ process_result <- function(X, result) {
     i <- colnames(X)[result[[8]]]
     j <- colnames(X)[result[[9]]]
     k <- colnames(X)[result[[10]]]
-    equiv_list = c()
-    if (length(result[[12]]) > 0) {
+    equiv_list <- c()
+    if (length(result[[12]][0]) > 0) {
         equiv_list <- lapply(result[[12]], val_to_list_name, X)
         names(equiv_list) <- paste0(i, ",", j, ",", k)
     }
@@ -69,7 +71,7 @@ read_log <- function(log_filename="regression.log") {
     return(process_result(result))
 }
 
-interaction_lasso <- function(X, Y, n = dim(X)[1], p = dim(X)[2], lambda_min = -1, halt_error_diff=1.01, max_interaction_distance=-1, max_nz_beta=-1, max_lambdas=200, verbose=FALSE, log_filename="regression.log", depth=2, log_level="none", estimate_unbiased=FALSE, use_intercept=TRUE, num_threads=-1, strong_hierarchy=FALSE, check_duplicates=FALSE) {
+interaction_lasso <- function(X, Y, n = dim(X)[1], p = dim(X)[2], lambda_min = -1, halt_error_diff=1.01, max_interaction_distance=-1, max_nz_beta=-1, max_lambdas=200, verbose=FALSE, log_filename="regression.log", depth=2, log_level="none", estimate_unbiased=FALSE, use_intercept=TRUE, num_threads=-1, strong_hierarchy=FALSE, check_duplicates=FALSE, continuous_X=FALSE) {
     Ym = as.matrix(Y)
     if (!dim(Ym)[1] == n) {
         stop("Y does not have the same number of rows as X, or the format is wrong")
@@ -79,7 +81,6 @@ interaction_lasso <- function(X, Y, n = dim(X)[1], p = dim(X)[2], lambda_min = -
     if (continuous_X) {
         check_duplicates <- FALSE
     }
-    continuous_X <- FALSE # not implemented yet.
 
     log_level_enum = 0;
     if (log_level == "lambda") {
@@ -112,7 +113,11 @@ interaction_lasso <- function(X, Y, n = dim(X)[1], p = dim(X)[2], lambda_min = -
         main_only = .Call(lasso_, X, Ym, lambda_min, lambda_max, halt_error_diff, max_interaction_distance, max_nz_beta*2, max_lambdas, verbose, log_filename, 1, log_level_enum, estimate_unbiased, use_intercept, num_threads, check_duplicates, continuous_X)
         main_only_result <- process_result(X, main_only[[1]])
         # we'll use these to allow the second run to report all identical columns again.
-        all_equiv <- unique(unlist(main_only_result$main_effects$equivalent))
+        if (check_duplicates) {
+            all_equiv <- unique(unlist(main_only_result$main_effects$equivalent))
+        } else {
+            all_equiv <- unique(unlist(main_only_result$main_effects$i))
+        }
 
         X <- X[,all_equiv]
     }

coverage-badge.svg

@@ -42,7 +42,8 @@ Y <- d$Y
 ## result <- interaction_lasso(X, Y, lambda_min = -1, max_interaction_distance = -1, use_adaptive_calibration = FALSE, max_nz_beta = 200, depth = 3)
 # result <- interaction_lasso(X, Y, depth = 3)
 # result <- interaction_lasso(X, Y, depth = 2)
-result <- interaction_lasso(X, Y, depth = 2, max_nz_beta = 150, estimate_unbiased = TRUE, num_threads = 4, verbose=TRUE, strong_hierarchy = TRUE, check_duplicates = TRUE)
+# result <- interaction_lasso(X, Y, depth = 2, max_nz_beta = 150, estimate_unbiased = TRUE, num_threads = 4, verbose=TRUE, strong_hierarchy = TRUE, check_duplicates = TRUE, continuous_X = TRUE)
+result <- interaction_lasso(X, Y, depth = 2, max_nz_beta = 150, estimate_unbiased = TRUE, num_threads = 4, verbose=TRUE, strong_hierarchy = FALSE, check_duplicates = TRUE, continuous_X = TRUE)
 # print(result)
 
 # q()

install_and_run.R

@@ -10,6 +10,7 @@ add_project_arguments([
   '-ffast-math',
   '-fno-stack-protector',
   '-fpermissive',
+  '-Wno-unused',
  #'-Ofast',
  # '-g',
   # '-Os',

meson.build

@@ -359,7 +359,7 @@ SEXP lasso_(SEXP X_, SEXP Y_, SEXP lambda_min_, SEXP lambda_max_,
     Lasso_Result lasso_result = simple_coordinate_descent_lasso(
         xmatrix, Y, n, p, max_interaction_distance, asReal(lambda_min_),
         asReal(lambda_max_), max_lambdas, verbose, halt_error_diff, log_level, NULL, 0,
-        max_nz_beta, log_filename, depth, estimate_unbiased, use_intercept, check_duplicates, continuous_X, ci);
+        max_nz_beta, log_filename, depth, estimate_unbiased, use_intercept, check_duplicates, &ci);
     float final_lambda = lasso_result.final_lambda;
     float regularized_intercept = lasso_result.regularized_intercept;
     float unbiased_intercept = lasso_result.unbiased_intercept;

src/Pint.cpp

@@ -104,6 +104,7 @@ struct continuous_info {
     std::vector<float>* col_real_vals;
     float* col_max_vals;
 };
+void free_continuous_info(struct continuous_info ci);
 
 typedef struct {
     robin_hood::unordered_flat_map<XXH64_hash_t, robin_hood::unordered_flat_map<XXH64_hash_t, robin_hood::unordered_flat_set<int_fast64_t>>> cols_for_hash;
@@ -145,6 +146,7 @@ struct AS_Entry {
     S8bCol col;
     float *last_rowsum;
     float last_max;
+    std::vector<float> real_vals;
 };
 
 typedef struct {

src/liblasso.h

@@ -61,12 +61,11 @@ void* queue_pop_head(Queue* q)
 void queue_free(Queue* q)
 {
     Queue_Item* current_item = q->first_item;
-    Queue_Item* next_item = (Queue_Item*)current_item->next;
 
     // free the queue contents
     while (current_item != NULL) {
         free(current_item->contents);
-        next_item = (Queue_Item*)current_item->next;
+        Queue_Item* next_item = (Queue_Item*)current_item->next;
         free(current_item);
         current_item = next_item;
     }

src/queue.cpp

@@ -158,7 +158,7 @@ static auto rng = std::default_random_engine();
 
 void subproblem_only(Iter_Vars* vars, float lambda, float* rowsum,
     float* old_rowsum, Active_Set* active_set,
-    int_fast64_t depth, char use_intercept)
+    int_fast64_t depth, char use_intercept, struct continuous_info* cont_inf)
 {
     float** last_rowsum = vars->last_rowsum;
     Thread_Cache* thread_caches = vars->thread_caches;
@@ -205,8 +205,8 @@ void subproblem_only(Iter_Vars* vars, float lambda, float* rowsum,
             if (entry.present) {
                 if (current_beta_set->contains(k) && fabs(current_beta_set->at(k)) != 0.0) {
                     update_beta_cyclic(
-                        entry.col, Y, rowsum, n, p, lambda, current_beta_set, k, vars->intercept,
-                        thread_caches[omp_get_thread_num()].col_i);
+                        &entry, Y, rowsum, n, p, lambda, current_beta_set, k, vars->intercept,
+                        thread_caches[omp_get_thread_num()].col_i, cont_inf);
                 }
             }
         }
@@ -265,6 +265,7 @@ int_fast64_t run_lambda_iters_pruned(Iter_Vars* vars, float lambda, float* rowsu
     for (int_fast64_t i = 0; i < n; i++) {
         error += rowsum[i] * rowsum[i];
     }
+    error = sqrt(error);
 
     // run several iterations of will_update to make sure we catch any new
     // columns
@@ -405,8 +406,8 @@ int_fast64_t run_lambda_iters_pruned(Iter_Vars* vars, float lambda, float* rowsu
                         was_zero = FALSE;
                     total_beta_updates++;
                     Changes changes = update_beta_cyclic(
-                        entry.col, Y, rowsum, n, p, lambda, current_beta_set, k, vars->intercept,
-                        thread_caches[omp_get_thread_num()].col_i);
+                        &entry, Y, rowsum, n, p, lambda, current_beta_set, k, vars->intercept,
+                        thread_caches[omp_get_thread_num()].col_i, cont_inf);
                     if (changes.actual_diff == 0.0) {
                         total_unchanged++;
                     } else {
@@ -495,8 +496,9 @@ Lasso_Result simple_coordinate_descent_lasso(
     float hed, enum LOG_LEVEL log_level,
     const char** job_args, int_fast64_t job_args_num,
     int_fast64_t mnz_beta, const char* log_filename, int_fast64_t depth,
-    const bool estimate_unbiased, const bool use_intercept, const bool check_duplicates, const bool continuous_X, struct continuous_info* cont_inf)
+    const bool estimate_unbiased, const bool use_intercept, const bool check_duplicates, struct continuous_info* cont_inf)
 {
+    const bool continuous_X = cont_inf->use_cont;
     int_fast64_t max_nz_beta = mnz_beta;
     if (verbose)
         printf("n: %ld, p: %ld\n", n, p);
@@ -857,7 +859,7 @@ Lasso_Result simple_coordinate_descent_lasso(
         };
         // run_lambda_iters_pruned(&iter_vars_pruned, 0.0, rowsum,
         subproblem_only(&iter_vars_pruned, 0.0, rowsum,
-            old_rowsum, &active_set, depth, use_intercept);
+            old_rowsum, &active_set, depth, use_intercept, cont_inf);
         if (verbose)
             printf("un-regularized error: %f\n", calculate_error(Y, rowsum, n));
         unbiased_intercept = iter_vars_pruned.intercept;
@@ -965,18 +967,22 @@ Changes update_beta_cyclic_old(
 
     return changes;
 }
-Changes update_beta_cyclic(S8bCol col, float* Y, float* rowsum, int_fast64_t n, int_fast64_t p,
+Changes update_beta_cyclic(AS_Entry* as_entry, float* Y, float* rowsum, int_fast64_t n, int_fast64_t p,
     float lambda,
     robin_hood::unordered_flat_map<int_fast64_t, float>* beta,
-    int_fast64_t k, float intercept, int_fast64_t* column_entry_cache)
+    int_fast64_t k, float intercept, int_fast64_t* column_entry_cache, struct continuous_info* ci)
 {
+    S8bCol col = as_entry->col;
     float sumk = col.nz;
+    if (ci->use_cont)
+        sumk = 0.0;
     float bk = 0.0;
     if (beta->contains(k)) {
         bk = beta->at(k);
     }
-    float sumn = col.nz * bk;
+    float sumn = 0.0;
     int_fast64_t* column_entries = column_entry_cache;
+    std::vector<float> col_real_vals = as_entry->real_vals;
 
     int_fast64_t col_entry_pos = 0;
     int_fast64_t entry = -1;
@@ -988,12 +994,20 @@ Changes update_beta_cyclic(S8bCol col, float* Y, float* rowsum, int_fast64_t n,
             if (diff != 0) {
                 entry += diff;
                 column_entries[col_entry_pos] = entry;
-                sumn -= rowsum[entry];
+                float rs = rowsum[entry];
+                if (ci->use_cont) {
+                    float cv = col_real_vals[col_entry_pos];
+                    rs *= cv;
+                    sumk += cv*cv;
+                    // sumn += cv*bk;
+                }
+                sumn -= rs;
                 col_entry_pos++;
             }
             values >>= item_width[word.selector];
         }
     }
+    sumn += sumk*bk;
 
     float new_value = soft_threshold(sumn, lambda * total_sqrt_error) / sumk; // square root lasso
     float Bk_diff = new_value - bk;
@@ -1011,8 +1025,11 @@ Changes update_beta_cyclic(S8bCol col, float* Y, float* rowsum, int_fast64_t n,
     if (Bk_diff != 0) {
         for (int_fast64_t e = 0; e < col.nz; e++) {
             int_fast64_t i = column_entries[e];
+            float offset = Bk_diff;
+            if (ci->use_cont)
+                offset *= col_real_vals[e];
 #pragma omp atomic
-            rowsum[i] += Bk_diff;
+            rowsum[i] += offset;
         }
     } else {
         zero_updates++;

src/regression.cpp

@@ -30,13 +30,13 @@ Lasso_Result simple_coordinate_descent_lasso(
     float lambda_min, float lambda_max, int_fast64_t max_iter, const bool VERBOSE,
     float halt_beta_diff,
     enum LOG_LEVEL log_level, const char** job_args, int_fast64_t job_args_num,
-    int_fast64_t max_nz_beta, const char* log_filename, int_fast64_t depth, const bool estimate_unbiased, const bool use_intercept, const bool check_duplicates, const bool continuous_X, struct continuous_info* cont_inf);
+    int_fast64_t max_nz_beta, const char* log_filename, int_fast64_t depth, const bool estimate_unbiased, const bool use_intercept, const bool check_duplicates, struct continuous_info* cont_inf);
 float update_intercept_cyclic(float intercept, int_fast64_t** X, float* Y,
     robin_hood::unordered_flat_map<int_fast64_t, float>* beta, int_fast64_t n, int_fast64_t p);
 // Changes update_beta_cyclic(XMatrixSparse xmatrix_sparse, float *Y,
-Changes update_beta_cyclic(S8bCol col, float* Y, float* rowsum, int_fast64_t n, int_fast64_t p,
+Changes update_beta_cyclic(AS_Entry* entry, float* Y, float* rowsum, int_fast64_t n, int_fast64_t p,
     float lambda, robin_hood::unordered_flat_map<int_fast64_t, float>* beta, int_fast64_t k,
-    float intercept, int_fast64_t* column_cache);
+    float intercept, int_fast64_t* column_cache, struct continuous_info* ci);
 Changes update_beta_cyclic_old(XMatrixSparse xmatrix_sparse, float* Y,
     float* rowsum, int_fast64_t n, int_fast64_t p, float lambda,
     robin_hood::unordered_flat_map<int_fast64_t, float>* beta, int_fast64_t k, float intercept,

src/regression.h

@@ -192,7 +192,7 @@ std::vector<int_fast64_t> update_main_indistinguishable_cols(
         XXH3_128bits_reset(mh_state);
         XXH3_128bits_update(mh_state, column_entries, main_col_len * sizeof(int_fast64_t));
         if (ci->use_cont)
-            XXH3_128bits_update(mh_state, &ci->col_real_vals[main][0], ci->col_real_vals[main].size() * sizeof(ci->col_real_vals[0]));
+            XXH3_128bits_update(mh_state, &ci->col_real_vals[main][0], ci->col_real_vals[main].size() * sizeof(ci->col_real_vals[main][0]));
         XXH128_hash_t main_hash = XXH3_128bits_digest(mh_state);
         XXH3_freeState(mh_state);