Struct OutputLayer

pub struct OutputLayer<A: Activation, Neurons: NL<Input>, Input: AL> { /* private fields */ }

The final layer of a Network.

Implementations

impl<A: Activation, Neurons: NL<Input>, Input: AL> OutputLayer<A, Neurons, Input>

pub fn new() -> Self

Trait Implementations

impl<A: Clone + Activation, Neurons: Clone + NL<Input>, Input: Clone + AL> Clone for OutputLayer<A, Neurons, Input>

fn clone(&self) -> OutputLayer<A, Neurons, Input>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Activation, Neurons: Debug + NL<Input>, Input: Debug + AL> Debug for OutputLayer<A, Neurons, Input>

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

Formats the value using the given formatter.

impl<'de, A: Activation, Neurons, Input> Deserialize<'de> for OutputLayer<A, Neurons, Input>

where Neurons: NL<Input>, Input: AL,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: Activation, Input: AL, Neurons: NL<Input>> Layer<Input, Neurons, Neurons, A> for OutputLayer<A, Neurons, Input>

fn calculate( &self, inputs: &GenericArray<f32, Input>, ) -> GenericArray<f32, Neurons>

runs the inputs through this and lower layers, resulting in the output

fn step( &self, inputs: &GenericArray<f32, Neurons>, ) -> GenericArray<f32, Neurons>

runs only this layers calculation, not recursing to deeper layers

fn weight( &self, inputs: &GenericArray<f32, Input>, ) -> GenericArray<f32, Neurons>

reduces the inputs to a single input per neuron using the weights. i.e. calculates the input to the activation functions for the neurons

fn _get_error( &mut self, output: GenericArray<f32, Neurons>, correct_output: &GenericArray<f32, Neurons>, _speed: f32, ) -> (GenericArray<f32, Neurons>, GenericArray<f32, Neurons>)

gets this layers error, either by comparing with correct output or by calling lower layers

fn _apply_deltas( &mut self, deltas: GenericArray<f32, Neurons>, inputs: &GenericArray<f32, Input>, speed: f32, )

modifies own weights by given deltas

fn _pre_error( &self, deltas: &GenericArray<f32, Neurons>, ) -> GenericArray<f32, Input>

calculates the previous layers errors from this layers errors and weights

fn backprop( &mut self, input: &GenericArray<f32, Input>, correct_output: &GenericArray<f32, FinalOut>, speed: f32, ) -> (GenericArray<f32, Input>, GenericArray<f32, FinalOut>)

pass in the input and the expected output. calculates the error for each neuron and corrects itself speed should be 0..1 and modifies how strongly the weights are adjusted

fn _weight_errors( &self, error: GenericArray<f32, Neurons>, weighted_inputs: &GenericArray<f32, Neurons>, ) -> GenericArray<f32, Neurons>

weights errors relative to activation. gets called by backprop, don’t call this manually

fn teach<F: FnMut(usize, f32), I: IntoIterator<Item = (GenericArray<f32, Input>, GenericArray<f32, FinalOut>)>>( &mut self, lesson: I, iterations: usize, callback: F, )

where <I as IntoIterator>::IntoIter: Clone,

impl<A: Activation, Neurons, Input> Serialize for OutputLayer<A, Neurons, Input>

where Neurons: NL<Input>, Input: AL,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.