Struct gad::net_ext::SquareLoss

pub struct SquareLoss<N, Data>(_, _);

The result of SingleOutputNet::add_square_loss.

Trait Implementations

impl<N: Clone, Data: Clone> Clone for SquareLoss<N, Data>

fn clone(&self) -> SquareLoss<N, Data>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: Debug, Data: Debug> Debug for SquareLoss<N, Data>

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

Formats the value using the given formatter.

impl<'de, N, Data> Deserialize<'de> for SquareLoss<N, Data> where
    N: Deserialize<'de>, 

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

Deserialize this value from the given Serde deserializer.

impl<Data, Algebra, N> Net<Algebra> for SquareLoss<N, Data> where
    Algebra: HasGradientReader + CoreAlgebra<Data, Value = N::Output> + ArrayAlgebra<N::Output> + ArithAlgebra<N::Output> + MatrixAlgebra<N::Output>,
    N: Net<Algebra>,
    Data: HasDims,
    N::Output: HasDims<Dims = Data::Dims>,
    Data::Dims: Clone + PartialEq + Debug, 

type Input = (N::Input, Data)

Input of the network.

type Output = <Algebra as ArrayAlgebra<N::Output>>::Scalar

Output of the network.

type Weights = N::Weights

External representation for the weights of the network.

type GradientInfo = N::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,
    store: &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<N, Data> Serialize for SquareLoss<N, Data> where
    N: Serialize, 

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

Serialize this value into the given Serde serializer.