Struct dumbnet::layers::InnerLayer

pub struct InnerLayer<A: Activation, Neurons: NL<Input>, Input: AL, NextN: NL<Neurons>, FinalOut: AL, NextA: Activation, Next: Layer<Neurons, NextN, FinalOut, NextA>> { /* fields omitted */ }

a layer that stacks another layer inside itself (which may then recursively stack another and so on)

Methods

impl<A: Activation, Neurons: NL<Input>, Input: AL, NextN: NL<Neurons>, FinalOut: AL, NextA: Activation, Next: Layer<Neurons, NextN, FinalOut, NextA>> InnerLayer<A, Neurons, Input, NextN, FinalOut, NextA, Next>

pub fn push(next: Next) -> Self

Pushes this layer on top of an existing layer.

Trait Implementations

impl<A: Clone + Activation, Neurons: Clone + NL<Input>, Input: Clone + AL, NextN: Clone + NL<Neurons>, FinalOut: Clone + AL, NextA: Clone + Activation, Next: Clone + Layer<Neurons, NextN, FinalOut, NextA>> Clone for InnerLayer<A, Neurons, Input, NextN, FinalOut, NextA, Next>

fn clone(&self) -> InnerLayer<A, Neurons, Input, NextN, FinalOut, NextA, Next>

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, NextN: Debug + NL<Neurons>, FinalOut: Debug + AL, NextA: Debug + Activation, Next: Debug + Layer<Neurons, NextN, FinalOut, NextA>> Debug for InnerLayer<A, Neurons, Input, NextN, FinalOut, NextA, Next>

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

Formats the value using the given formatter.

impl<'de, A: Activation, Neurons: NL<Input>, Input: AL, NextN: NL<Neurons>, FinalOut: AL, NextA: Activation, Next: Layer<Neurons, NextN, FinalOut, NextA>> Deserialize<'de> for InnerLayer<A, Neurons, Input, NextN, FinalOut, NextA, Next> where
    Neurons: NL<Input>,
    Input: AL,
    NextN: NL<Neurons>,
    FinalOut: 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, Neurons: NL<Input>, Input: AL, NextN: NL<Neurons>, FinalOut: AL, NextA: Activation, Next: Layer<Neurons, NextN, FinalOut, NextA>> Layer<Input, Neurons, FinalOut, A> for InnerLayer<A, Neurons, Input, NextN, FinalOut, NextA, Next>

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

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

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 step(
    &self,
    inputs: &GenericArray<f32, Neurons>
) -> GenericArray<f32, Neurons>

runs only this layers calculation, not recursing to deeper layers

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

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, NextN: NL<Neurons>, FinalOut: AL, NextA: Activation, Next: Layer<Neurons, NextN, FinalOut, NextA>> Serialize for InnerLayer<A, Neurons, Input, NextN, FinalOut, NextA, Next> where
    Neurons: NL<Input>,
    Input: AL,
    NextN: NL<Neurons>,
    FinalOut: AL, 

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

Serialize this value into the given Serde serializer.