#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum MaxFeatures {
All,
Sqrt,
Count(usize),
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Splitter {
#[default]
Best,
Random,
}
use crate::artifact::ArtifactError;
const SPLITTER_BEST: u32 = 1;
const SPLITTER_RANDOM: u32 = 2;
pub(crate) const fn encode_splitter(value: Splitter) -> u32 {
match value {
Splitter::Best => SPLITTER_BEST,
Splitter::Random => SPLITTER_RANDOM,
}
}
pub(crate) const fn decode_splitter(tag: u32) -> Option<Splitter> {
match tag {
SPLITTER_BEST => Some(Splitter::Best),
SPLITTER_RANDOM => Some(Splitter::Random),
_ => None,
}
}
const MAX_FEATURES_ALL: u32 = 1;
const MAX_FEATURES_SQRT: u32 = 2;
const MAX_FEATURES_COUNT: u32 = 3;
pub(crate) fn encode_max_features(value: MaxFeatures) -> Result<(u32, u32), ArtifactError> {
Ok(match value {
MaxFeatures::All => (MAX_FEATURES_ALL, 0),
MaxFeatures::Sqrt => (MAX_FEATURES_SQRT, 0),
MaxFeatures::Count(count) => (
MAX_FEATURES_COUNT,
u32::try_from(count).map_err(|_| ArtifactError::InvalidPayload)?,
),
})
}
pub(crate) fn decode_max_features(tag: u32, count: u32, n_features: usize) -> Option<MaxFeatures> {
match tag {
MAX_FEATURES_ALL if count == 0 => Some(MaxFeatures::All),
MAX_FEATURES_SQRT if count == 0 => Some(MaxFeatures::Sqrt),
MAX_FEATURES_COUNT if count != 0 && count as usize <= n_features => {
Some(MaxFeatures::Count(count as usize))
}
_ => None,
}
}
macro_rules! tree_params {
($name:ident, $estimator:literal) => {
#[doc = concat!("Parameters for [`", $estimator, "`](super::", $estimator, ").")]
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct $name {
max_depth: Option<usize>,
min_samples_split: usize,
min_samples_leaf: usize,
max_features: MaxFeatures,
splitter: Splitter,
random_state: u64,
}
impl Default for $name {
fn default() -> Self {
Self {
max_depth: None,
min_samples_split: 2,
min_samples_leaf: 1,
max_features: MaxFeatures::All,
splitter: Splitter::Best,
random_state: 0,
}
}
}
impl $name {
#[must_use]
pub fn with_max_depth(mut self, max_depth: Option<usize>) -> Self {
self.max_depth = max_depth;
self
}
#[must_use]
pub fn with_min_samples_split(mut self, min_samples_split: usize) -> Self {
self.min_samples_split = min_samples_split;
self
}
#[must_use]
pub fn with_min_samples_leaf(mut self, min_samples_leaf: usize) -> Self {
self.min_samples_leaf = min_samples_leaf;
self
}
#[must_use]
pub fn with_max_features(mut self, max_features: MaxFeatures) -> Self {
self.max_features = max_features;
self
}
#[must_use]
pub fn with_splitter(mut self, splitter: Splitter) -> Self {
self.splitter = splitter;
self
}
#[must_use]
pub fn with_random_state(mut self, random_state: u64) -> Self {
self.random_state = random_state;
self
}
pub const fn max_depth(&self) -> Option<usize> {
self.max_depth
}
pub const fn min_samples_split(&self) -> usize {
self.min_samples_split
}
pub const fn min_samples_leaf(&self) -> usize {
self.min_samples_leaf
}
pub const fn max_features(&self) -> MaxFeatures {
self.max_features
}
pub const fn splitter(&self) -> Splitter {
self.splitter
}
pub const fn random_state(&self) -> u64 {
self.random_state
}
}
};
}
tree_params!(DecisionTreeClassifierParams, "DecisionTreeClassifier");
tree_params!(DecisionTreeRegressorParams, "DecisionTreeRegressor");