Struct radiate::models::neat::neuron::Neuron

pub struct Neuron {
    pub id: NeuronId,
    pub neuron_type: NeuronType,
    pub activated_value: f32,
    pub deactivated_value: f32,
    pub current_state: f32,
    pub previous_state: f32,
    pub error: f32,
    pub bias: f32,
    // some fields omitted
}

Neuron is a wrapper around a neuron providing only what is needed for a neuron to be added to the NEAT graph, while the neuron encapsulates the neural network logic for the specific node type, Some neurons like an LSTM require more variables and different internal activation logic, so encapsulating that within a normal node on the graph would be misplaced.

Fields

id: NeuronId

neuron_type: NeuronType

activated_value: f32

deactivated_value: f32

current_state: f32

previous_state: f32

error: f32

bias: f32

Implementations

impl Neuron

pub fn new(
    id: NeuronId,
    neuron_type: NeuronType,
    activation: Activation,
    direction: NeuronDirection
) -> Self

pub fn add_incoming(&mut self, edge: &Edge)

Add incoming edge

pub fn add_outgoing(&mut self, edge: EdgeId)

Add outgoing edge

pub fn update_incoming(&mut self, edge: &Edge, weight: f32)

Update incoming edge

pub fn remove_incoming(&mut self, edge: &Edge)

Remove incoming edge

pub fn remove_outgoing(&mut self, edge: EdgeId)

Remove outgoing edge

pub fn incoming_edges(&self) -> &[NeuronLink]

Get incoming edge ids.

pub fn outgoing_edges(&self) -> &[EdgeId]

Get outgoing edge ids.

pub fn activate(&mut self)

𝜎(Σ(w * i) + b) activate this node by calling the underlying neuron's logic for activation

pub fn reset_neuron(&mut self)

each Neuron has a base layer of reset which needs to happen but on top of that each neuron might need to do more internally

pub fn clone_with_values(&self) -> Self

Trait Implementations

impl Clone for Neuron

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 Neuron

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Neuron

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

Deserialize this value from the given Serde deserializer.

impl Serialize for Neuron

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

Serialize this value into the given Serde serializer.