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

pub struct Neat {
    pub inputs: Vec<i32>,
    pub outputs: Vec<i32>,
    pub nodes: HashMap<i32, *mut Neuron>,
    pub edges: HashMap<i32, Edge>,
}

Define a network graph structure of raw pointer neurons

Fields

inputs: Vec<i32>

outputs: Vec<i32>

nodes: HashMap<i32, *mut Neuron>

edges: HashMap<i32, Edge>

Methods

impl Neat

implement the neuralnetwork

pub fn new() -> Self

create a new empty neural network graph this network is basically in charge of keeping track of the nodes in the network and their connections to each other

pub fn feed_forward(&self, data: &Vec<f64>) -> Result<Vec<f64>, Box<dyn Error>>

Feed a vec of inputs through the network, will panic! if the shapes of the values do not match or if something goes wrong within the feed forward process.

pub fn backprop(
    &mut self,
    data: &Vec<f64>,
    targets: &Vec<f64>,
    learning_rate: f64
)

Backpropagation algorithm, transfer the error through the network and change the weights of the edges accordinly, this is pretty straight forward due to the design of the neat graph

pub fn connect(self, num_in: i32, num_out: i32, counter: &mut Counter) -> Self

Connect the inputs of the network to the outputs of the network for the first time and return back a fully connected default network.

pub fn add_node(
    &mut self,
    counter: &mut Counter,
    activation: Activation
) -> Option<*mut Neuron>

Add a node to the network by getting a random edge and inserting the new node inbetween that edge's source and destination nodes. The old weight is pushed forward while the new weight is randomly chosen and put between the old source node and the new node

pub fn add_edge(&mut self, counter: &mut Counter) -> Option<Edge>

add a connection to the network. Randomly get a sending node that cannot be an output and a receiving node which is not an input node, the validate that the desired connection can be made. If it can be, make the connection with a weight of .5 in order to minimally impact the network

pub fn see(&self)

Trait Implementations

impl Genome<Neat, NeatEnvironment> for Neat

iplement genome for a neat network

fn crossover(
    one: &Neat,
    two: &Neat,
    env: &Arc<Mutex<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<Mutex<NeatEnvironment>>) -> f64

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 Neat

These must be implemneted for the network or any type to be used within seperate threads. Because implementing the functions themselves is dangerious and unsafe and i'm not smart enough to do that from scratch, these "implmenetaions" will get rid of the error and realistically they don't need to be implemneted for the program to work

impl Sync for Neat

impl Drop for Neat

Because the tree is made out of raw mutable pointers, if those pointers are not dropped, there is a severe memory leak, like possibly gigs of ram over only a few generations depending on the size of the generation This drop implementation will recursivley drop all nodes in the tree

fn drop(&mut self)

Executes the destructor for this type.

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 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 Display for Neat

Simple override of display for neat to debug a little cleaner

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

Formats the value using the given formatter.

impl Debug for Neat

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

Formats the value using the given formatter.