wip: allow continuous X

Author: Kieran Elmes

R/pint.R

@@ -75,6 +75,10 @@ interaction_lasso <- function(X, Y, n = dim(X)[1], p = dim(X)[2], lambda_min = -
         stop("Y does not have the same number of rows as X, or the format is wrong")
     }
 
+    # combination currently not implemented
+    if (continuous_X) {
+        check_duplicates <- FALSE
+    }
     continuous_X <- FALSE # not implemented yet.
 
     log_level_enum = 0;

src/Pint.cpp

@@ -321,20 +321,36 @@ SEXP lasso_(SEXP X_, SEXP Y_, SEXP lambda_min_, SEXP lambda_max_,
 
     float halt_error_diff = asReal(halt_error_diff_);
 
+    std::vector<float>* col_real_vals = new std::vector<float>[p];
+    float* col_max_vals = new float[p];
     int_fast64_t** X = (int_fast64_t**)malloc(p * sizeof *X);
     for (int_fast64_t i = 0; i < p; i++)
         X[i] = (int_fast64_t*)malloc(n * sizeof *X[i]);
 
     for (int_fast64_t i = 0; i < p; i++) {
+        float col_max_val = 0.0;
         for (int_fast64_t j = 0; j < n; j++) {
-            X[i][j] = (int)(x[j + i * n]);
+            float x_val = x[j + i * n];
+            if (fabs(x_val) > 0.0) {
+                col_real_vals[i].push_back(x_val);
+                X[i][j] = 1;
+                if (fabs(x_val) > fabs(col_max_val))
+                    col_max_val = x_val;
+            } else {
+                X[i][j] = 0;
+            }
         }
+        col_max_vals[i] = col_max_val;
     }
+    struct continuous_info ci;
+    ci.col_max_vals = col_max_vals;
+    ci.col_real_vals = col_real_vals;
+    ci.use_cont = continuous_X;
+   
     float* Y = (float*)malloc(n * sizeof(float));
     for (int_fast64_t i = 0; i < n; i++) {
         Y[i] = (float)y[i];
     }
-
     XMatrix xmatrix;
     xmatrix.actual_cols = n;
     xmatrix.X = X;
@@ -343,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);
+        max_nz_beta, log_filename, depth, estimate_unbiased, use_intercept, check_duplicates, continuous_X, ci);
     float final_lambda = lasso_result.final_lambda;
     float regularized_intercept = lasso_result.regularized_intercept;
     float unbiased_intercept = lasso_result.unbiased_intercept;

src/liblasso.cpp

@@ -153,4 +153,9 @@ int_fast64_t** X2_from_X(int_fast64_t** X, int_fast64_t n, int_fast64_t p)
         }
     }
     return X2;
+}
+
+void free_continuous_info(struct continuous_info ci) {
+    delete[] ci.col_real_vals;
+    delete[] ci.col_max_vals;
 }

src/liblasso.h

@@ -99,6 +99,12 @@ struct OpenCL_Setup {
 //     int_fast64_t b : 64;
 // } int_128;
 
+struct continuous_info {
+    bool use_cont;
+    std::vector<float>* col_real_vals;
+    float* col_max_vals;
+};
+
 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;
     // robin_hood::unordered_flat_map<int64_t, std::vector<int64_t>> defining_co;

src/pruning.cpp

@@ -47,7 +47,7 @@ float pessimistic_estimate(float alpha, float* last_rowsum, float* rowsum,
 // the worst case effect is \leq last_max * alpha + pessimistic_estimate()
 float l2_combined_estimate(X_uncompressed X, float lambda, int_fast64_t k,
     float last_max, float* last_rowsum,
-    float* rowsum)
+    float* rowsum, struct continuous_info* ci)
 {
     float alpha = 0.0;
     // read through the compressed column
@@ -70,6 +70,8 @@ float l2_combined_estimate(X_uncompressed X, float lambda, int_fast64_t k,
         alpha = 0.0;
 
     float remainder = pessimistic_estimate(alpha, last_rowsum, rowsum, col, X.host_col_nz[k]);
+    if (ci->use_cont)
+        remainder *= fabs(ci->col_max_vals[k]);
 
     float total_estimate = fabs(last_max * alpha) + remainder;
     return total_estimate;
@@ -87,10 +89,10 @@ float l2_combined_estimate(X_uncompressed X, float lambda, int_fast64_t k,
  */
 // TODO: should beta[k] be in here?
 bool wont_update_effect(X_uncompressed X, float lambda, int_fast64_t k, float last_max,
-    float* last_rowsum, float* rowsum, int_fast64_t* column_cache)
+    float* last_rowsum, float* rowsum, int_fast64_t* column_cache, struct continuous_info* ci)
 {
     // int_fast64_t* cache = malloc(X.n * sizeof *column_cache);
-    float upper_bound = l2_combined_estimate(X, lambda, k, last_max, last_rowsum, rowsum);
+    float upper_bound = l2_combined_estimate(X, lambda, k, last_max, last_rowsum, rowsum, ci);
     return upper_bound <= lambda * total_sqrt_error;
 }
 
@@ -115,7 +117,7 @@ float as_pessimistic_estimate(float alpha, float* last_rowsum, float* rowsum,
     return estimate;
 }
 
-float as_combined_estimate(float lambda, float last_max, float* last_rowsum, float* rowsum, S8bCol col, int_fast64_t* cache)
+float as_combined_estimate(float lambda, float last_max, float* last_rowsum, float* rowsum, S8bCol col, int_fast64_t* cache, float col_max, bool use_cont)
 {
     float alpha = 0.0;
     // read through the compressed column
@@ -149,12 +151,14 @@ float as_combined_estimate(float lambda, float last_max, float* last_rowsum, flo
         alpha = 0.0;
 
     float remainder = as_pessimistic_estimate(alpha, last_rowsum, rowsum, cache, col_entry_pos);
+    if (use_cont)
+        remainder *= fabs(col_max);
 
     float total_estimate = fabs(last_max * alpha) + remainder;
     return total_estimate;
 }
-bool as_wont_update(X_uncompressed Xu, float lambda, float last_max, float* last_rowsum, float* rowsum, S8bCol col, int_fast64_t* column_cache)
+bool as_wont_update(X_uncompressed Xu, float lambda, float last_max, float* last_rowsum, float* rowsum, S8bCol col, int_fast64_t* column_cache, float col_max, bool use_cont)
 {
-    float upper_bound = as_combined_estimate(lambda, last_max, last_rowsum, rowsum, col, column_cache);
+    float upper_bound = as_combined_estimate(lambda, last_max, last_rowsum, rowsum, col, column_cache, col_max, use_cont);
     return upper_bound <= lambda * total_sqrt_error;
 }

src/pruning.h

@@ -1,4 +1,4 @@
 bool wont_update_effect(X_uncompressed X, float lambda, int_fast64_t k, float last_max,
-    float* last_rowsum, float* rowsum, int_fast64_t* column_cache);
-bool as_wont_update(X_uncompressed Xu, float lambda, float last_max, float* last_rowsum, float* rowsum, S8bCol col, int_fast64_t* column_cache);
+    float* last_rowsum, float* rowsum, int_fast64_t* column_cache, struct continuous_info* ci);
+bool as_wont_update(X_uncompressed Xu, float lambda, float last_max, float* last_rowsum, float* rowsum, S8bCol col, int_fast64_t* column_cache, float col_max, bool use_cont);
 bool as_pessimistic_est(float lambda, float* rowsum, S8bCol col);

src/regression.cpp

@@ -243,7 +243,8 @@ void subproblem_only(Iter_Vars* vars, float lambda, float* rowsum,
 
 int_fast64_t run_lambda_iters_pruned(Iter_Vars* vars, float lambda, float* rowsum,
     float* old_rowsum, Active_Set* active_set,
-    int_fast64_t depth, const bool use_intercept, IndiCols* indi, const bool check_duplicates)
+    int_fast64_t depth, const bool use_intercept, IndiCols* indi, const bool check_duplicates,
+    struct continuous_info* cont_inf)
 {
     XMatrixSparse Xc = vars->Xc;
     X_uncompressed Xu = vars->Xu;
@@ -297,7 +298,7 @@ int_fast64_t run_lambda_iters_pruned(Iter_Vars* vars, float lambda, float* rowsu
         for (int_fast64_t j = 0; j < p; j++) {
             bool prev_wont_update = wont_update[j];
             wont_update[j] = wont_update_effect(Xu, lambda, j, last_max[j], last_rowsum[j], rowsum,
-                thread_caches[omp_get_thread_num()].col_j);
+                thread_caches[omp_get_thread_num()].col_j, cont_inf);
             if (!wont_update[j] && !(*vars->seen_before)[j]) {
             // if (!wont_update[j] && !prev_wont_update) {
             // if (true) {
@@ -352,7 +353,7 @@ int_fast64_t run_lambda_iters_pruned(Iter_Vars* vars, float lambda, float* rowsu
         clock_gettime(CLOCK_MONOTONIC_RAW, &start_time);
         auto working_set_results = update_working_set(vars->Xu, Xc, rowsum, wont_update, p, n, lambda,
             updateable_items, count_may_update, active_set,
-            thread_caches, last_max, depth, indi, &new_cols, max_interaction_distance, check_duplicates);
+            thread_caches, last_max, depth, indi, &new_cols, max_interaction_distance, check_duplicates, cont_inf);
         bool increased_set = working_set_results.first;
         auto vals_to_remove = working_set_results.second;
         for (auto val : vals_to_remove) {
@@ -494,7 +495,7 @@ 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)
+    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 = mnz_beta;
     if (verbose)
@@ -724,7 +725,7 @@ Lasso_Result simple_coordinate_descent_lasso(
         int_fast64_t last_iter_count = 0;
 
         nz_beta += run_lambda_iters_pruned(&iter_vars_pruned, lambda, rowsum,
-            old_rowsum, &active_set, depth, use_intercept, &indi, check_duplicates);
+            old_rowsum, &active_set, depth, use_intercept, &indi, check_duplicates, cont_inf);
 
         {
             int_fast64_t nonzero = beta_sets.beta1.size() + beta_sets.beta2.size() + beta_sets.beta3.size();

src/regression.h

@@ -30,7 +30,7 @@ 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);
+    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);
 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,

src/sparse_matrix.cpp

@@ -32,18 +32,23 @@ void free_row_set(struct row_set rs)
     }
     free(rs.row_lengths);
     free(rs.rows);
+    if (rs.row_real_vals != NULL)
+        delete[] rs.row_real_vals;
 }
 
 struct row_set row_list_without_columns(XMatrixSparse Xc, X_uncompressed Xu,
     bool* remove,
-    Thread_Cache* thread_caches)
+    Thread_Cache* thread_caches, struct continuous_info* ci)
 {
     int_fast64_t p = Xc.p;
     int_fast64_t n = Xc.n;
     struct row_set rs;
     rs.num_rows = n;
     int_fast64_t** new_rows = (int_fast64_t**)calloc(n, sizeof *new_rows);
     int_fast64_t* row_lengths = (int_fast64_t*)calloc(n, sizeof *row_lengths);
+    std::vector<float>* row_real_vals = NULL;
+    if (ci->use_cont)
+        row_real_vals = new std::vector<float>[n];
 
     // #pragma omp parallel for
     for (int_fast64_t row = 0; row < n; row++) {
@@ -64,9 +69,20 @@ struct row_set row_list_without_columns(XMatrixSparse Xc, X_uncompressed Xu,
             new_rows[row] = (int_fast64_t*)malloc(row_pos * sizeof *new_rows);
         memcpy(new_rows[row], row_cache, row_pos * sizeof *new_rows);
     }
+    if (ci->use_cont) {
+        for (int col = 0; col < p; col++) {
+            int_fast64_t* col_vals = &Xu.host_X[Xu.host_col_offsets[col]];
+            for (int ri = 0; ri < Xu.host_col_nz[col]; ri++) {
+                int_fast64_t row = col_vals[ri];
+                float col_real_val = ci->col_real_vals[col][ri];
+                row_real_vals[row].push_back(col_real_val);
+            }
+        }
+    }
 
     rs.rows = new_rows;
     rs.row_lengths = row_lengths;
+    rs.row_real_vals = row_real_vals;
     return rs;
 }
 
@@ -161,7 +177,8 @@ void free_indicols(IndiCols indi) {
 
 std::vector<int_fast64_t> update_main_indistinguishable_cols(
     X_uncompressed Xu, bool* wont_update, struct row_set relevant_row_set,
-    IndiCols* indi, robin_hood::unordered_flat_set<int_fast64_t>* new_cols)
+    IndiCols* indi, robin_hood::unordered_flat_set<int_fast64_t>* new_cols,
+    struct continuous_info* ci)
 {
     int_fast64_t total_cols_checked = 0;
     // robin_hood::unordered_flat_map<int64_t, std::vector<int64_t>>
@@ -171,7 +188,14 @@ std::vector<int_fast64_t> update_main_indistinguishable_cols(
         total_cols_checked++;
         int_fast64_t main_col_len = Xu.host_col_nz[main];
         int_fast64_t* column_entries = &Xu.host_X[Xu.host_col_offsets[main]];
-        XXH128_hash_t main_hash = XXH3_128bits(column_entries, main_col_len * sizeof(int_fast64_t));
+        XXH3_state_t* mh_state = XXH3_createState();
+        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]));
+        XXH128_hash_t main_hash = XXH3_128bits_digest(mh_state);
+        XXH3_freeState(mh_state);
+
 
         if (indi->main_col_hashes[main_hash.high64].contains(main_hash.low64))
             // indi->skip_main_col_ids.insert(main);

src/sparse_matrix.h

@@ -20,6 +20,7 @@ struct row_set {
     int_fast64_t** rows;
     int_fast64_t* row_lengths;
     int_fast64_t num_rows;
+    std::vector<float>* row_real_vals;
     // S8bCol* s8b_rows;
 };
 
@@ -57,11 +58,11 @@ XMatrixSparse sparse_X2_from_X(int_fast64_t** X, int_fast64_t n, int_fast64_t p,
     int_fast64_t max_interaction_distance, int_fast64_t shuffle);
 XMatrixSparse sparsify_X(int_fast64_t** X, int_fast64_t n, int_fast64_t p);
 
-struct row_set row_list_without_columns(XMatrixSparse Xc, X_uncompressed Xu, bool* remove, Thread_Cache* thread_caches);
+struct row_set row_list_without_columns(XMatrixSparse Xc, X_uncompressed Xu, bool* remove, Thread_Cache* thread_caches, struct continuous_info* ci);
 void free_row_set(struct row_set rs);
 X_uncompressed construct_host_X(XMatrixSparse* Xc);
 void free_host_X(X_uncompressed *Xu);
-std::vector<int_fast64_t> update_main_indistinguishable_cols(X_uncompressed Xu, bool* wont_update, struct row_set relevant_row_set, IndiCols* last_result, robin_hood::unordered_flat_set<int_fast64_t>* new_cols);
+std::vector<int_fast64_t> update_main_indistinguishable_cols(X_uncompressed Xu, bool* wont_update, struct row_set relevant_row_set, IndiCols* last_result, robin_hood::unordered_flat_set<int_fast64_t>* new_cols, struct continuous_info* ci);
 std::vector<int_fast64_t> get_col_by_id(X_uncompressed Xu, int_fast64_t id);
 IndiCols get_empty_indicols(int_fast64_t p);
 void free_indicols(IndiCols indi);