fann 0.1.8

Wrapper for the Fast Artificial Neural Networks library
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

use libc::c_float;

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct IncrementalParams {
    /// A higher momentum can be used to speed up incremental training. It should be between 0
    /// and 1, the default is 0.
    pub learning_momentum: c_float,
    /// The learning rate determines how aggressive training should be. Default is 0.7.
    pub learning_rate: c_float,
}

impl Default for IncrementalParams {
    fn default() -> IncrementalParams {
        IncrementalParams {
            learning_momentum: 0.0,
            learning_rate: 0.7,
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct BatchParams {
    /// The learning rate determines how aggressive training should be. Default is 0.7.
    pub learning_rate: c_float,
}

impl Default for BatchParams {
    fn default() -> BatchParams {
        BatchParams { learning_rate: 0.7 }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct RpropParams {
    /// A value less than 1, used to decrease the step size during training. Default 0.5
    pub decrease_factor: c_float,
    /// A value greater than 1, used to increase the step size during training. Default 1.2
    pub increase_factor: c_float,
    /// The minimum step size. Default 0.0
    pub delta_min: c_float,
    /// The maximum step size. Default 50.0
    pub delta_max: c_float,
    /// The initial step size. Default 0.1
    pub delta_zero: c_float,
}

impl Default for RpropParams {
    fn default() -> RpropParams {
        RpropParams {
            decrease_factor: 0.5,
            increase_factor: 1.2,
            delta_min: 0.0,
            delta_max: 50.0,
            delta_zero: 0.1,
        }
    }
}

#[derive(Copy, Clone, Debug, PartialEq)]
pub struct QuickpropParams {
    /// The factor by which weights should become smaller in each iteration, to ensure that
    /// the weights don't grow too large during training. Should be a negative number close to
    /// 0. The default is -0.0001.
    pub decay: c_float,
    /// The mu factor is used to increase or decrease the step size; should always be greater
    /// than 1. The default is 1.75.
    pub mu: c_float,
    /// The learning rate determines how aggressive training should be. Default is 0.7.
    pub learning_rate: c_float,
}

impl Default for QuickpropParams {
    fn default() -> QuickpropParams {
        QuickpropParams {
            decay: -0.0001,
            mu: 1.75,
            learning_rate: 0.7,
        }
    }
}

/// The Training algorithms used when training on `fann_train_data` with functions like
/// `fann_train_on_data` or `fann_train_on_file`. The incremental training alters the weights
/// after each time it is presented an input pattern, while batch only alters the weights once after
/// it has been presented to all the patterns.
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum TrainAlgorithm {
    /// Standard backpropagation algorithm, where the weights are updated after each training
    /// pattern. This means that the weights are updated many times during a single epoch and some
    /// problems will train very fast, while other more advanced problems will not train very well.
    Incremental(IncrementalParams),
    /// Standard backpropagation algorithm, where the weights are updated after calculating the mean
    /// square error for the whole training set. This means that the weights are only updated once
    /// during an epoch. For this reason some problems will train slower with this algorithm. But
    /// since the mean square error is calculated more correctly than in incremental training, some
    /// problems will reach better solutions.
    Batch(BatchParams),
    /// A more advanced batch training algorithm which achieves good results for many problems.
    /// `Rprop` is adaptive and therefore does not use the `learning_rate`. Some other parameters
    /// can, however, be set to change the way `Rprop` works, but it is only recommended for users
    /// with a deep understanding of the algorithm. The original RPROP training algorithm is
    /// described by [Riedmiller and Braun, 1993], but the algorithm used here is a variant, iRPROP,
    /// described by [Igel and Husken, 2000].
    Rprop(RpropParams),
    /// A more advanced batch training algorithm which achieves good results for many problems. The
    /// quickprop training algorithm uses the `learning_rate` parameter along with other more
    /// advanced parameters, but it is only recommended to change these for users with a deep
    /// understanding of the algorithm. Quickprop is described by [Fahlman, 1988].
    Quickprop(QuickpropParams),
}

impl Default for TrainAlgorithm {
    fn default() -> TrainAlgorithm {
        TrainAlgorithm::Rprop(Default::default())
    }
}