optirs-core 0.3.1

OptiRS core optimization algorithms and utilities
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

//! # PrivateRandomSearch - Trait Implementations
//!
//! This module contains trait implementations for `PrivateRandomSearch`.
//!
//! ## Implemented Traits
//!
//! - `NoisyOptimizer`
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use crate::error::{OptimError, Result};
use crate::privacy::{DifferentialPrivacyConfig, PrivacyBudget};
use scirs2_core::numeric::Float;
use std::collections::HashMap;
use std::fmt::Debug;

use super::functions::NoisyOptimizer;
use super::types::{
    HPOEvaluation, HPOResult, ParameterConfiguration, ParameterSpace, ParameterType,
    ParameterValue, PrivateRandomSearch,
};

impl<T: Float + Debug + Send + Sync + 'static> NoisyOptimizer<T> for PrivateRandomSearch<T> {
    fn suggest_next(
        &mut self,
        parameterspace: &ParameterSpace<T>,
        _evaluation_history: &[HPOEvaluation<T>],
        _privacy_budget: &PrivacyBudget,
    ) -> Result<ParameterConfiguration<T>> {
        let mut values = HashMap::new();
        for (param_name, param_def) in &parameterspace.parameters {
            let value = match &param_def.param_type {
                ParameterType::Continuous => {
                    let min = param_def.bounds.min.unwrap_or(T::zero());
                    let max = param_def.bounds.max.unwrap_or(T::one());
                    let random_val = T::from(self.rng.gen_range(0.0..1.0)).expect("unwrap failed");
                    ParameterValue::Continuous(min + random_val * (max - min))
                }
                ParameterType::Integer => {
                    let min = param_def
                        .bounds
                        .min
                        .unwrap_or(T::zero())
                        .to_i64()
                        .unwrap_or(0);
                    let max = param_def
                        .bounds
                        .max
                        .unwrap_or(T::from(100).unwrap_or_else(|| T::zero()))
                        .to_i64()
                        .unwrap_or(100);
                    ParameterValue::Integer(self.rng.gen_range(min..max + 1))
                }
                ParameterType::Boolean => ParameterValue::Boolean(self.rng.gen_range(0..2) == 1),
                ParameterType::Categorical(categories) => {
                    let idx = self.rng.gen_range(0..categories.len());
                    ParameterValue::Categorical(categories[idx].clone())
                }
                ParameterType::Ordinal(values) => {
                    let idx = self.rng.gen_range(0..values.len());
                    ParameterValue::Ordinal(idx)
                }
            };
            values.insert(param_name.clone(), value);
        }
        Ok(ParameterConfiguration {
            values,
            id: format!("config_{}", self.history.len()),
            metadata: HashMap::new(),
        })
    }
    fn update(
        &mut self,
        config: &ParameterConfiguration<T>,
        _result: &HPOResult<T>,
        _privacy_budget: &PrivacyBudget,
    ) -> Result<()> {
        Ok(())
    }
    fn name(&self) -> &str {
        "PrivateRandomSearch"
    }
}