Struct gad::net::Then

pub struct Then<N1, N2>(_, _);

The result of Net::then

Trait Implementations

impl<N1: Clone, N2: Clone> Clone for Then<N1, N2>

fn clone(&self) -> Then<N1, N2>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N1: Debug, N2: Debug> Debug for Then<N1, N2>

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

Formats the value using the given formatter.

impl<'de, N1, N2> Deserialize<'de> for Then<N1, N2> where
    N1: Deserialize<'de>,
    N2: Deserialize<'de>, 

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

Deserialize this value from the given Serde deserializer.

impl<Algebra, N1, N2> Net<Algebra> for Then<N1, N2> where
    Algebra: HasGradientReader,
    N1: Net<Algebra>,
    N2: Net<Algebra, Input = N1::Output>, 

type Input = N1::Input

Input of the network.

type Output = N2::Output

Output of the network.

type Weights = Then<N1::Weights, N2::Weights>

External representation for the weights of the network.

type GradientInfo = Then<N1::GradientInfo, N2::GradientInfo>

How to read the gradients of the weights after a backward pass.

fn eval_with_gradient_info(
    &self,
    graph: &mut Algebra,
    input: Self::Input
) -> Result<(Self::Output, Self::GradientInfo)>

fn get_weights(&self) -> Self::Weights

fn set_weights(&mut self, weights: Self::Weights) -> Result<()>

fn update_weights(&mut self, delta: Self::Weights) -> Result<()>

fn read_weight_gradients(
    &self,
    info: Self::GradientInfo,
    reader: &Algebra::GradientReader
) -> Result<Self::Weights>

fn eval(&self, graph: &mut Algebra, input: Self::Input) -> Result<Self::Output>

fn map<F, O>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: Fn(&mut Algebra, Self::Output) -> Result<O>, 

fn using<N>(self, net: N) -> Using<Self, N> where
    Self: Sized,
    N: Net<Algebra, Input = ()>, 

fn then<N>(self, net: N) -> Then<Self, N> where
    Self: Sized,
    N: Net<Algebra, Input = Self::Output>, 

fn and<N>(self, net: N) -> (Self, N) where
    Self: Sized,
    N: Net<Algebra>, 

impl<N1, N2> Serialize for Then<N1, N2> where
    N1: Serialize,
    N2: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<T, W1, W2> WeightOps<T> for Then<W1, W2> where
    T: Copy,
    W1: WeightOps<T>,
    W2: WeightOps<T>, 

fn add_assign(&mut self, other: Self) -> Result<()>

fn scale(&self, rhs: T) -> Self