revonet 0.2.1

Rust implementation of real-coded genetic algorithm for solving optimization problems and training of neural networks. The latter is also known as neuroevolution.
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

use rand::{Rng};
use std;

use ea::*;

/// Represents baseline interface for the objective function.
///
/// By default solution is represented by a vector of real-numbers.
///
/// # Example: Custom optimization problem
/// ```
/// extern crate revonet;
/// extern crate rand;
///
/// use rand::{Rng, SeedableRng, StdRng};
///
/// use revonet::ea::*;
/// use revonet::problem::*;
///
/// // Dummy problem returning random fitness.
/// pub struct DummyProblem;
///
/// impl Problem for DummyProblem {
///     // Function to evaluate a specific individual.
///     fn compute<T: Individual>(&self, ind: &mut T) -> f32 {
///         // use `to_vec` to get real-coded representation of an individual.
///         let v = ind.to_vec().unwrap();
///
///         // Perform calculations as per optimization problem being implemened.
///         // Here just a random value is returned.
///         let mut rng: StdRng = StdRng::from_seed(&[0]);
///         rng.gen::<f32>()
///     }
/// }
///
/// fn main() {}
/// ```

pub trait Problem{
    /// Returns whether given fitness value is enough to be a solution.
    ///
    /// # Arguments:
    /// * `value` - fitness value to consider.
    fn is_solution(&self, value: f32) -> bool {
        value < 1e-3f32
    }
    /// Generate random individual for the problem. Default implementation creates a real-coded
    /// individual with the number of genes equal to `size`
    ///
    /// # Arguments:
    /// * `size` - number of genes.
    /// * `rng` - reference to pre-initialized RNG.
    fn get_random_individual<T: Individual, R: Rng>(&self, size: usize, mut rng: &mut R) -> T {
        let mut res_ind = T::new();
        res_ind.init(size, rng);
        res_ind
    }
    /// Computes fitness value for a given individual.
    ///
    /// # Arguments:
    /// * `ind` - individual to compute a fitness for.
    fn compute<T: Individual>(&self, ind: &mut T) -> f32;
}

//---------------------------------------------------------------
/*
Some other functions: https://en.wikipedia.org/wiki/Test_functions_for_optimization
*/

/// Sample problem representing [Sphere function](https://en.wikipedia.org/wiki/Test_functions_for_optimization).
#[allow(dead_code)]
pub struct SphereProblem;
impl Problem for SphereProblem {
    fn compute<T: Individual>(&self, ind: &mut T) -> f32 {
        let v = ind.to_vec().expect("Can not extract vector of genes");
        if v.len() > 0 {v.iter().fold(0f32, |s, x| s + x*x)} else {std::f32::NAN}
    }
}

//---------------------------------------------------------------
/// Sample problem representing [Rastrigin function](https://en.wikipedia.org/wiki/Rastrigin_function).
#[allow(dead_code)]
pub struct RastriginProblem;
impl Problem for RastriginProblem {
    fn compute<T: Individual>(&self, ind: &mut T) -> f32 {
        const PI2: f32 = 2f32 * std::f32::consts::PI;
        let v = ind.to_vec().expect("Can not extract vector of genes");
        if v.len() > 0 {v.iter().fold(10f32*(v.len() as f32), |s, x| s + x*x - 10f32 * (x * PI2).cos())}
        else {std::f32::NAN}
    }
}


//---------------------------------------------------------------
/// Sample problem representing [Rosenbrock function](https://en.wikipedia.org/wiki/Rosenbrock_function).
#[allow(dead_code)]
pub struct RosenbrockProblem;
impl Problem for RosenbrockProblem {
    fn compute<T: Individual>(&self, ind: &mut T) -> f32 {
        let v = ind.to_vec().expect("Can not extract vector of genes");
        if v.len() == 0 {return std::f32::NAN;}

        let mut res = 0f32;
        for k in 1..v.len() {
            let xk = v[k as usize];
            let xk1 = v[(k - 1) as usize];
            res += 100f32 * (xk - xk1).powf(2f32) + (xk1 - 1f32).powf(2f32)
        }
        res
    }
}