clusterkit 0.2.3 → 0.2.5

data/ext/clusterkit/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 crate-type = ["cdylib"]
 
 [dependencies]
-magnus = { version = "0.6", features = ["embed"] }
+magnus = { version = "0.8", features = ["embed"] }
 annembed = { git = "https://github.com/scientist-labs/annembed", tag = "clusterkit-0.1.1" }
 hnsw_rs = { git = "https://github.com/scientist-labs/hnswlib-rs", tag = "clusterkit-0.1.0" }
 hdbscan = "0.11"
@@ -23,3 +23,4 @@ default = ["openblas-static"]
 openblas-static = ["annembed/openblas-static"]
 openblas-system = ["annembed/openblas-system"]
 intel-mkl-static = ["annembed/intel-mkl-static"]
+macos-accelerate = ["annembed/macos-accelerate"]

data/ext/clusterkit/extconf.rb

@@ -1,4 +1,12 @@
 require "mkmf"
 require "rb_sys/mkmf"
 
-create_rust_makefile("clusterkit/clusterkit")
+create_rust_makefile("clusterkit/clusterkit") do |r|
+  if ENV["CLUSTERKIT_FEATURES"]
+    r.extra_cargo_args += ["--no-default-features"]
+    r.features = ENV["CLUSTERKIT_FEATURES"].split(",")
+  elsif RUBY_PLATFORM =~ /darwin/
+    r.extra_cargo_args += ["--no-default-features"]
+    r.features = ["macos-accelerate"]
+  end
+end

data/ext/clusterkit/src/clustering/hdbscan_wrapper.rs

@@ -1,4 +1,4 @@
-use magnus::{function, prelude::*, Error, Value, RArray, RHash, Integer};
+use magnus::{function, prelude::*, Error, Value, RHash, Ruby};
 use hdbscan::{Hdbscan, HdbscanHyperParams};
 use crate::utils::ruby_array_to_vec_vec_f64;
 
@@ -10,75 +10,62 @@ pub fn hdbscan_fit(
     min_cluster_size: usize,
     metric: String,
 ) -> Result<RHash, Error> {
+    let ruby = Ruby::get().unwrap();
+
     // Convert Ruby array to Vec<Vec<f64>> using shared helper
     let data_vec = ruby_array_to_vec_vec_f64(data)?;
     let n_samples = data_vec.len();
-    
-    // Note: hdbscan crate doesn't support custom metrics directly
-    // We'll use the default Euclidean distance for now
+
     if metric != "euclidean" && metric != "l2" {
         eprintln!("Warning: Current hdbscan version only supports Euclidean distance. Using Euclidean.");
     }
-    
+
     // Adjust parameters to avoid index out of bounds errors
-    // The hdbscan crate has issues when min_samples >= n_samples
     let adjusted_min_samples = min_samples.min(n_samples.saturating_sub(1)).max(1);
     let adjusted_min_cluster_size = min_cluster_size.min(n_samples).max(2);
-    
+
     // Create hyperparameters
     let hyper_params = HdbscanHyperParams::builder()
         .min_cluster_size(adjusted_min_cluster_size)
         .min_samples(adjusted_min_samples)
         .build();
-    
+
     // Create HDBSCAN instance and run clustering
     let clusterer = Hdbscan::new(&data_vec, hyper_params);
-    
-    // Run the clustering algorithm - cluster() returns Result<Vec<i32>, HdbscanError>
+
     let labels = clusterer.cluster().map_err(|e| {
         Error::new(
-            magnus::exception::runtime_error(),
+            ruby.exception_runtime_error(),
             format!("HDBSCAN clustering failed: {:?}", e)
         )
     })?;
-    
+
     // Convert results to Ruby types
-    let ruby = magnus::Ruby::get().unwrap();
-    let result = RHash::new();
-    
-    // Convert labels (i32 to Ruby Integer, -1 for noise)
-    let labels_array = RArray::new();
+    let result = ruby.hash_new();
+
+    let labels_array = ruby.ary_new();
     for &label in labels.iter() {
-        labels_array.push(Integer::from_value(
-            ruby.eval(&format!("{}", label)).unwrap()
-        ).unwrap())?;
+        labels_array.push(ruby.integer_from_i64(label as i64))?;
     }
     result.aset("labels", labels_array)?;
-    
-    // For now, we'll create dummy probabilities and outlier scores
-    // since the basic hdbscan crate doesn't provide these
-    // In the future, we could calculate these ourselves or use a more advanced implementation
-    
-    // Create probabilities array (all 1.0 for clustered points, 0.0 for noise)
-    let probs_array = RArray::new();
+
+    let probs_array = ruby.ary_new();
     for &label in labels.iter() {
         let prob = if label == -1 { 0.0 } else { 1.0 };
         probs_array.push(prob)?;
     }
     result.aset("probabilities", probs_array)?;
-    
-    // Create outlier scores array (0.0 for clustered points, 1.0 for noise)
-    let outlier_array = RArray::new();
+
+    let outlier_array = ruby.ary_new();
     for &label in labels.iter() {
         let score = if label == -1 { 1.0 } else { 0.0 };
         outlier_array.push(score)?;
     }
     result.aset("outlier_scores", outlier_array)?;
-    
-    // Create empty cluster persistence hash for now
-    let persistence_hash = RHash::new();
+
+    let persistence_hash = ruby.hash_new();
     result.aset("cluster_persistence", persistence_hash)?;
-    
+
     Ok(result)
 }
 
@@ -88,6 +75,6 @@ pub fn init(clustering_module: &magnus::RModule) -> Result<(), Error> {
         "hdbscan_rust",
         function!(hdbscan_fit, 4),
     )?;
-    
+
     Ok(())
-}
+}

data/ext/clusterkit/src/clustering.rs

@@ -1,50 +1,52 @@
-use magnus::{function, prelude::*, Error, Value, RArray, Integer};
+use magnus::{function, prelude::*, Error, Value, RArray, Ruby};
 use ndarray::{Array1, Array2, ArrayView1, Axis};
 use rand::prelude::*;
 use rand::rngs::StdRng;
 use rand::SeedableRng;
-use crate::utils::{ruby_array_to_ndarray2};
+use crate::utils::ruby_array_to_ndarray2;
 
 mod hdbscan_wrapper;
 
 pub fn init(parent: &magnus::RModule) -> Result<(), Error> {
     let clustering_module = parent.define_module("Clustering")?;
-    
+
     clustering_module.define_singleton_method(
         "kmeans_rust",
         function!(kmeans, 4),
     )?;
-    
+
     clustering_module.define_singleton_method(
         "kmeans_predict_rust",
         function!(kmeans_predict, 2),
     )?;
-    
+
     // Initialize HDBSCAN functions
     hdbscan_wrapper::init(&clustering_module)?;
-    
+
     Ok(())
 }
 
 /// Perform K-means clustering
 /// Returns (labels, centroids, inertia)
 fn kmeans(data: Value, k: usize, max_iter: usize, random_seed: Option<i64>) -> Result<(RArray, RArray, f64), Error> {
+    let ruby = Ruby::get().unwrap();
+
     // Convert Ruby array to ndarray using shared helper
     let data_array = ruby_array_to_ndarray2(data)?;
     let (n_samples, n_features) = data_array.dim();
-    
+
     if k > n_samples {
         return Err(Error::new(
-            magnus::exception::arg_error(),
+            ruby.exception_arg_error(),
             format!("k ({}) cannot be larger than number of samples ({})", k, n_samples),
         ));
     }
-    
+
     // Initialize centroids using K-means++
     let mut centroids = kmeans_plusplus(&data_array, k, random_seed)?;
     let mut labels = vec![0usize; n_samples];
     let mut prev_labels = vec![0usize; n_samples];
-    
+
     // K-means iterations
     for iteration in 0..max_iter {
         // Assign points to nearest centroid
@@ -53,7 +55,7 @@ fn kmeans(data: Value, k: usize, max_iter: usize, random_seed: Option<i64>) -> R
             let point = data_array.row(i);
             let mut min_dist = f64::INFINITY;
             let mut best_cluster = 0;
-            
+
             for (j, centroid) in centroids.axis_iter(Axis(0)).enumerate() {
                 let dist = euclidean_distance(&point, &centroid);
                 if dist < min_dist {
@@ -61,38 +63,38 @@ fn kmeans(data: Value, k: usize, max_iter: usize, random_seed: Option<i64>) -> R
                     best_cluster = j;
                 }
             }
-            
+
             if labels[i] != best_cluster {
                 changed = true;
             }
             labels[i] = best_cluster;
         }
-        
+
         // Check for convergence
         if !changed && iteration > 0 {
             break;
         }
-        
+
         // Update centroids
         for j in 0..k {
             let mut sum = Array1::<f64>::zeros(n_features);
             let mut count = 0;
-            
+
             for i in 0..n_samples {
                 if labels[i] == j {
                     sum += &data_array.row(i);
                     count += 1;
                 }
             }
-            
+
             if count > 0 {
                 centroids.row_mut(j).assign(&(sum / count as f64));
             }
         }
-        
+
         prev_labels.clone_from(&labels);
     }
-    
+
     // Calculate inertia (sum of squared distances to nearest centroid)
     let mut inertia = 0.0;
     for i in 0..n_samples {
@@ -100,44 +102,43 @@ fn kmeans(data: Value, k: usize, max_iter: usize, random_seed: Option<i64>) -> R
         let centroid = centroids.row(labels[i]);
         inertia += euclidean_distance(&point, &centroid).powi(2);
     }
-    
+
     // Convert results to Ruby arrays
-    let ruby = magnus::Ruby::get().unwrap();
-    let labels_array = RArray::new();
+    let labels_array = ruby.ary_new();
     for label in labels {
-        labels_array.push(Integer::from_value(ruby.eval(&format!("{}", label)).unwrap()).unwrap())?;
+        labels_array.push(ruby.integer_from_i64(label as i64))?;
     }
-    
-    let centroids_array = RArray::new();
+
+    let centroids_array = ruby.ary_new();
     for i in 0..k {
-        let row_array = RArray::new();
+        let row_array = ruby.ary_new();
         for j in 0..n_features {
             row_array.push(centroids[[i, j]])?;
         }
         centroids_array.push(row_array)?;
     }
-    
+
     Ok((labels_array, centroids_array, inertia))
 }
 
 /// Predict cluster labels for new data given centroids
 fn kmeans_predict(data: Value, centroids: Value) -> Result<RArray, Error> {
+    let ruby = Ruby::get().unwrap();
+
     // Convert inputs using shared helpers
     let data_matrix = ruby_array_to_ndarray2(data)?;
     let centroids_matrix = ruby_array_to_ndarray2(centroids)?;
-    
+
     let (n_samples, _) = data_matrix.dim();
-    let (_k, _) = centroids_matrix.dim();
-    
+
     // Predict labels
-    let ruby = magnus::Ruby::get().unwrap();
-    let labels_array = RArray::new();
-    
+    let labels_array = ruby.ary_new();
+
     for i in 0..n_samples {
         let point = data_matrix.row(i);
         let mut min_dist = f64::INFINITY;
         let mut best_cluster = 0;
-        
+
         for (j, centroid) in centroids_matrix.axis_iter(Axis(0)).enumerate() {
             let dist = euclidean_distance(&point, &centroid);
             if dist < min_dist {
@@ -145,10 +146,10 @@ fn kmeans_predict(data: Value, centroids: Value) -> Result<RArray, Error> {
                 best_cluster = j;
             }
         }
-        
-        labels_array.push(Integer::from_value(ruby.eval(&format!("{}", best_cluster)).unwrap()).unwrap())?;
+
+        labels_array.push(ruby.integer_from_i64(best_cluster as i64))?;
     }
-    
+
     Ok(labels_array)
 }
 
@@ -156,28 +157,26 @@ fn kmeans_predict(data: Value, centroids: Value) -> Result<RArray, Error> {
 fn kmeans_plusplus(data: &Array2<f64>, k: usize, random_seed: Option<i64>) -> Result<Array2<f64>, Error> {
     let n_samples = data.nrows();
     let n_features = data.ncols();
-    
+
     // Use seeded RNG if seed is provided, otherwise use thread_rng
     let mut rng: Box<dyn RngCore> = match random_seed {
         Some(seed) => {
-            // Convert i64 to u64 for seeding (negative numbers wrap around)
             let seed_u64 = seed as u64;
             Box::new(StdRng::seed_from_u64(seed_u64))
         },
         None => Box::new(thread_rng()),
     };
-    
+
     let mut centroids = Array2::<f64>::zeros((k, n_features));
-    
+
     // Choose first centroid randomly
     let first_idx = rng.gen_range(0..n_samples);
     centroids.row_mut(0).assign(&data.row(first_idx));
-    
+
     // Choose remaining centroids
     for i in 1..k {
         let mut distances = vec![f64::INFINITY; n_samples];
-        
-        // Calculate distance to nearest centroid for each point
+
         for j in 0..n_samples {
             for c in 0..i {
                 let dist = euclidean_distance(&data.row(j), &centroids.row(c));
@@ -186,25 +185,20 @@ fn kmeans_plusplus(data: &Array2<f64>, k: usize, random_seed: Option<i64>) -> Re
                 }
             }
         }
-        
-        // Convert distances to probabilities
+
         let total: f64 = distances.iter().map(|d| d * d).sum();
         if total == 0.0 {
-            // All points are identical or we've selected duplicates
-            // Just use sequential points as centroids
             if i < n_samples {
                 centroids.row_mut(i).assign(&data.row(i));
             } else {
-                // Reuse first point if we run out
                 centroids.row_mut(i).assign(&data.row(0));
             }
             continue;
         }
-        
-        // Choose next centroid with probability proportional to squared distance
+
         let mut cumsum = 0.0;
         let rand_val: f64 = rng.gen::<f64>() * total;
-        
+
         for j in 0..n_samples {
             cumsum += distances[j] * distances[j];
             if cumsum >= rand_val {
@@ -213,7 +207,7 @@ fn kmeans_plusplus(data: &Array2<f64>, k: usize, random_seed: Option<i64>) -> Re
             }
         }
     }
-    
+
     Ok(centroids)
 }
 
@@ -224,4 +218,4 @@ fn euclidean_distance(a: &ArrayView1<f64>, b: &ArrayView1<f64>) -> f64 {
         .map(|(x, y)| (x - y).powi(2))
         .sum::<f64>()
         .sqrt()
-}
+}