I know GRU is a variant of RNN in the context of neural network of machine learning. And in the original NEAT paper, the author did mention a kind of RNN, with which the game double pole is solved----the RNN here is not what we refer to in the context of machine learning, right?

But what does GRU mean in the context of NEAT for this crate? Does it mean that NEAT could generate GRU structure (like in this paper), and with which could solve non-Markov decision problem?

These changes are sometimes simplifications sometimes unnecessary references. None of them change the functionality of anything but are mostly just easier to read or slightly increase Performance(like using Mutex::get_mut instead of Mutex::lock).

While the examples do successfully compile but do not really work yet, there are some further Cleanups along with Changes like deriving the Debug trait to many structs which makes it possible to use it on types like the Snake in the example.

I also made an error.rs for the train module which makes error handling possible and is shorter than using panic twice.

Here is my current (edited) code from the README. Upon putting it in a main function there are multiple functions that don't exist(compute_score and get_inputs()). My proposal to fix this would be to put the example in an examples folder similar to this blog. This makes it easier to check if the code in the examples code works. I will work on this in the following days.

use neat_gru::game::{Game, GameAsync};
use neat_gru::neural_network::nn::NeuralNetwork;
use neat_gru::topology::topology::Topology;
use async_trait::async_trait;
use neat_gru::train::train::Train;
struct Player {
    pub net: NeuralNetwork<f64>,
}

impl Player {
    pub fn new(net: NeuralNetwork<f64>) -> Player {
        Player {
            net,
        }
    }
}

struct Simulation {
    players: Vec<Player>,
}

impl Simulation {
    pub fn new() -> Simulation {
        Simulation {
            players: Vec::new(),
        }
    }
}

impl Game<f64> for Simulation {
    /// Loss function
    fn run_generation(&mut self) -> Vec<f64> {
        let inputs = get_inputs();
        self.players.iter().map(|p| {
            let output = p.net.compute(inputs);
            let scores = compute_score(output, target);
            scores
        }).collect()
    }

    /// Reset networks
    fn reset_players(&mut self, nets: Vec<NeuralNetwork<f64>>) {
        self.players.clear();
        self.players = nets
            .into_iter()
            .map(Player::new)
            .collect();
    }

    /// Called at the end of training
    fn post_training(&mut self, history: &[Topology<f64>]) {
        // Iter on best topologies and upload the best one
    }
}

const INPUT_COUNT: usize = 2;
const OUTPUT_COUNT: usize = 1;
const NB_GENERATIONS: usize = 5;
const ITERATIONS: usize = 1000;
const HIDDEN_LAYERS: usize = 2;
const MAX_INDIVIDUALS: usize = 100;
fn run_sim() {
    let mut sim = Simulation::new();

    let mut runner = Train::new(&mut sim);
    runner
        .inputs(INPUT_COUNT)
        .outputs(OUTPUT_COUNT)
        .iterations(NB_GENERATIONS)
        .max_layers(HIDDEN_LAYERS + 2)
        .max_per_layers(HIDDEN_LAYERS)
        .max_individuals(MAX_INDIVIDUALS)
        .delta_threshold(2.) // Delta parameter from NEAT paper
        .formula(0.8, 0.8, 0.3) // c1, c2 and c3 from NEAT paper
        .access_train_object(Box::new(|train| {
            let species_count = train.species_count();
            println!("Species count: {}", species_count);
        })) // Callback called after `reset_players` that gives you access to the train object during training
        .start(); // .start_async().await for async version
}
fn main(){
    run_sim();
}

@Nereuxofficial @BenInTheBox Following the recent event with Microsoft, I added an AUTHORS file, feel free to edit or remove your information from the list

I finally had time to implement this. This time i implemented it as a feature, which should be nicer to use, since it allows users this: neat-gru-rust = { version="1.1.1", features="relu"} but without it the tanh function will be used.

This is more of a proof of concept since in order for it to get merged it would have to be optional, i think it's a nice idea since it would be much faster. You can also try it out using my flappy bird for or just replace the version with { git = "https://github.com/Nereuxofficial/neat-gru-rust"} in another project

Using Cargo criterion and looking at the generated HTML pages you can also see the performance difference between sigmoid and ReLu with nice charts.