Struct gad::net::InputData

pub struct InputData<Data, Algebra> where
    Data: HasDims,  { /* fields omitted */ }

A network that takes a single user data as input and returns it (after a dimension check).

Implementations

impl<Data, Algebra> InputData<Data, Algebra> where
    Data: HasDims, 

pub fn new(dims: Data::Dims) -> Self

Trait Implementations

impl<Data: Clone, Algebra: Clone> Clone for InputData<Data, Algebra> where
    Data: HasDims,
    Data::Dims: Clone, 

fn clone(&self) -> InputData<Data, Algebra>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Data: Debug, Algebra: Debug> Debug for InputData<Data, Algebra> where
    Data: HasDims,
    Data::Dims: Debug, 

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

Formats the value using the given formatter.

impl<Data, Value, Dims, Algebra> Net<Algebra> for InputData<Data, Algebra> where
    Algebra: HasGradientReader + CoreAlgebra<Data, Value = Value>,
    Data: HasDims<Dims = Dims>,
    Dims: Clone + PartialEq + Debug, 

type Input = Data

Input of the network.

type Output = Value

Output of the network.

type Weights = ()

External representation for the weights of the network.

type 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>,