Struct gad::net::WeightData

pub struct WeightData<Data, Algebra> { /* fields omitted */ }

A network that takes no inputs and always returns the weights.

Implementations

impl<Data, Algebra> WeightData<Data, Algebra>

pub fn new(data: Data) -> Self

pub fn get(&self) -> &Data

Trait Implementations

impl<Data: Clone, Algebra: Clone> Clone for WeightData<Data, Algebra>

fn clone(&self) -> WeightData<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 WeightData<Data, Algebra>

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

Formats the value using the given formatter.

impl<Data, Value, Algebra> Net<Algebra> for WeightData<Data, Algebra> where
    Algebra: HasGradientReader + CoreAlgebra<Data, Value = Value>,
    Data: Clone + HasDims + AddAssign,
    Value: HasGradientId,
    Data::Dims: Clone + PartialEq + Debug,
    Algebra::GradientReader: GradientReader<Value::GradientId, Data>, 

type Input = ()

Input of the network.

type Output = Value

Output of the network.

type Weights = Data

External representation for the weights of the network.

type GradientInfo = Value::GradientId

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