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

// Multi-objective optimization for neural architecture search

use scirs2_core::numeric::Float;
use std::fmt::Debug;
use std::collections::HashMap;
use crate::error::Result;
use super::population::Individual;

/// Multi-objective optimizer
pub struct MultiObjectiveOptimizer<T: Float + Debug + Send + Sync + 'static> {
    objective_weights: Vec<f64>,
    pareto_front: Vec<Individual<T>>,
    optimization_objectives: Vec<OptimizationObjective>,
}

impl<T: Float + Debug + Send + Sync + 'static> MultiObjectiveOptimizer<T> {
    pub fn new(objective_weights: Vec<f64>) -> Result<Self> {
        let optimization_objectives = vec![
            OptimizationObjective::Accuracy,
            OptimizationObjective::Speed,
            OptimizationObjective::Memory,
        ];

        Ok(Self {
            objective_weights,
            pareto_front: Vec::new(),
            optimization_objectives,
        })
    }

    pub fn update_pareto_front(&mut self, population: &[Individual<T>]) -> Result<Vec<Individual<T>>> {
        self.pareto_front = self.compute_pareto_front(population)?;
        Ok(self.pareto_front.clone())
    }

    fn compute_pareto_front(&self, population: &[Individual<T>]) -> Result<Vec<Individual<T>>> {
        let mut front = Vec::new();

        for individual in population {
            let mut dominated = false;

            for existing in &front {
                if self.dominates(existing, individual)? {
                    dominated = true;
                    break;
                }
            }

            if !dominated {
                front.retain(|existing| !self.dominates(individual, existing).unwrap_or(false));
                front.push(individual.clone());
            }
        }

        Ok(front)
    }

    fn dominates(&self, a: &Individual<T>, b: &Individual<T>) -> Result<bool> {
        let objectives_a = self.extract_objectives(&a.metrics)?;
        let objectives_b = self.extract_objectives(&b.metrics)?;

        let mut at_least_one_better = false;
        for (obj_a, obj_b) in objectives_a.iter().zip(objectives_b.iter()) {
            if obj_a < obj_b {
                return Ok(false);
            }
            if obj_a > obj_b {
                at_least_one_better = true;
            }
        }

        Ok(at_least_one_better)
    }

    fn extract_objectives(&self, metrics: &super::evaluation::EvaluationMetrics) -> Result<Vec<f64>> {
        Ok(vec![
            metrics.accuracy,
            1.0 / (1.0 + metrics.training_time_seconds / 3600.0),
            1.0 / (1.0 + metrics.memory_usage_mb as f64 / 1024.0),
        ])
    }

    pub fn get_pareto_front(&self) -> &[Individual<T>] {
        &self.pareto_front
    }
}

/// Optimization objectives
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum OptimizationObjective {
    Accuracy,
    Speed,
    Memory,
    Energy,
    Complexity,
}

/// Pareto front representation
pub struct ParetoFront<T: Float + Debug + Send + Sync + 'static> {
    pub individuals: Vec<Individual<T>>,
    pub objective_count: usize,
}

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

    #[test]
    fn test_multi_objective_optimizer() {
        let weights = vec![0.5, 0.3, 0.2];
        let optimizer = MultiObjectiveOptimizer::<f32>::new(weights);
        assert!(optimizer.is_ok());
    }
}