add seed param to search params (#168)

montanalow · morenol · commit 05dfffad5ce2 · 2022-11-08T11:29:56.000-05:00
diff --git a/src/cluster/kmeans.rs b/src/cluster/kmeans.rs
@@ -145,13 +145,17 @@ pub struct KMeansSearchParameters {
     pub k: Vec<usize>,
     /// Maximum number of iterations of the k-means algorithm for a single run.
     pub max_iter: Vec<usize>,
+    /// Determines random number generation for centroid initialization.
+    /// Use an int to make the randomness deterministic
+    pub seed: Vec<Option<u64>>,
 }
 
 /// KMeans grid search iterator
 pub struct KMeansSearchParametersIterator {
     kmeans_search_parameters: KMeansSearchParameters,
     current_k: usize,
     current_max_iter: usize,
+    current_seed: usize,
 }
 
 impl IntoIterator for KMeansSearchParameters {
@@ -163,6 +167,7 @@ impl IntoIterator for KMeansSearchParameters {
             kmeans_search_parameters: self,
             current_k: 0,
             current_max_iter: 0,
+            current_seed: 0,
         }
     }
 }
@@ -173,23 +178,30 @@ impl Iterator for KMeansSearchParametersIterator {
     fn next(&mut self) -> Option<Self::Item> {
         if self.current_k == self.kmeans_search_parameters.k.len()
             && self.current_max_iter == self.kmeans_search_parameters.max_iter.len()
+            && self.current_seed == self.kmeans_search_parameters.seed.len()
         {
             return None;
         }
 
         let next = KMeansParameters {
             k: self.kmeans_search_parameters.k[self.current_k],
             max_iter: self.kmeans_search_parameters.max_iter[self.current_max_iter],
+            seed: self.kmeans_search_parameters.seed[self.current_seed],
         };
 
         if self.current_k + 1 < self.kmeans_search_parameters.k.len() {
             self.current_k += 1;
         } else if self.current_max_iter + 1 < self.kmeans_search_parameters.max_iter.len() {
             self.current_k = 0;
             self.current_max_iter += 1;
+        } else if self.current_seed + 1 < self.kmeans_search_parameters.seed.len() {
+            self.current_k = 0;
+            self.current_max_iter = 0;
+            self.current_seed += 1;
         } else {
             self.current_k += 1;
             self.current_max_iter += 1;
+            self.current_seed += 1;
         }
 
         Some(next)
@@ -203,6 +215,7 @@ impl Default for KMeansSearchParameters {
         KMeansSearchParameters {
             k: vec![default_params.k],
             max_iter: vec![default_params.max_iter],
+            seed: vec![default_params.seed],
         }
     }
 }
diff --git a/src/svm/svc.rs b/src/svm/svc.rs
@@ -119,6 +119,8 @@ pub struct SVCSearchParameters<T: RealNumber, M: Matrix<T>, K: Kernel<T, M::RowV
     pub kernel: Vec<K>,
     /// Unused parameter.
     m: PhantomData<M>,
+    /// Controls the pseudo random number generation for shuffling the data for probability estimates
+    seed: Vec<Option<u64>>,
 }
 
 /// SVC grid search iterator
@@ -128,6 +130,7 @@ pub struct SVCSearchParametersIterator<T: RealNumber, M: Matrix<T>, K: Kernel<T,
     current_c: usize,
     current_tol: usize,
     current_kernel: usize,
+    current_seed: usize,
 }
 
 impl<T: RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> IntoIterator
@@ -143,6 +146,7 @@ impl<T: RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> IntoIterator
             current_c: 0,
             current_tol: 0,
             current_kernel: 0,
+            current_seed: 0,
         }
     }
 }
@@ -157,6 +161,7 @@ impl<T: RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> Iterator
             && self.current_c == self.svc_search_parameters.c.len()
             && self.current_tol == self.svc_search_parameters.tol.len()
             && self.current_kernel == self.svc_search_parameters.kernel.len()
+            && self.current_seed == self.svc_search_parameters.kernel.len()
         {
             return None;
         }
@@ -167,6 +172,7 @@ impl<T: RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> Iterator
             tol: self.svc_search_parameters.tol[self.current_tol],
             kernel: self.svc_search_parameters.kernel[self.current_kernel].clone(),
             m: PhantomData,
+            seed: self.svc_search_parameters.seed[self.current_seed],
         };
 
         if self.current_epoch + 1 < self.svc_search_parameters.epoch.len() {
@@ -183,11 +189,18 @@ impl<T: RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> Iterator
             self.current_c = 0;
             self.current_tol = 0;
             self.current_kernel += 1;
+        } else if self.current_kernel + 1 < self.svc_search_parameters.kernel.len() {
+            self.current_epoch = 0;
+            self.current_c = 0;
+            self.current_tol = 0;
+            self.current_kernel = 0;
+            self.current_seed += 1;
         } else {
             self.current_epoch += 1;
             self.current_c += 1;
             self.current_tol += 1;
             self.current_kernel += 1;
+            self.current_seed += 1;
         }
 
         Some(next)
@@ -204,6 +217,7 @@ impl<T: RealNumber, M: Matrix<T>> Default for SVCSearchParameters<T, M, LinearKe
             tol: vec![default_params.tol],
             kernel: vec![default_params.kernel],
             m: PhantomData,
+            seed: vec![default_params.seed],
         }
     }
 }
diff --git a/src/tree/decision_tree_classifier.rs b/src/tree/decision_tree_classifier.rs
@@ -209,14 +209,21 @@ impl Default for DecisionTreeClassifierParameters {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Debug, Clone)]
 pub struct DecisionTreeClassifierSearchParameters {
+    #[cfg_attr(feature = "serde", serde(default))]
     /// Split criteria to use when building a tree. See [Decision Tree Classifier](../../tree/decision_tree_classifier/index.html)
     pub criterion: Vec<SplitCriterion>,
+    #[cfg_attr(feature = "serde", serde(default))]
     /// Tree max depth. See [Decision Tree Classifier](../../tree/decision_tree_classifier/index.html)
     pub max_depth: Vec<Option<u16>>,
+    #[cfg_attr(feature = "serde", serde(default))]
     /// The minimum number of samples required to be at a leaf node. See [Decision Tree Classifier](../../tree/decision_tree_classifier/index.html)
     pub min_samples_leaf: Vec<usize>,
+    #[cfg_attr(feature = "serde", serde(default))]
     /// The minimum number of samples required to split an internal node. See [Decision Tree Classifier](../../tree/decision_tree_classifier/index.html)
     pub min_samples_split: Vec<usize>,
+    #[cfg_attr(feature = "serde", serde(default))]
+    /// Controls the randomness of the estimator
+    pub seed: Vec<Option<u64>>,
 }
 
 /// DecisionTreeClassifier grid search iterator
@@ -226,6 +233,7 @@ pub struct DecisionTreeClassifierSearchParametersIterator {
     current_max_depth: usize,
     current_min_samples_leaf: usize,
     current_min_samples_split: usize,
+    current_seed: usize,
 }
 
 impl IntoIterator for DecisionTreeClassifierSearchParameters {
@@ -239,6 +247,7 @@ impl IntoIterator for DecisionTreeClassifierSearchParameters {
             current_max_depth: 0,
             current_min_samples_leaf: 0,
             current_min_samples_split: 0,
+            current_seed: 0,
         }
     }
 }
@@ -267,6 +276,7 @@ impl Iterator for DecisionTreeClassifierSearchParametersIterator {
                     .decision_tree_classifier_search_parameters
                     .min_samples_split
                     .len()
+            && self.current_seed == self.decision_tree_classifier_search_parameters.seed.len()
         {
             return None;
         }
@@ -283,6 +293,7 @@ impl Iterator for DecisionTreeClassifierSearchParametersIterator {
             min_samples_split: self
                 .decision_tree_classifier_search_parameters
                 .min_samples_split[self.current_min_samples_split],
+            seed: self.decision_tree_classifier_search_parameters.seed[self.current_seed],
         };
 
         if self.current_criterion + 1
@@ -319,11 +330,19 @@ impl Iterator for DecisionTreeClassifierSearchParametersIterator {
             self.current_max_depth = 0;
             self.current_min_samples_leaf = 0;
             self.current_min_samples_split += 1;
+        } else if self.current_seed + 1 < self.decision_tree_classifier_search_parameters.seed.len()
+        {
+            self.current_criterion = 0;
+            self.current_max_depth = 0;
+            self.current_min_samples_leaf = 0;
+            self.current_min_samples_split = 0;
+            self.current_seed += 1;
         } else {
             self.current_criterion += 1;
             self.current_max_depth += 1;
             self.current_min_samples_leaf += 1;
             self.current_min_samples_split += 1;
+            self.current_seed += 1;
         }
 
         Some(next)
@@ -339,6 +358,7 @@ impl Default for DecisionTreeClassifierSearchParameters {
             max_depth: vec![default_params.max_depth],
             min_samples_leaf: vec![default_params.min_samples_leaf],
             min_samples_split: vec![default_params.min_samples_split],
+            seed: vec![default_params.seed],
         }
     }
 }
diff --git a/src/tree/decision_tree_regressor.rs b/src/tree/decision_tree_regressor.rs
@@ -148,6 +148,8 @@ pub struct DecisionTreeRegressorSearchParameters {
     pub min_samples_leaf: Vec<usize>,
     /// The minimum number of samples required to split an internal node. See [Decision Tree Regressor](../../tree/decision_tree_regressor/index.html)
     pub min_samples_split: Vec<usize>,
+    /// Controls the randomness of the estimator
+    pub seed: Vec<Option<u64>>,
 }
 
 /// DecisionTreeRegressor grid search iterator
@@ -156,6 +158,7 @@ pub struct DecisionTreeRegressorSearchParametersIterator {
     current_max_depth: usize,
     current_min_samples_leaf: usize,
     current_min_samples_split: usize,
+    current_seed: usize,
 }
 
 impl IntoIterator for DecisionTreeRegressorSearchParameters {
@@ -168,6 +171,7 @@ impl IntoIterator for DecisionTreeRegressorSearchParameters {
             current_max_depth: 0,
             current_min_samples_leaf: 0,
             current_min_samples_split: 0,
+            current_seed: 0,
         }
     }
 }
@@ -191,6 +195,7 @@ impl Iterator for DecisionTreeRegressorSearchParametersIterator {
                     .decision_tree_regressor_search_parameters
                     .min_samples_split
                     .len()
+            && self.current_seed == self.decision_tree_regressor_search_parameters.seed.len()
         {
             return None;
         }
@@ -204,6 +209,7 @@ impl Iterator for DecisionTreeRegressorSearchParametersIterator {
             min_samples_split: self
                 .decision_tree_regressor_search_parameters
                 .min_samples_split[self.current_min_samples_split],
+            seed: self.decision_tree_regressor_search_parameters.seed[self.current_seed],
         };
 
         if self.current_max_depth + 1
@@ -230,10 +236,17 @@ impl Iterator for DecisionTreeRegressorSearchParametersIterator {
             self.current_max_depth = 0;
             self.current_min_samples_leaf = 0;
             self.current_min_samples_split += 1;
+        } else if self.current_seed + 1 < self.decision_tree_regressor_search_parameters.seed.len()
+        {
+            self.current_max_depth = 0;
+            self.current_min_samples_leaf = 0;
+            self.current_min_samples_split = 0;
+            self.current_seed += 1;
         } else {
             self.current_max_depth += 1;
             self.current_min_samples_leaf += 1;
             self.current_min_samples_split += 1;
+            self.current_seed += 1;
         }
 
         Some(next)
@@ -248,6 +261,7 @@ impl Default for DecisionTreeRegressorSearchParameters {
             max_depth: vec![default_params.max_depth],
             min_samples_leaf: vec![default_params.min_samples_leaf],
             min_samples_split: vec![default_params.min_samples_split],
+            seed: vec![default_params.seed],
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -145,13 +145,17 @@ pub struct KMeansSearchParameters {`
`145`	`145`	`pub k: Vec<usize>,`
`146`	`146`	`/// Maximum number of iterations of the k-means algorithm for a single run.`
`147`	`147`	`pub max_iter: Vec<usize>,`
	`148`	`+ /// Determines random number generation for centroid initialization.`
	`149`	`+ /// Use an int to make the randomness deterministic`
	`150`	`+ pub seed: Vec<Option<u64>>,`
`148`	`151`	`}`
`149`	`152`
`150`	`153`	`/// KMeans grid search iterator`
`151`	`154`	`pub struct KMeansSearchParametersIterator {`
`152`	`155`	`kmeans_search_parameters: KMeansSearchParameters,`
`153`	`156`	`current_k: usize,`
`154`	`157`	`current_max_iter: usize,`
	`158`	`+ current_seed: usize,`
`155`	`159`	`}`
`156`	`160`
`157`	`161`	`impl IntoIterator for KMeansSearchParameters {`
`@@ -163,6 +167,7 @@ impl IntoIterator for KMeansSearchParameters {`
`163`	`167`	`kmeans_search_parameters: self,`
`164`	`168`	`current_k: 0,`
`165`	`169`	`current_max_iter: 0,`
	`170`	`+ current_seed: 0,`
`166`	`171`	`}`
`167`	`172`	`}`
`168`	`173`	`}`
`@@ -173,23 +178,30 @@ impl Iterator for KMeansSearchParametersIterator {`
`173`	`178`	`fn next(&mut self) -> Option<Self::Item> {`
`174`	`179`	`if self.current_k == self.kmeans_search_parameters.k.len()`
`175`	`180`	`&& self.current_max_iter == self.kmeans_search_parameters.max_iter.len()`
	`181`	`+ && self.current_seed == self.kmeans_search_parameters.seed.len()`
`176`	`182`	`{`
`177`	`183`	`return None;`
`178`	`184`	`}`
`179`	`185`
`180`	`186`	`let next = KMeansParameters {`
`181`	`187`	`k: self.kmeans_search_parameters.k[self.current_k],`
`182`	`188`	`max_iter: self.kmeans_search_parameters.max_iter[self.current_max_iter],`
	`189`	`+ seed: self.kmeans_search_parameters.seed[self.current_seed],`
`183`	`190`	`};`
`184`	`191`
`185`	`192`	`if self.current_k + 1 < self.kmeans_search_parameters.k.len() {`
`186`	`193`	`self.current_k += 1;`
`187`	`194`	`} else if self.current_max_iter + 1 < self.kmeans_search_parameters.max_iter.len() {`
`188`	`195`	`self.current_k = 0;`
`189`	`196`	`self.current_max_iter += 1;`
	`197`	`+ } else if self.current_seed + 1 < self.kmeans_search_parameters.seed.len() {`
	`198`	`+ self.current_k = 0;`
	`199`	`+ self.current_max_iter = 0;`
	`200`	`+ self.current_seed += 1;`
`190`	`201`	`} else {`
`191`	`202`	`self.current_k += 1;`
`192`	`203`	`self.current_max_iter += 1;`
	`204`	`+ self.current_seed += 1;`
`193`	`205`	`}`
`194`	`206`
`195`	`207`	`Some(next)`
`@@ -203,6 +215,7 @@ impl Default for KMeansSearchParameters {`
`203`	`215`	`KMeansSearchParameters {`
`204`	`216`	`k: vec![default_params.k],`
`205`	`217`	`max_iter: vec![default_params.max_iter],`
	`218`	`+ seed: vec![default_params.seed],`
`206`	`219`	`}`
`207`	`220`	`}`
`208`	`221`	`}`
Original file line number	Diff line number	Diff line change
`@@ -119,6 +119,8 @@ pub struct SVCSearchParameters<T: RealNumber, M: Matrix<T>, K: Kernel<T, M::RowV`
`119`	`119`	`pub kernel: Vec<K>,`
`120`	`120`	`/// Unused parameter.`
`121`	`121`	`m: PhantomData<M>,`
	`122`	`+ /// Controls the pseudo random number generation for shuffling the data for probability estimates`
	`123`	`+ seed: Vec<Option<u64>>,`
`122`	`124`	`}`
`123`	`125`
`124`	`126`	`/// SVC grid search iterator`
`@@ -128,6 +130,7 @@ pub struct SVCSearchParametersIterator<T: RealNumber, M: Matrix<T>, K: Kernel<T,`
`128`	`130`	`current_c: usize,`
`129`	`131`	`current_tol: usize,`
`130`	`132`	`current_kernel: usize,`
	`133`	`+ current_seed: usize,`
`131`	`134`	`}`
`132`	`135`
`133`	`136`	`impl<T: RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> IntoIterator`
`@@ -143,6 +146,7 @@ impl<T: RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> IntoIterator`
`143`	`146`	`current_c: 0,`
`144`	`147`	`current_tol: 0,`
`145`	`148`	`current_kernel: 0,`
	`149`	`+ current_seed: 0,`
`146`	`150`	`}`
`147`	`151`	`}`
`148`	`152`	`}`
`@@ -157,6 +161,7 @@ impl<T: RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> Iterator`
`157`	`161`	`&& self.current_c == self.svc_search_parameters.c.len()`
`158`	`162`	`&& self.current_tol == self.svc_search_parameters.tol.len()`
`159`	`163`	`&& self.current_kernel == self.svc_search_parameters.kernel.len()`
	`164`	`+ && self.current_seed == self.svc_search_parameters.kernel.len()`
`160`	`165`	`{`
`161`	`166`	`return None;`
`162`	`167`	`}`
`@@ -167,6 +172,7 @@ impl<T: RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> Iterator`
`167`	`172`	`tol: self.svc_search_parameters.tol[self.current_tol],`
`168`	`173`	`kernel: self.svc_search_parameters.kernel[self.current_kernel].clone(),`
`169`	`174`	`m: PhantomData,`
	`175`	`+ seed: self.svc_search_parameters.seed[self.current_seed],`
`170`	`176`	`};`
`171`	`177`
`172`	`178`	`if self.current_epoch + 1 < self.svc_search_parameters.epoch.len() {`
`@@ -183,11 +189,18 @@ impl<T: RealNumber, M: Matrix<T>, K: Kernel<T, M::RowVector>> Iterator`
`183`	`189`	`self.current_c = 0;`
`184`	`190`	`self.current_tol = 0;`
`185`	`191`	`self.current_kernel += 1;`
	`192`	`+ } else if self.current_kernel + 1 < self.svc_search_parameters.kernel.len() {`
	`193`	`+ self.current_epoch = 0;`
	`194`	`+ self.current_c = 0;`
	`195`	`+ self.current_tol = 0;`
	`196`	`+ self.current_kernel = 0;`
	`197`	`+ self.current_seed += 1;`
`186`	`198`	`} else {`
`187`	`199`	`self.current_epoch += 1;`
`188`	`200`	`self.current_c += 1;`
`189`	`201`	`self.current_tol += 1;`
`190`	`202`	`self.current_kernel += 1;`
	`203`	`+ self.current_seed += 1;`
`191`	`204`	`}`
`192`	`205`
`193`	`206`	`Some(next)`
`@@ -204,6 +217,7 @@ impl<T: RealNumber, M: Matrix<T>> Default for SVCSearchParameters<T, M, LinearKe`
`204`	`217`	`tol: vec![default_params.tol],`
`205`	`218`	`kernel: vec![default_params.kernel],`
`206`	`219`	`m: PhantomData,`
	`220`	`+ seed: vec![default_params.seed],`
`207`	`221`	`}`
`208`	`222`	`}`
`209`	`223`	`}`
Original file line number	Diff line number	Diff line change
`@@ -148,6 +148,8 @@ pub struct DecisionTreeRegressorSearchParameters {`
`148`	`148`	`pub min_samples_leaf: Vec<usize>,`
`149`	`149`	`/// The minimum number of samples required to split an internal node. See [Decision Tree Regressor](../../tree/decision_tree_regressor/index.html)`
`150`	`150`	`pub min_samples_split: Vec<usize>,`
	`151`	`+ /// Controls the randomness of the estimator`
	`152`	`+ pub seed: Vec<Option<u64>>,`
`151`	`153`	`}`
`152`	`154`
`153`	`155`	`/// DecisionTreeRegressor grid search iterator`
`@@ -156,6 +158,7 @@ pub struct DecisionTreeRegressorSearchParametersIterator {`
`156`	`158`	`current_max_depth: usize,`
`157`	`159`	`current_min_samples_leaf: usize,`
`158`	`160`	`current_min_samples_split: usize,`
	`161`	`+ current_seed: usize,`
`159`	`162`	`}`
`160`	`163`
`161`	`164`	`impl IntoIterator for DecisionTreeRegressorSearchParameters {`
`@@ -168,6 +171,7 @@ impl IntoIterator for DecisionTreeRegressorSearchParameters {`
`168`	`171`	`current_max_depth: 0,`
`169`	`172`	`current_min_samples_leaf: 0,`
`170`	`173`	`current_min_samples_split: 0,`
	`174`	`+ current_seed: 0,`
`171`	`175`	`}`
`172`	`176`	`}`
`173`	`177`	`}`
`@@ -191,6 +195,7 @@ impl Iterator for DecisionTreeRegressorSearchParametersIterator {`
`191`	`195`	`.decision_tree_regressor_search_parameters`
`192`	`196`	`.min_samples_split`
`193`	`197`	`.len()`
	`198`	`+ && self.current_seed == self.decision_tree_regressor_search_parameters.seed.len()`
`194`	`199`	`{`
`195`	`200`	`return None;`
`196`	`201`	`}`
`@@ -204,6 +209,7 @@ impl Iterator for DecisionTreeRegressorSearchParametersIterator {`
`204`	`209`	`min_samples_split: self`
`205`	`210`	`.decision_tree_regressor_search_parameters`
`206`	`211`	`.min_samples_split[self.current_min_samples_split],`
	`212`	`+ seed: self.decision_tree_regressor_search_parameters.seed[self.current_seed],`
`207`	`213`	`};`
`208`	`214`
`209`	`215`	`if self.current_max_depth + 1`
`@@ -230,10 +236,17 @@ impl Iterator for DecisionTreeRegressorSearchParametersIterator {`
`230`	`236`	`self.current_max_depth = 0;`
`231`	`237`	`self.current_min_samples_leaf = 0;`
`232`	`238`	`self.current_min_samples_split += 1;`
	`239`	`+ } else if self.current_seed + 1 < self.decision_tree_regressor_search_parameters.seed.len()`
	`240`	`+ {`
	`241`	`+ self.current_max_depth = 0;`
	`242`	`+ self.current_min_samples_leaf = 0;`
	`243`	`+ self.current_min_samples_split = 0;`
	`244`	`+ self.current_seed += 1;`
`233`	`245`	`} else {`
`234`	`246`	`self.current_max_depth += 1;`
`235`	`247`	`self.current_min_samples_leaf += 1;`
`236`	`248`	`self.current_min_samples_split += 1;`
	`249`	`+ self.current_seed += 1;`
`237`	`250`	`}`
`238`	`251`
`239`	`252`	`Some(next)`
`@@ -248,6 +261,7 @@ impl Default for DecisionTreeRegressorSearchParameters {`
`248`	`261`	`max_depth: vec![default_params.max_depth],`
`249`	`262`	`min_samples_leaf: vec![default_params.min_samples_leaf],`
`250`	`263`	`min_samples_split: vec![default_params.min_samples_split],`
	`264`	`+ seed: vec![default_params.seed],`
`251`	`265`	`}`
`252`	`266`	`}`
`253`	`267`	`}`