Struct eant2::options::EANT2Options

pub struct EANT2Options {
    pub inputs: usize,
    pub outputs: usize,
    pub population_size: usize,
    pub offspring_count: usize,
    pub fitness_threshold: f64,
    pub similar_fitness: f64,
    pub max_generations: usize,
    pub threads: usize,
    pub cmaes_runs: usize,
    pub cmaes_end_conditions: Vec<CMAESEndConditions>,
    pub print_option: bool,
    pub weights: [usize; 4],
    pub seed: Option<Network>,
    pub transfer_function: TransferFunction,
}

A container for all parameters and options for the EANT2 algorithm. See constants for default values.

Using default options is convenient, but may slightly reduce the quality of the neural networks generated, and can increase the time needed to find a solution. It is recommended to adjust the parameters depending on whether it is more important to find a solution quickly or to find a better solution. Note that increasing population size and CMA-ES runs will only affect the quality a small amount, so using smaller values will greatly speed up the algorithm, and does not have a large downside. It is important to set the fitness threshold using the fitness_threshold method, otherwise the algorithm may terminate too soon or take a long time to run. Here are some general tips for setting the options (more in the documentation):

If a minimal neural network is preferred, increase similar_fitness and increase the weight for connection removal. For complex problems, decrease population size and the weights for adding connections and neurons.

Examples

use eant2::*;

// A set of default options, with 2 inputs and 3 outputs to each neural network
let options = EANT2Options::new(2, 3);

// A set of options with 4 CMA-ES optimizations per individual, a minimum fitness of 10.0, and
// a population size of 50
let options = EANT2Options::new(2, 3)
    .fitness_threshold(10.0)
    .fitness_threshold(0.0)
    .cmaes_runs(4)
    .population_size(50);

Fields

inputs: usize

outputs: usize

population_size: usize

offspring_count: usize

fitness_threshold: f64

similar_fitness: f64

max_generations: usize

threads: usize

cmaes_runs: usize

cmaes_end_conditions: Vec<CMAESEndConditions>

print_option: bool

weights: [usize; 4]

seed: Option<Network>

transfer_function: TransferFunction

Methods

impl EANT2Options

fn new(inputs: usize, outputs: usize) -> EANT2Options

Returns a set of default options (see constants for default values).

fn seed(self, network: Network) -> EANT2Options

Add docs here

fn population_size(self, size: usize) -> EANT2Options

Sets the population size. Increasing this option may produce higher quality neural networks, but will increase the time needed to find a solution.

fn offspring_count(self, count: usize) -> EANT2Options

Sets the offspring count (how many offspring each individual spawns). Increasing this option may produce higher quality neural networks, but will increase the time needed to find a solution.

fn fitness_threshold(self, fitness: f64) -> EANT2Options

Sets the fitness threshold. The algorithm terminates if the best individual has a fitness less than or equal to the specified amount. It is recommended to set this option to a value specific to each fitness function. The specified fitness may not be reached if the max generation is reached first.

fn max_generations(self, generations: usize) -> EANT2Options

Sets the maximum generations. The algorithm terminates after the specified number of generations pass. Increasing this option will likely produce higher quality networks, but will increase the running time of the algorithm. The number of generations specified may not be reached if the fitness threshold is reached first.

fn similar_fitness(self, threshold: f64) -> EANT2Options

Sets the threshold for deciding whether two neural networks have a similar fitness. Increasing this option will make the algorithm more aggresively prefer smaller neural networks. Decreasing it will do the opposite, allowing larger individuals to stay in the population. It is recommended to set this option higher if a small neural network is preferred. The downside is it will take slightly longer to find a solution, due to more higher fitness neural networks being discarded.

fn threads(self, threads: usize) -> EANT2Options

Sets the number of threads to use in the algorithm. Increasing this option on multi-core hardware will greatly decrease the running time of the algorithm.

fn cmaes_runs(self, runs: usize) -> EANT2Options

Sets the number of times CMA-ES should be run on each individual. More runs will produce higher quality neural networks faster at the cost of a higher number of fitness function calls. Increase the number of runs if the fitness function is cheap to run, or if time taken to find a solution is not important.

fn cmaes_end_conditions(self, conditions: Vec<CMAESEndConditions>) -> EANT2Options

Sets the end conditions of CMA-ES. Setting higher stable generations or max generations or evaluations can produce higher quality neural networks at the cost of a longer time taken to find a solution. Decreasing these options is a good idea when it is important to find a solution quickly. DO NOT set the fitness threshold option, or it will take a very long time to find a solution, even on the simplest problems! It is recommended to leave this option alone, but the documentation for it is available here.

Examples

use eant2::*;

let cmaes_conditions = vec![CMAESEndConditions::MaxGenerations(250),
                            CMAESEndConditions::StableGenerations(0.001, 5)];

let options = EANT2Options::new(2, 2)
                  .cmaes_end_conditions(cmaes_conditions);

fn print(self, print: bool) -> EANT2Options

Sets whether to print info while the algorithm is running. The generation number is printed, and info about the solution is printed when the algorithm terminates.

fn mutation_weights(self, weights: [usize; 4]) -> EANT2Options

Sets the weight for choosing each mutation. The first element should be the weight for adding a connection, the second for removing a connection, the third for adding a neuron, and the fourth for adding a bias input. The weights are relative, so with the weights [1, 2, 4, 8], each mutation has twice the chance of the previous. In general, the chance for connection mutations should be higher than the chance for a neuron mutation. If a minimal network is desired, set the bias, neuron and connection addition weights low, and the connection removal rate high. For complex problems where network size isn't an issue, high connection addition rate is a good idea.

fn transfer_function(self, function: TransferFunction) -> EANT2Options

Sets the transfer function to use for the trained neural networks. See the documentation here for information.

Trait Implementations

impl Clone for EANT2Options

fn clone(&self) -> EANT2Options

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.