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
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

// Resource management for neural architecture search

use std::time::{Duration, Instant};
use crate::error::Result;

/// Resource manager for NAS
pub struct ResourceManager {
    budget: ComputeBudget,
    usage: ResourceUsage,
    constraints: ResourceConstraints,
    start_time: Instant,
}

impl ResourceManager {
    pub fn new(evaluation_budget: usize) -> Result<Self> {
        let budget = ComputeBudget {
            max_evaluations: evaluation_budget,
            max_time_hours: 24.0,
            max_memory_gb: 32.0,
            max_gpu_hours: 12.0,
        };

        let constraints = ResourceConstraints::default();
        let usage = ResourceUsage::new();

        Ok(Self {
            budget,
            usage,
            constraints,
            start_time: Instant::now(),
        })
    }

    pub fn has_budget_remaining(&self) -> bool {
        self.usage.evaluations_used < self.budget.max_evaluations &&
        self.get_elapsed_hours() < self.budget.max_time_hours &&
        self.usage.memory_used_gb < self.budget.max_memory_gb
    }

    pub fn consume_evaluation_budget(&mut self, count: usize) -> Result<()> {
        if self.usage.evaluations_used + count > self.budget.max_evaluations {
            return Err(crate::error::OptimError::Other("Evaluation budget exceeded".to_string()));
        }

        self.usage.evaluations_used += count;
        Ok(())
    }

    fn get_elapsed_hours(&self) -> f64 {
        self.start_time.elapsed().as_secs_f64() / 3600.0
    }

    pub fn get_usage_stats(&self) -> super::ResourceUsageStats {
        super::ResourceUsageStats {
            evaluations_used: self.usage.evaluations_used,
            evaluations_remaining: self.budget.max_evaluations.saturating_sub(self.usage.evaluations_used),
            total_compute_time: self.start_time.elapsed(),
        }
    }
}

/// Compute budget for NAS
#[derive(Debug, Clone)]
pub struct ComputeBudget {
    pub max_evaluations: usize,
    pub max_time_hours: f64,
    pub max_memory_gb: f64,
    pub max_gpu_hours: f64,
}

/// Resource usage tracking
#[derive(Debug, Clone)]
pub struct ResourceUsage {
    pub evaluations_used: usize,
    pub time_used_hours: f64,
    pub memory_used_gb: f64,
    pub gpu_hours_used: f64,
}

impl ResourceUsage {
    pub fn new() -> Self {
        Self {
            evaluations_used: 0,
            time_used_hours: 0.0,
            memory_used_gb: 0.0,
            gpu_hours_used: 0.0,
        }
    }
}

/// Resource constraints
#[derive(Debug, Clone)]
pub struct ResourceConstraints {
    pub max_concurrent_evaluations: usize,
    pub memory_per_evaluation_gb: f64,
    pub time_per_evaluation_minutes: f64,
}

impl Default for ResourceConstraints {
    fn default() -> Self {
        Self {
            max_concurrent_evaluations: 4,
            memory_per_evaluation_gb: 2.0,
            time_per_evaluation_minutes: 30.0,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_resource_manager() {
        let manager = ResourceManager::new(100);
        assert!(manager.is_ok());

        let rm = manager.expect("unwrap failed");
        assert!(rm.has_budget_remaining());
        assert_eq!(rm.usage.evaluations_used, 0);
    }

    #[test]
    fn test_budget_consumption() {
        let mut manager = ResourceManager::new(10).expect("unwrap failed");

        let result = manager.consume_evaluation_budget(5);
        assert!(result.is_ok());
        assert_eq!(manager.usage.evaluations_used, 5);

        let result = manager.consume_evaluation_budget(10);
        assert!(result.is_err()); // Should exceed budget
    }
}