Struct radiate::models::neat::neatenv::NeatEnvironment

pub struct NeatEnvironment {
    pub weight_mutate_rate: Option<f32>,
    pub weight_perturb: Option<f32>,
    pub new_node_rate: Option<f32>,
    pub new_edge_rate: Option<f32>,
    pub edit_weights: Option<f32>,
    pub reactivate: Option<f32>,
    pub input_size: Option<u32>,
    pub output_size: Option<u32>,
    pub activation_functions: Vec<Activation>,
}

Configuation settings for the NeatAlgorithm

weight_mutate_rate: the probability of uniformly perturbing a connection weight or assigning a new random value weight_perturb: the uniform range to perturb a weight by will go from negative num to pos (if you enter 5, it will pertub a weight randomly between -5 and 5) new_node_rate: the probability of adding a new node to the network new_edge_rate: the probability of adding a new edge to the network edit_weights: the probability of weights in the network being edited or just left alone reactivate: the probability of reactivating a connection between two neurons

Fields

weight_mutate_rate: Option<f32>

weight_perturb: Option<f32>

new_node_rate: Option<f32>

new_edge_rate: Option<f32>

edit_weights: Option<f32>

reactivate: Option<f32>

input_size: Option<u32>

output_size: Option<u32>

activation_functions: Vec<Activation>

Methods

impl NeatEnvironment

pub fn new() -> Self

pub fn set_weight_mutate_rate(self, num: f32) -> Self

pub fn set_weight_perturb(self, num: f32) -> Self

pub fn set_new_node_rate(self, num: f32) -> Self

pub fn set_new_edge_rate(self, num: f32) -> Self

pub fn set_edit_weights(self, num: f32) -> Self

pub fn set_reactivate(self, num: f32) -> Self

pub fn set_input_size(self, num: u32) -> Self

pub fn set_output_size(self, num: u32) -> Self

pub fn set_activation_functions(self, funcs: Vec<Activation>) -> Self

Trait Implementations

impl Clone for NeatEnvironment

fn clone(&self) -> NeatEnvironment

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NeatEnvironment

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

Formats the value using the given formatter.

impl Default for NeatEnvironment

fn default() -> Self

Returns the "default value" for a type.

impl Envionment for NeatEnvironment

fn reset(&mut self)

Reset can be used to reset the enviromnet after a certain event occurs, if not this is an empty default implementation

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

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

Crossover is the process of taking two types (T) and returning a new type, this is done through some defined form of mutation using the config type, or through crossover where parts of one type are given to parts of the other and that resulting type is returnd

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

This is a measure of a evolutionary types structure or topology - depending on what is being evolved. This is needed to split the members in their respective species - essentially it is a measure of how far away two types are from each other in a genetic sense. Think of something like how similar humans are to dolphins, this is a way to quanitfy that.

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 Genome<LSTM, NeatEnvironment> for LSTM where
    LSTM: Layer, 

in order for the lstm 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 lstm layers

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

implement how to crossover two LSTM layers

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

get the distance between two LSTM 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 Genome<Neat, NeatEnvironment> for Neat

iplement genome for a neat network

fn crossover(
    one: &Neat,
    two: &Neat,
    env: &Arc<RwLock<NeatEnvironment>>,
    crossover_rate: f32
) -> Option<Neat>

Crossover is the process of taking two types (T) and returning a new type, this is done through some defined form of mutation using the config type, or through crossover where parts of one type are given to parts of the other and that resulting type is returnd

fn base(env: &mut NeatEnvironment) -> Neat

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

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

This is a measure of a evolutionary types structure or topology - depending on what is being evolved. This is needed to split the members in their respective species - essentially it is a measure of how far away two types are from each other in a genetic sense. Think of something like how similar humans are to dolphins, this is a way to quanitfy that.

impl Send for NeatEnvironment

impl Sync for NeatEnvironment