Struct dumbnet::layers::OutputLayer

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

The final layer of a Network.

Methods

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: NL<Input>, Input: AL> 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: NL<Input>, Input: AL> 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.