clusterkit 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fac82eb24c9b8c0c3b764c541f801db734d6b0006f17ecf784887877c5f231f
-  data.tar.gz: 1252ce2657c239ae9c8e14a3a19584ce4fd102fcb0e382e5aade903d0a27c15f
+  metadata.gz: 19c31f1a55e35724884b0005bd5e168c572c75b4cb3331a9634f7b00e5722f25
+  data.tar.gz: a7620b934689b61e4a88b555885f20eadc92f316cc8f09910fce59fc68ca7445
 SHA512:
-  metadata.gz: f02361f689e23c89aa41af49a22e52c23b65127ddde65a926b89952b4d8079929baed04bb4732533c00d07c55fbd11226ced066110bf2da4cfc3ae687ec2b29a
-  data.tar.gz: 18dd392ed9442cd43581fd20a9e814ae7c6509c94ab935865d58541b8d6862b3c615f91dc83a636ec56bdce23ad9d46595f080e2c3743043f5502d1601817a13
+  metadata.gz: a0104f2e34d261e5d8da181f783f2c30e1127b8895ff2a1be64e4e7ec824e9fce9da5e08aebb0dd2e08d0ddca4b9e9b7c0d14d40335b9ccf25ffd014ba048812
+  data.tar.gz: d8c236c53f3e351d210c9de923bb4a77b82b33fe4c1caad4889a2251cfc92addc6980c8c621e7aac6408603d05e1ef529285ccc20d043726d0e7c6473a2fc926

data/Cargo.lock

@@ -1323,7 +1323,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "07033963ba89ebaf1584d767badaa2e8fcec21aedea6b8c0346d487d49c28667"
 dependencies = [
  "cfg-if",
- "windows-targets 0.53.3",
+ "windows-targets 0.48.5",
 ]
 
 [[package]]
@@ -1382,9 +1382,9 @@ dependencies = [
 
 [[package]]
 name = "magnus"
-version = "0.6.4"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1597ef40aa8c36be098249e82c9a20cf7199278ac1c1a1a995eeead6a184479"
+checksum = "3b36a5b126bbe97eb0d02d07acfeb327036c6319fd816139a49824a83b7f9012"
 dependencies = [
  "magnus-macros",
  "rb-sys",
@@ -1394,9 +1394,9 @@ dependencies = [
 
 [[package]]
 name = "magnus-macros"
-version = "0.6.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5968c820e2960565f647819f5928a42d6e874551cab9d88d75e3e0660d7f71e3"
+checksum = "47607461fd8e1513cb4f2076c197d8092d921a1ea75bd08af97398f593751892"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1970,18 +1970,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.117"
+version = "0.9.124"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f900d1ce4629a2ebffaf5de74bd8f9c1188d4c5ed406df02f97e22f77a006f44"
+checksum = "c85c4188462601e2aa1469def389c17228566f82ea72f137ed096f21591bc489"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.117"
+version = "0.9.124"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef1e9c857028f631056bcd6d88cec390c751e343ce2223ddb26d23eb4a151d59"
+checksum = "568068db4102230882e6d4ae8de6632e224ca75fe5970f6e026a04e91ed635d3"
 dependencies = [
  "bindgen",
  "lazy_static",
@@ -1994,9 +1994,9 @@ dependencies = [
 
 [[package]]
 name = "rb-sys-env"
-version = "0.1.2"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a35802679f07360454b418a5d1735c89716bde01d35b1560fc953c1415a0b3bb"
+checksum = "cca7ad6a7e21e72151d56fe2495a259b5670e204c3adac41ee7ef676ea08117a"
 
 [[package]]
 name = "redox_syscall"

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"

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()
-}
+}