Struct radiate::models::neat::neat::Neat

pub struct Neat {
    pub layers: Vec<LayerWrap>,
    pub input_size: u32,
    pub batch_size: usize,
}

Neat is a neural network consisting of layers the layers can be stacked together then the feed forward and backprop functions will take care of 'connecting them'

Fields

layers: Vec<LayerWrap>

input_size: u32

batch_size: usize

Implementations

impl Neat

pub fn new() -> Self

pub fn input_size(self, input_size: u32) -> Self

set the input size for the network

pub fn batch_size(self, batch_size: usize) -> Self

set the batch size for the network

pub fn reset(&mut self)

reset the layers on the network

pub fn train<F>(
    &mut self,
    inputs: &[Vec<f32>],
    targets: &[Vec<f32>],
    rate: f32,
    loss_fn: Loss,
    run: F
) -> Result<(), Box<dyn Error>> where
    F: Fn(usize, f32) -> bool, 

train the network

pub fn backward(
    &mut self,
    net_outs: &[Vec<f32>],
    net_targets: &[Vec<f32>],
    rate: f32,
    loss_fn: &Loss
) -> f32

backpropagate the network, will move through time if needed

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

feed forward a vec of data through the neat network

pub fn dense_pool(self, size: u32, activation: Activation) -> Self

create and append a new dense pool layer onto the neat network

pub fn dense(self, size: u32, activation: Activation) -> Self

create an append a simple dense layer onto the network

pub fn lstm(self, size: u32, output_size: u32, act: Activation) -> Self

create a new lstm layer and add it to the network

pub fn gru(self, size: u32, output_size: u32, act: Activation) -> Self

pub fn save(&self, file_path: &str) -> Result<(), Box<dyn Error>>

dumy model saver file to export the model to json

pub fn load(file_path: &str) -> Result<Neat, Box<dyn Error>>

load in a saved neat model from a file path

Trait Implementations

impl Clone for Neat

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 Neat

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Neat

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

Deserialize this value from the given Serde deserializer.

impl Genome<Neat, NeatEnvironment> for Neat

implement 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 returned

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 an evolutionary type's 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 quantify that.

impl PartialEq<Neat> for Neat

Implement partialeq for neat because if neat itself is to be used as a problem, it must be able to compare one to another

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Serialize for Neat

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

Serialize this value into the given Serde serializer.