optirs-learned 0.3.1

OptiRS learned optimizers and meta-learning
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

// Architecture generation utilities

use scirs2_core::random::Rng;
use crate::error::Result;
use super::architecture_space::ArchitectureSearchSpace;

/// Architecture generator
pub struct ArchitectureGenerator {
    generation_strategy: GenerationStrategy,
    search_space: Option<ArchitectureSearchSpace>,
}

impl ArchitectureGenerator {
    pub fn new(search_space: &ArchitectureSearchSpace) -> Result<Self> {
        Ok(Self {
            generation_strategy: GenerationStrategy::Random,
            search_space: Some(search_space.clone()),
        })
    }

    pub fn generate_random_population(&self, size: usize) -> Result<Vec<String>> {
        let mut architectures = Vec::new();
        let mut rng = scirs2_core::random::thread_rng();

        for _ in 0..size {
            if let Some(ref space) = self.search_space {
                architectures.push(space.sample_random_architecture(&mut rng)?);
            }
        }

        Ok(architectures)
    }
}

/// Generation strategy
#[derive(Debug, Clone, Copy)]
pub enum GenerationStrategy {
    Random,
    Guided,
    Template,
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::learned_optimizers::neural_architecture_search::config::SearchConstraints;

    #[test]
    fn test_architecture_generator() {
        let constraints = SearchConstraints::default();
        let space = ArchitectureSearchSpace::new(&constraints).expect("unwrap failed");
        let generator = ArchitectureGenerator::new(&space);
        assert!(generator.is_ok());
    }
}