Function batch_mutate

pub fn batch_mutate(
    amount: usize,
    mutation_rate: f64,
    network: &NeuralNetwork,
    outputs: bool,
) -> Vec<NeuralNetwork>

Turns one inputted NeuralNetwork into amount number of mutated NeuralNetworks mutated by mutation. If outputs is true then it will also mutate the output weights. It does this through cloning and calling NeuralNetwork::mutate(mutation) so it isn’t any more efficent, its simply here for convenience.

Examples found in repository

examples/simple_use_case.rs (line 38)

fn main() {
    /// This is our target, we will consider `NeuralNetworks` that get closer to this to be learning.
    const TARGET:f64 = 10.0;

    /// The margin of error for the networks.
    const MARGIN:f64 = 0.1;

    /// This is the `INPUT` for the networks, the goal being for them to "learn" how to take this number as
    /// an input and output `TARGET`. When they output a value within `MARGIN` of `TARGET` that `NeuralNetwork`
    /// will be considered to have reach the goal.
    const INPUT:f64 = 1.0;

    /// The maximum number of `GENERATIONS` that will be ran, less may be ran if a network gets within `margin` of
    /// the target before `GENERATIONS` number of generations are ran.
    const GENERATIONS:usize = 10_000;

    // Create a `Vector` containing all `NeuralNetwork`s in the current generation using `batch_mutate()` and `NeuralNetwork::new()`
    let mut networks:Vec<NeuralNetwork> = batch_mutate(5,0.25,&mut NeuralNetwork::new(1.0,1,3,1), true);

    // This stores the closest value found by the network, it defaults to negative infinity.
    let mut closest_value:f64 = f64::NEG_INFINITY;

    // Get the current instant so that it can later be used to time how long it took to finish/fail
    let time:Instant = Instant::now();

    // For `generation` in `GENERATIONS` perform `batch_run()` and check if the networks are getting closer.
    for generation in 0..GENERATIONS {
        // Run the networks using `INPUT` as an input and store the output in `output`
        let outputs:Vec<Vec<f64>> = batch_run(&mut networks, &vec![INPUT]);

        // The `closest_network` used for creating the next generation.
        let mut closest_network:usize = 0;

        // Loop through every value in `outputs` checking to see if any of the outputs are within `MARGIN` of `TARGET`
        // And use a range so that we can track the index of the output easily.
        for output in 0..outputs.len() {
            // Since the networks are only outputting a single value we can simply grab the first value of the `Vector`
            // and check if thats within `MARGIN` of `TARGET` using a range.
            if (TARGET-MARGIN..=TARGET+MARGIN).contains(&outputs[output][0]) {
                // If true then print the value found by the network, the network itself, the current generation, and exit from the program.
                println!("Finished in {:?}!\nGeneration: {:?}\nValue: {:?}\nNetwork: {{\nHiddenLayers: {:?}\nOutputLayer: {:?}\n}}", time.elapsed(),generation, outputs[output][0], networks[output].get_weights(), networks[output].get_output_weights());
                // Exit code 0 on Linux means no problem, on Windows however this should be 256 but that is outside the scope of this example.
                std::process::exit(0);
            } else {
                // If the `output` was not within `MARGIN` of `TARGET` then check if this value is closer to `TARGET` than the last `closest_value`.
                // and set `closest_value` to `output` if it is closer.
                if outputs[output][0] < TARGET && outputs[output][0] > closest_value {
                    closest_value = outputs[output][0];
                    closest_network = output;
                } else if outputs[output][0] > TARGET && outputs[output][0] < closest_value {
                    closest_value = outputs[output][0];
                    closest_network = output;
                }
            }
        }

        // Set all `networks` to various mutations of the `closest_network`.
        networks = batch_mutate(5, 0.25, &networks[closest_network], true);
    }

    // If we managed to get through `GENERATIONS` number of generations without getting within `MARGIN` of `TARGET` then output the `closest_value` we found.
    println!("Failed to get within `MARGIN` within {:?} number of generations, this is the `closest_value` obtained: {:?}. In {:?}", GENERATIONS, closest_value, time.elapsed());
}