Struct radiate::models::neat::layers::gru::GRU

pub struct GRU {
    pub input_size: u32,
    pub memory_size: u32,
    pub output_size: u32,
    pub current_memory: Vec<f32>,
    pub current_output: Vec<f32>,
    pub f_gate: Dense,
    pub e_gate: Dense,
    pub o_gate: Dense,
}

Fields

input_size: u32

memory_size: u32

output_size: u32

current_memory: Vec<f32>

current_output: Vec<f32>

f_gate: Dense

e_gate: Dense

o_gate: Dense

Implementations

impl GRU

implement a simple GRU layer that can be added to the neat network

pub fn new(
    input_size: u32,
    memory_size: u32,
    output_size: u32,
    act: Activation
) -> Self

Trait Implementations

impl Clone for GRU

Implement clone for the neat neural network in order to facilitate proper crossover and mutation for the network

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GRU

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GRU

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for GRU

implement display for the GRU layer of the network

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Genome<GRU, NeatEnvironment> for GRU where
    GRU: Layer, 

in order for the GRU layer to be evolved along with the rest of the network, Genome must be implemented so that the layer can be crossed over and measured along with other GRU layers

fn crossover(
    child: &GRU,
    parent_two: &GRU,
    env: Arc<RwLock<NeatEnvironment>>,
    crossover_rate: f32
) -> Option<GRU>

implement how to crossover two GRU layers

fn distance(one: &GRU, two: &GRU, env: Arc<RwLock<NeatEnvironment>>) -> f32

get the distance between two GRU layers of the network

fn base(_: &mut E) -> T where
    T: Sized, 

Genome needs to have a base implementation in order for one of the population options to be satisfied

impl Layer for GRU

implement the layer trait for the GRU so it can be stored in the neat network

fn forward(&mut self, inputs: &Vec<f32>) -> Option<Vec<f32>>

implement the propagation function for the GRU layer

fn backward(
    &mut self,
    _errors: &Vec<f32>,
    _learning_rate: f32
) -> Option<Vec<f32>>

Take the errors of the feed forward and backpropagate them through the network to adjust the weights of the connections between the neurons. Return the error of the input neurons from this layer - needed to transfer error from layer to layer

fn as_ref_any(&self) -> &dyn Any where
    Self: Sized + 'static, 

Get a reference to the underlying type without generics in order to downcast to a concrete type

fn as_mut_any(&mut self) -> &mut dyn Any where
    Self: Sized + 'static, 

Get a mutable reference to the underlying type without generics in order to downcast to a concrete type

fn shape(&self) -> (usize, usize)

Return the (input size, output size) of this layer - used to make specifying layer sizes easier so the user only needs the say the size of the output, not the input. That would be too redundant.

fn reset(&mut self)

reset the layer, not a necessary implementation

fn add_tracer(&mut self)

fn remove_tracer(&mut self)

remove the tracer from a layer so that it can be evolved without keeping track of data

impl Serialize for GRU

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.